@apmantza/greedysearch-pi 2.1.3 → 2.1.5

package/docs/usage.md

@@ -0,0 +1,69 @@
+# Usage Guide
+
+GreedySearch registers one Pi tool: `greedy_search`.
+
+## Common Calls
+
+```js
+greedy_search({ query: "React 19 changes" });
+greedy_search({ query: "React 19 changes", synthesize: true });
+greedy_search({ query: "Prisma vs Drizzle", engine: "perplexity" });
+greedy_search({ query: "What is Redis?", depth: "research", maxSources: 5 });
+```
+
+## Parameters
+
+### Common
+
+- `query` — required search/research question.
+- `fullAnswer` — return complete engine output instead of a preview.
+- `headless` — defaults to `true`; set to `false` to show Chrome.
+- `visible` / `alwaysVisible` — force visible Chrome for this run.
+
+### Normal Search
+
+- `engine` — `all` by default. Supported individual engines:
+  `perplexity`, `google`, `chatgpt`, `gemini`, `semantic-scholar`,
+  `logically`, and `bing`.
+- `synthesize` — for `engine: "all"`, synthesize fetched sources with the
+  configured synthesizer.
+- `synthesizer` — `gemini` or `chatgpt`.
+- `depth` — legacy `fast` / `standard` / `deep` aliases are still accepted;
+  prefer `synthesize` for normal search.
+
+### Research
+
+- `depth: "research"` — run the iterative research workflow.
+- `breadth` — actions per round, 1-5.
+- `iterations` — rounds, 1-3.
+- `maxSources` — fetched source cap, 3-12.
+- `researchOutDir` — custom bundle directory.
+- `writeResearchBundle` — write the bundle to disk; default `true`.
+
+## Search Modes
+
+- **Individual engine** — calls one engine and returns its answer/sources.
+- **Grounded all-engine search** — fans out to configured engines, ranks
+  sources, fetches top source content, and returns confidence metadata.
+- **All + synthesis** — adds a synthesis pass over engine answers and fetched
+  source evidence.
+- **Research** — runs planning, searches, source fetching, learning extraction,
+  citation audit, and bundle writing.
+
+## Configuration
+
+Configure all-engine fan-out and synthesis in `~/.pi/greedyconfig`:
+
+```json
+{
+  "engines": ["perplexity", "google", "chatgpt", "gemini"],
+  "synthesizer": "gemini"
+}
+```
+
+`semantic-scholar` and `logically` are opt-in research engines. They remain
+available as individual engines and can be added to `engines` when you want them
+in normal `engine: "all"` fan-out.
+
+Deep research child searches reuse the configured `engines` list and pass query
+text through stdin to avoid leaking prompts in process arguments.

package/extractors/chatgpt.mjs

@@ -25,7 +25,6 @@ import {
 	prepareArgs,
 	validateQuery,
 	waitForSelector,
-	waitForStreamComplete,
 } from "./common.mjs";
 import { dismissConsent, handleVerification } from "./consent.mjs";
 
@@ -131,14 +130,96 @@ const CHATGPT_RESPONSE_SELECTOR = String.raw`(() => {
  *                      and resolve quickly because the entire response
  *                      actually has finished.
  */
-async function waitForResponse(tab, timeoutMs = 20000) {
-	return waitForStreamComplete(tab, {
-		timeout: timeoutMs,
-		interval: 600,
-		stableRounds: 6,
-		minLength: 1,
-		selector: CHATGPT_RESPONSE_SELECTOR,
-	});
+async function bringToFront(tab, { required = false } = {}) {
+	try {
+		await cdp(["evalraw", tab, "Page.bringToFront", "{}"], 5000);
+		return true;
+	} catch (error) {
+		console.error(`[chatgpt] bringToFront failed: ${error.message}`);
+		if (required) throw error;
+		return false;
+	}
+}
+
+async function waitForResponse(tab, timeoutMs = 35000) {
+	await bringToFront(tab, { required: true });
+	let foregroundAttempts = 0;
+	let foregroundInFlight = false;
+	const keepForeground = setInterval(() => {
+		if (foregroundInFlight) return;
+		if (foregroundAttempts >= 8) {
+			console.error("[chatgpt] stopping foreground keepalive after 8 attempts");
+			clearInterval(keepForeground);
+			return;
+		}
+		foregroundAttempts++;
+		foregroundInFlight = true;
+		bringToFront(tab).finally(() => {
+			foregroundInFlight = false;
+		});
+	}, 4000);
+	try {
+		const code = String.raw`
+		new Promise((resolve, reject) => {
+			const _deadline = Date.now() + ${timeoutMs};
+			const _baseInterval = 700;
+			const _stableRounds = 5;
+			let _lastLen = -1;
+			let _stableCount = 0;
+
+			function _jitter(ms) {
+				return Math.max(50, ms + (Math.random() * ms * 0.4 - ms * 0.2));
+			}
+
+			function _assistantAfterLastUser() {
+				const all = document.querySelectorAll('[data-message-author-role]');
+				let lastUserIdx = -1;
+				for (let i = 0; i < all.length; i++) {
+					if (all[i].getAttribute('data-message-author-role') === 'user') lastUserIdx = i;
+				}
+				if (lastUserIdx < 0) return null;
+				let assistant = null;
+				for (let i = lastUserIdx + 1; i < all.length; i++) {
+					if (all[i].getAttribute('data-message-author-role') === 'assistant') assistant = all[i];
+				}
+				return assistant;
+			}
+
+			function _poll() {
+				try {
+					const el = _assistantAfterLastUser();
+					const text = (el?.innerText || '').trim();
+					const len = text.length;
+					const streaming = !!el?.querySelector('.streaming-animation,[data-is-streaming="true"]') ||
+						!!document.querySelector('button[data-testid="stop-button"], button[aria-label="Stop generating"], button[aria-label*="Stop"]');
+					if (len >= 1 && !streaming) {
+						if (len === _lastLen) {
+							_stableCount++;
+							if (_stableCount >= _stableRounds) { resolve(len); return; }
+						} else {
+							_lastLen = len;
+							_stableCount = 0;
+						}
+					} else if (len !== _lastLen) {
+						_lastLen = len;
+						_stableCount = 0;
+					}
+					if (Date.now() < _deadline) setTimeout(_poll, _jitter(_baseInterval));
+					else if (_lastLen >= 1 && !streaming) resolve(_lastLen);
+					else reject(new Error('ChatGPT response did not finish streaming within ${timeoutMs}ms'));
+				} catch (e) { reject(e); }
+			}
+			_poll();
+		})`;
+		const lenStr = await cdp(["eval", tab, code], timeoutMs + 10000);
+		const len = parseInt(lenStr, 10) || 0;
+		if (len >= 1) return len;
+		throw new Error(
+			`ChatGPT response did not finish streaming within ${timeoutMs}ms`,
+		);
+	} finally {
+		clearInterval(keepForeground);
+	}
 }
 
 /**
@@ -211,6 +292,8 @@ async function extractAnswerFromDom(tab) {
 					skipped: 'no-assistant-response',
 				});
 			}
+			const streaming = !!assistant.querySelector('.streaming-animation,[data-is-streaming="true"]') ||
+				!!document.querySelector('button[data-testid="stop-button"], button[aria-label="Stop generating"], button[aria-label*="Stop"]');
 			const answer = (assistant.innerText || assistant.textContent || '').trim();
 			const seen = new Set();
 			const sources = [];
@@ -222,13 +305,16 @@ async function extractAnswerFromDom(tab) {
 				sources.push({ title, url });
 				if (sources.length >= 10) break;
 			}
-			return JSON.stringify({ answer, sources });
+			return JSON.stringify({ answer, sources, streaming });
 		})()
 	`,
 	]);
 	try {
 		return JSON.parse(raw);
-	} catch {
+	} catch (error) {
+		console.error(
+			`[chatgpt] DOM fallback JSON parse failed (${raw.length} chars): ${error.message}`,
+		);
 		return { answer: "", sources: [], skipped: "parse-error" };
 	}
 }
@@ -307,6 +393,9 @@ async function extractAnswer(tab, env) {
 	let domFallback = null;
 	if (!answer) {
 		domFallback = await extractAnswerFromDom(tab);
+		if (domFallback.streaming) {
+			return { answer: "", sources: [], skipped: "still-streaming" };
+		}
 		answer = domFallback.answer;
 		env.fallbackUsed = answer ? "dom" : null;
 	}
@@ -335,15 +424,25 @@ async function extractAnswer(tab, env) {
 			trimmed.length <= 50 &&
 			/\s|[.,!?;:]/.test(trimmed);
 		const looksLikeLongAnswer = trimmed.length > 50;
-		if (!looksLikeShortAnswer && !looksLikeLongAnswer) {
+		const words = trimmed.split(/\s+/).filter(Boolean);
+		const domainRepeats = (
+			trimmed.match(/\b[a-z0-9-]+\.(?:com|org|net|dev|io)\b/gi) || []
+		).length;
+		const looksLikeCitationStub =
+			domainRepeats >= 4 &&
+			domainRepeats >= Math.max(3, Math.floor(words.length / 3));
+		if (
+			(!looksLikeShortAnswer && !looksLikeLongAnswer) ||
+			looksLikeCitationStub
+		) {
 			console.error(
-				`[chatgpt] DOM fallback answer suspiciously short (${trimmed.length} chars: ${JSON.stringify(trimmed.slice(0, 80))}) — returning empty for caller to retry`,
+				`[chatgpt] DOM fallback answer suspicious (${trimmed.length} chars, domainRepeats=${domainRepeats}: ${JSON.stringify(trimmed.slice(0, 80))}) — returning empty for caller to retry`,
 			);
 			env.fallbackUsed = null;
 			return {
 				answer: "",
 				sources: [],
-				skipped: "header-stub",
+				skipped: looksLikeCitationStub ? "citation-stub" : "header-stub",
 			};
 		}
 	}
@@ -518,15 +617,20 @@ async function main() {
 		if (!answer) {
 			env.blockedBy = "no-response";
 			env.skipped = skipped || null;
-			throw new Error(
-				skipped === "no-user-message"
-					? "ChatGPT still on homepage — query was not submitted"
-					: skipped === "no-assistant-response"
-						? "ChatGPT did not return an assistant response after submit"
-						: skipped === "header-stub"
-							? "ChatGPT response appeared to be a header stub after 3 retries — assistant never rendered the body"
-							: "ChatGPT returned no answer — assistant never responded",
-			);
+			let message = "ChatGPT returned no answer — assistant never responded";
+			if (skipped === "no-user-message") {
+				message = "ChatGPT still on homepage — query was not submitted";
+			} else if (skipped === "no-assistant-response") {
+				message = "ChatGPT did not return an assistant response after submit";
+			} else if (
+				skipped === "header-stub" ||
+				skipped === "citation-stub" ||
+				skipped === "still-streaming"
+			) {
+				message =
+					"ChatGPT response did not finish rendering after 3 retries — assistant never rendered the body";
+			}
+			throw new Error(message);
 		}
 		logStage(env, "done", startTime);
 

package/extractors/common.mjs

@@ -129,7 +129,18 @@ export async function getOrOpenTab(tabPrefix) {
 		"Target.createTarget",
 		'{"url":"about:blank"}',
 	]);
-	const { targetId } = JSON.parse(raw);
+	let createdTarget;
+	try {
+		createdTarget = JSON.parse(raw);
+	} catch (error) {
+		throw new Error(
+			`Target.createTarget returned invalid JSON: ${error.message}`,
+		);
+	}
+	const { targetId } = createdTarget;
+	if (!targetId) {
+		throw new Error("Target.createTarget did not return a targetId");
+	}
 	await cdp(["list"]); // refresh cache
 	const tid = targetId.slice(0, 8);
 	// Inject stealth patches for anti-detection coverage (both headless + visible).
@@ -221,40 +232,62 @@ export async function injectHeadlessStealth(tab) {
   try { delete window._phantom; } catch(_) {}
   try { delete window.Buffer; } catch(_) {}
 
-  // Real Chrome without automation does not expose a useful webdriver value.
-  // A literal false value is itself a common stealth tell; prefer undefined and
-  // make the descriptor configurable like native browser properties.
-  Object.defineProperty(navigator, 'webdriver', { get: () => undefined, configurable: true });
+  // Real Chrome without automation should not expose navigator.webdriver at all.
+  // A literal false or an own-property getter returning undefined is itself a
+  // common stealth tell; remove both instance and prototype properties when the
+  // descriptor is configurable (as it is with --disable-blink-features).
+  try { delete navigator.webdriver; } catch(_) {}
+  try { delete Navigator.prototype.webdriver; } catch(_) {}
   Object.defineProperty(navigator, 'vendor', { get: () => 'Google Inc.', configurable: true });
   Object.defineProperty(navigator, 'platform', { get: () => 'Win32', configurable: true });
   Object.defineProperty(navigator, 'maxTouchPoints', { get: () => 0, configurable: true });
   Object.defineProperty(navigator, 'pdfViewerEnabled', { get: () => true, configurable: true });
+  Object.defineProperty(navigator, 'productSub', { get: () => '20030107', configurable: true });
+  Object.defineProperty(navigator, 'product', { get: () => 'Gecko', configurable: true });
+  var __greedyMimeTypes = null;
+  function __makeMimeTypes() {
+    var pdf = { type: 'application/pdf', suffixes: 'pdf', description: 'Portable Document Format', enabledPlugin: null };
+    var textPdf = { type: 'text/pdf', suffixes: 'pdf', description: 'Portable Document Format', enabledPlugin: null };
+    try { Object.setPrototypeOf(pdf, MimeType.prototype); } catch(_) {}
+    try { Object.setPrototypeOf(textPdf, MimeType.prototype); } catch(_) {}
+    var m = [pdf, textPdf];
+    try { Object.setPrototypeOf(m, MimeTypeArray.prototype); } catch(_) {}
+    m.item = function item(i) { return this[i] || null; };
+    m.namedItem = function namedItem(name) { return Array.prototype.find.call(this, function(x) { return x && x.type === name; }) || null; };
+    return m;
+  }
   Object.defineProperty(navigator, 'plugins', {
     get: () => {
-      var p = [
-        { name: 'Chrome PDF Plugin', filename: 'internal-pdf-viewer', description: 'Portable Document Format' },
-        { name: 'Chrome PDF Viewer', filename: 'mhjfbmdgcfjbbpaeojofohoefgiehjai', description: '' },
-        { name: 'Native Client', filename: 'internal-nacl-plugin', description: '' },
-      ];
-      p.length = 3;
+      __greedyMimeTypes = __greedyMimeTypes || __makeMimeTypes();
+      var plugin0 = { name: 'Chrome PDF Plugin', filename: 'internal-pdf-viewer', description: 'Portable Document Format' };
+      var plugin1 = { name: 'Chrome PDF Viewer', filename: 'mhjfbmdgcfjbbpaeojofohoefgiehjai', description: '' };
+      var plugin2 = { name: 'Native Client', filename: 'internal-nacl-plugin', description: '' };
+      try { Object.setPrototypeOf(plugin0, Plugin.prototype); } catch(_) {}
+      try { Object.setPrototypeOf(plugin1, Plugin.prototype); } catch(_) {}
+      try { Object.setPrototypeOf(plugin2, Plugin.prototype); } catch(_) {}
+      var p = [plugin0, plugin1, plugin2];
+      p.item = function item(i) { return this[i] || null; };
+      p.namedItem = function namedItem(name) { return Array.prototype.find.call(this, function(x) { return x && x.name === name; }) || null; };
+      p.refresh = function refresh() {};
+      try { Object.setPrototypeOf(p, PluginArray.prototype); } catch(_) {}
+      try {
+        __greedyMimeTypes[0].enabledPlugin = p[0];
+        __greedyMimeTypes[1].enabledPlugin = p[0];
+      } catch(_) {}
       return p;
     },
+    configurable: true,
   });
   Object.defineProperty(navigator, 'mimeTypes', {
     get: () => {
-      var m = [
-        { type: 'application/pdf', suffixes: 'pdf', description: 'Portable Document Format', enabledPlugin: null },
-        { type: 'text/pdf', suffixes: 'pdf', description: 'Portable Document Format', enabledPlugin: null },
-      ];
-      m.item = function(i) { return m[i] || null; };
-      m.namedItem = function(name) { return m.find(function(x) { return x.type === name; }) || null; };
-      return m;
+      __greedyMimeTypes = __greedyMimeTypes || __makeMimeTypes();
+      return __greedyMimeTypes;
     },
     configurable: true,
   });
   Object.defineProperty(navigator, 'languages', { get: () => ['en-US', 'en'], configurable: true });
   try {
-    Object.defineProperty(navigator, 'connection', { get: () => ({ effectiveType: '4g', rtt: 50, downlink: 10, saveData: false }), configurable: true });
+    Object.defineProperty(navigator, 'connection', { get: () => ({ effectiveType: '4g', rtt: 50, downlink: 10, downlinkMax: Infinity, saveData: false }), configurable: true });
   } catch(_) {}
   if (!navigator.mediaDevices) {
     Object.defineProperty(navigator, 'mediaDevices', {
@@ -270,6 +303,18 @@ export async function injectHeadlessStealth(tab) {
       configurable: true,
     });
   }
+  // ── Missing platform APIs (headless often lacks these) ─
+  try {
+    if (!navigator.share) {
+      navigator.share = function() { return Promise.reject(new Error('NotAllowedError')); };
+    }
+  } catch(_) {}
+  try {
+    if (!navigator.contentIndex) {
+      Object.defineProperty(navigator, 'contentIndex', { get: () => ({ add: function() {}, delete: function() {}, getAll: function() { return Promise.resolve([]); } }), configurable: true });
+    }
+  } catch(_) {}
+
   if (!window.chrome) {
     window.chrome = {
       app: { isInstalled: false, InstallState: {}, RunningState: {} },
@@ -277,8 +322,8 @@ export async function injectHeadlessStealth(tab) {
         OnInstalledReason: {}, OnRestartRequiredReason: {}, PlatformArch: {}, PlatformNaclArch: {}, PlatformOs: {}, RequestUpdateCheckStatus: {},
         connect: () => ({}), sendMessage: () => {}, onMessage: { addListener: () => {} }
       },
-      loadTimes: () => ({}),
-      csi: () => ({}),
+      loadTimes: function() { return { requestTime: 0, startLoadTime: Date.now() - 5000, commitLoadTime: Date.now() - 3000, finishDocumentLoadTime: Date.now() - 2000, finishLoadTime: Date.now() - 1000, firstPaintTime: Date.now() - 800, navigationType: 'Other', wasFetchedViaSpdy: true, wasNpnNegotiated: true, npnNegotiatedProtocol: 'h2', wasAlternateProtocolAvailable: false, connectionInfo: 'http/2' }; },
+      csi: function() { var t = Date.now(); return { onloadT: t - 2000, startE: t - 5000, pageT: 'back', tran: 2 }; },
     };
   }
   var __greedyNativeFns = [];
@@ -299,6 +344,19 @@ export async function injectHeadlessStealth(tab) {
       return getParam.call(this, p);
     });
   } catch(_) {}
+  // ── WebGL readPixels noise ──────────────────────────
+  // CreepJS and other fingerprinters draw content with WebGL and read back the
+  // rendered pixels. Adding subtle noise breaks rendering-based fingerprinting.
+  try {
+    var origReadPixels = WebGLRenderingContext.prototype.readPixels;
+    WebGLRenderingContext.prototype.readPixels = __markNative(function readPixels(x, y, width, height, format, type, pixels) {
+      var result = origReadPixels.call(this, x, y, width, height, format, type, pixels);
+      if (pixels && pixels.length > 0) {
+        pixels[0] ^= 1;
+      }
+      return result;
+    });
+  } catch(_) {}
   Object.defineProperty(navigator, 'hardwareConcurrency', { get: () => 8, configurable: true });
   Object.defineProperty(navigator, 'deviceMemory', { get: () => 8, configurable: true });
 
@@ -306,7 +364,7 @@ export async function injectHeadlessStealth(tab) {
   // Headless rendering engines produce slightly different canvas output
   // than headed Chrome. Subtle noise breaks hash-based fingerprinting.
   try {
-    var __canvasNoise = ((Date.now() % 997) + Math.floor(Math.random() * 997)) & 1;
+    var __canvasNoise = ((Date.now() & 0xFF) | 1);
     var origFill = CanvasRenderingContext2D.prototype.fillText;
     CanvasRenderingContext2D.prototype.fillText = __markNative(function fillText() {
       this.globalAlpha = 0.9995;
@@ -325,15 +383,39 @@ export async function injectHeadlessStealth(tab) {
     HTMLCanvasElement.prototype.toDataURL = __markNative(function toDataURL() {
       var ctx = this.getContext('2d');
       if (ctx) {
-        // Add 1px noise pixel in corner (invisible but changes hash)
-        var imgData = ctx.getImageData(0, 0, 1, 1);
-        if (imgData) imgData.data[0] ^= __canvasNoise;
-        ctx.putImageData(imgData, 0, 0);
+        // Spread noise across canvas to break hash-based fingerprinting.
+        // Uses a deterministic pattern so it's consistent per page load
+        // but varies between sessions.
+        var w = this.width, h = this.height;
+        if (w > 0 && h > 0) {
+          var imgData = ctx.getImageData(0, 0, Math.min(w, 4), Math.min(h, 4));
+          if (imgData && imgData.data) {
+            for (var __i = 0; __i < imgData.data.length; __i += 4) {
+              imgData.data[__i] ^= (__canvasNoise + __i) & 0xFF;
+            }
+            ctx.putImageData(imgData, 0, 0);
+          }
+        }
       }
       return origToDataURL.apply(this, arguments);
     });
   } catch(_) {}
 
+  // ── AudioContext fingerprint noise ────────────────────
+  // Headless Chrome's AudioContext produces slightly different output.
+  // Subtle noise breaks audio-based fingerprinting.
+  try {
+    var __audioSeed = ((Date.now() & 0x1F) | 1);
+    var origGetChannelData = AudioBuffer.prototype.getChannelData;
+    AudioBuffer.prototype.getChannelData = __markNative(function getChannelData(channel) {
+      var data = origGetChannelData.call(this, channel);
+      for (var __i = 0; __i < data.length; __i += 64) {
+        data[__i] *= 0.99999;
+      }
+      return data;
+    });
+  } catch(_) {}
+
   // ── window outer dimensions ──────────────────────────
   // outerWidth/Height = 0 in headless — a well-known bot signal.
   // Mirror innerWidth/Height (set by --window-size flag) so the ratio is sane.
@@ -343,9 +425,15 @@ export async function injectHeadlessStealth(tab) {
   } catch(_) {}
 
   // ── screen properties ─────────────────────────────────
+  // Headless Chrome often reports an 800x600 screen even when the viewport is
+  // 1920x1080. Keep screen metrics internally consistent with our launch flags.
   try {
-    if (!screen.colorDepth) Object.defineProperty(screen, 'colorDepth', { get: () => 24, configurable: true });
-    if (!screen.pixelDepth) Object.defineProperty(screen, 'pixelDepth', { get: () => 24, configurable: true });
+    Object.defineProperty(screen, 'width', { get: () => 1920, configurable: true });
+    Object.defineProperty(screen, 'height', { get: () => 1080, configurable: true });
+    Object.defineProperty(screen, 'availWidth', { get: () => 1920, configurable: true });
+    Object.defineProperty(screen, 'availHeight', { get: () => 1040, configurable: true });
+    Object.defineProperty(screen, 'colorDepth', { get: () => 24, configurable: true });
+    Object.defineProperty(screen, 'pixelDepth', { get: () => 24, configurable: true });
   } catch(_) {}
 
   // ── navigator.userAgentData (UA Client Hints) ─────────

package/extractors/gemini.mjs

@@ -66,6 +66,17 @@ async function typeIntoGemini(tab, text) {
 	}
 }
 
+async function bringToFront(tab, { required = false } = {}) {
+	try {
+		await cdp(["evalraw", tab, "Page.bringToFront", "{}"], 5000);
+		return true;
+	} catch (error) {
+		console.error(`[gemini] bringToFront failed: ${error.message}`);
+		if (required) throw error;
+		return false;
+	}
+}
+
 async function scrollToBottom(tab) {
 	await cdp([
 		"eval",
@@ -93,7 +104,8 @@ async function extractAnswerFromDom(tab) {
 			new Promise((resolve) => {
 				const _deadline = Date.now() + 6000;
 				function _tryExtract() {
-					const resp = document.querySelector('model-response');
+					const responses = Array.from(document.querySelectorAll('model-response'));
+					const resp = responses[responses.length - 1];
 					if (resp) {
 						const text = (resp.innerText || resp.textContent || '').trim();
 						const idx = text.indexOf('\n');
@@ -126,11 +138,32 @@ async function extractAnswerFromDom(tab) {
 	);
 	try {
 		return JSON.parse(raw);
-	} catch {
+	} catch (error) {
+		console.error(
+			`[gemini] DOM fallback JSON parse failed (${raw.length} chars): ${error.message}`,
+		);
 		return { answer: "", sources: [] };
 	}
 }
 
+async function clickLatestModelResponseCopy(tab) {
+	return cdp([
+		"eval",
+		tab,
+		`(() => {
+			const responses = Array.from(document.querySelectorAll('model-response'));
+			const resp = responses[responses.length - 1];
+			if (!resp) return 'no-model-response';
+			const buttons = Array.from(resp.querySelectorAll('${S.copyButton}'));
+			const nonCodeButtons = buttons.filter((btn) => !btn.closest('pre, code, code-block, .code-block, .code-container'));
+			const btn = nonCodeButtons[nonCodeButtons.length - 1] || buttons[buttons.length - 1];
+			if (!btn) return 'no-copy-button';
+			btn.click();
+			return 'clicked';
+		})()`,
+	]);
+}
+
 async function extractAnswer(tab, query = "") {
 	const queryNorm = query.toLowerCase().trim();
 
@@ -151,7 +184,8 @@ async function extractAnswer(tab, query = "") {
 			"eval",
 			tab,
 			String.raw`(() => {
-				const r = document.querySelector('model-response');
+				const responses = Array.from(document.querySelectorAll('model-response'));
+				const r = responses[responses.length - 1];
 				if (!r) return false;
 				const t = (r.innerText || '').trim();
 				// Must have content beyond the locale-specific label
@@ -174,18 +208,7 @@ async function extractAnswer(tab, query = "") {
 	// not the absolute last copy button on the page. The page has many
 	// copy icons (copy link, copy code, etc.) and the last one is not
 	// always the assistant's response copy button.
-	await cdp([
-		"eval",
-		tab,
-		`(() => {
-			const resp = document.querySelector('model-response');
-			if (!resp) return 'no-model-response';
-			const btn = resp.querySelector('${S.copyButton}');
-			if (!btn) return 'no-copy-button';
-			btn.click();
-			return 'clicked';
-		})()`,
-	]);
+	await clickLatestModelResponseCopy(tab);
 	await new Promise((r) => setTimeout(r, 600));
 
 	let answer = await cdp(["eval", tab, `window.${GLOBAL_VAR} || ''`]);
@@ -200,35 +223,32 @@ async function extractAnswer(tab, query = "") {
 	) {
 		console.error("[gemini] Clipboard echoed query, retrying in 2s...");
 		await new Promise((r) => setTimeout(r, 2000));
-		await cdp([
-			"eval",
-			tab,
-			`(() => {
-				const resp = document.querySelector('model-response');
-				if (!resp) return 'no-model-response';
-				const btn = resp.querySelector('${S.copyButton}');
-				if (!btn) return 'no-copy-button';
-				btn.click();
-				return 'clicked';
-			})()`,
-		]);
+		await clickLatestModelResponseCopy(tab);
 		await new Promise((r) => setTimeout(r, 600));
 		answer = await cdp(["eval", tab, `window.${GLOBAL_VAR} || ''`]);
 	}
 
-	// DOM fallback: if the clipboard is empty or still echoes the query,
-	// read the model-response innerText directly. This handles the case
-	// where the copy button never rendered (response never appeared) or
-	// the click didn't fire.
+	// DOM fallback: if clipboard is empty, echoes the query, or looks like a
+	// short snippet, read the model-response innerText directly. Skip the
+	// fallback when native copy already returned a substantial full answer.
 	let domFallback = null;
-	if (
-		!answer ||
-		(queryNorm &&
-			(answer.toLowerCase().trim() === queryNorm ||
-				answer.trim().length < queryNorm.length))
-	) {
+	const answerText = answer?.trim() || "";
+	const clipboardLooksEchoed =
+		queryNorm &&
+		(answerText.toLowerCase() === queryNorm ||
+			answerText.length < queryNorm.length);
+	const clipboardLooksComplete =
+		answerText.length > 500 && !clipboardLooksEchoed;
+	if (!clipboardLooksComplete) {
 		domFallback = await extractAnswerFromDom(tab);
-		if (domFallback.answer) {
+		const domExtendsClipboard =
+			answerText &&
+			domFallback.answer.includes(answerText) &&
+			domFallback.answer.length > answerText.length * 2;
+		if (
+			domFallback.answer &&
+			(!answerText || clipboardLooksEchoed || domExtendsClipboard)
+		) {
 			answer = domFallback.answer;
 		}
 	}
@@ -304,6 +324,7 @@ async function main() {
 		await waitForSelector(tab, S.input, 8000, TIMING.inputPoll);
 		await new Promise((r) => setTimeout(r, jitter(TIMING.postClick)));
 
+		await bringToFront(tab, { required: true });
 		await injectClipboardInterceptor(tab, GLOBAL_VAR);
 		await typeIntoGemini(tab, query);
 		await new Promise((r) => setTimeout(r, jitter(TIMING.postType)));
@@ -316,8 +337,10 @@ async function main() {
 
 		// Wait for Gemini's response to finish streaming before extracting.
 		// Periodic scrolling keeps lazy-loaded content triggered in the viewport.
+		await bringToFront(tab);
 		let pollTick = 0;
 		const scrollInterval = setInterval(() => {
+			bringToFront(tab).catch(() => null);
 			if (++pollTick % 10 === 0) scrollToBottom(tab).catch(() => null);
 		}, 6000);
 		try {
@@ -325,6 +348,8 @@ async function main() {
 				timeout: 45000,
 				stableRounds: 5,
 				minLength: 60,
+				selector:
+					"(() => { const responses = Array.from(document.querySelectorAll('model-response')); return responses[responses.length - 1]; })()",
 			});
 		} finally {
 			clearInterval(scrollInterval);