@apmantza/greedysearch-pi 1.7.2 → 1.7.4

package/bin/search.mjs

@@ -32,19 +32,19 @@ import http from "node:http";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { fetchSourceHttp, shouldUseBrowser } from "../src/fetcher.mjs";
-import { fetchGitHubContent, parseGitHubUrl } from "../src/github.mjs";
-import { trimContentHeadTail } from "../src/utils/content.mjs";
+import { fetchSourceHttp, shouldUseBrowser } from "../src/fetcher.mjs";
+import { fetchGitHubContent, parseGitHubUrl } from "../src/github.mjs";
+import { trimContentHeadTail } from "../src/utils/content.mjs";
 
 const __dir = dirname(fileURLToPath(import.meta.url));
 const CDP = join(__dir, "cdp.mjs");
 const PAGES_CACHE = `${tmpdir().replace(/\\/g, "/")}/cdp-pages.json`;
 
-const GREEDY_PORT = 9222;
-const SOURCE_FETCH_CONCURRENCY = Math.max(
-	1,
-	parseInt(process.env.GREEDY_FETCH_CONCURRENCY || "2", 10) || 2,
-);
+const GREEDY_PORT = 9222;
+const SOURCE_FETCH_CONCURRENCY = Math.max(
+	1,
+	parseInt(process.env.GREEDY_FETCH_CONCURRENCY || "2", 10) || 2,
+);
 
 const ENGINES = {
 	perplexity: "perplexity.mjs",
@@ -752,27 +752,6 @@ async function getAnyTab() {
 	return first.slice(0, 8);
 }
 
-async function _getOrReuseBlankTab() {
-	// Reuse an existing about:blank tab rather than always creating a new one
-	const listOut = await cdp(["list"]);
-	const lines = listOut.split("\n").filter(Boolean);
-	for (const line of lines) {
-		if (line.includes("about:blank")) {
-			return line.slice(0, 8); // prefix of the blank tab's targetId
-		}
-	}
-	// No blank tab — open a new one
-	const anchor = await getAnyTab();
-	const raw = await cdp([
-		"evalraw",
-		anchor,
-		"Target.createTarget",
-		'{"url":"about:blank"}',
-	]);
-	const { targetId } = JSON.parse(raw);
-	return targetId;
-}
-
 async function openNewTab() {
 	const anchor = await getAnyTab();
 	const raw = await cdp([
@@ -785,11 +764,6 @@ async function openNewTab() {
 	return targetId;
 }
 
-async function _getOrOpenEngineTab(engine) {
-	await cdp(["list"]);
-	return getFullTabFromCache(engine) || openNewTab();
-}
-
 async function activateTab(targetId) {
 	try {
 		const anchor = await getAnyTab();
@@ -844,13 +818,13 @@ function runExtractor(
 		...(tabPrefix ? ["--tab", tabPrefix] : []),
 		...(short ? ["--short"] : []),
 	];
-	return new Promise((resolve, reject) => {
-		const proc = spawn(
-			"node",
-			[join(__dir, "..", "extractors", script), query, ...extraArgs],
-			{
-				stdio: ["ignore", "pipe", "pipe"],
-				env: { ...process.env, CDP_PROFILE_DIR: GREEDY_PROFILE_DIR },
+	return new Promise((resolve, reject) => {
+		const proc = spawn(
+			"node",
+			[join(__dir, "..", "extractors", script), query, ...extraArgs],
+			{
+				stdio: ["ignore", "pipe", "pipe"],
+				env: { ...process.env, CDP_PROFILE_DIR: GREEDY_PROFILE_DIR },
 			},
 		);
 		let out = "";
@@ -1032,62 +1006,62 @@ async function fetchSourceContentBrowser(url, maxChars = 8000) {
 	}
 }
 
-async function fetchMultipleSources(
-	sources,
-	maxSources = 5,
-	maxChars = 8000,
-	concurrency = SOURCE_FETCH_CONCURRENCY,
-) {
-	const toFetch = sources.slice(0, maxSources);
-	if (toFetch.length === 0) return [];
-
-	const workerCount = Math.min(
-		toFetch.length,
-		Math.max(1, parseInt(String(concurrency), 10) || SOURCE_FETCH_CONCURRENCY),
-	);
-
-	process.stderr.write(
-		`[greedysearch] Fetching content from ${toFetch.length} sources via HTTP (concurrency ${workerCount})...\n`,
-	);
-
-	const fetched = new Array(toFetch.length);
-	let nextIndex = 0;
-	let completed = 0;
-
-	async function worker() {
-		while (true) {
-			const index = nextIndex++;
-			if (index >= toFetch.length) return;
-
-			const s = toFetch[index];
-			const url = s.canonicalUrl || s.url;
-			process.stderr.write(
-				`[greedysearch] [${index + 1}/${toFetch.length}] Fetching: ${url.slice(0, 60)}...\n`,
-			);
-
-			const result = await fetchSourceContent(url, maxChars);
-			fetched[index] = {
-				id: s.id,
-				...result,
-			};
-
-			if (result.content && result.content.length > 100) {
-				process.stderr.write(
-					`[greedysearch] ✓ ${result.source}: ${result.content.length} chars\n`,
-				);
-			} else if (result.error) {
-				process.stderr.write(`[greedysearch] ✗ ${result.error.slice(0, 80)}\n`);
-			}
-
-			completed += 1;
-			process.stderr.write(`PROGRESS:fetch:${completed}/${toFetch.length}\n`);
-		}
-	}
-
-	await Promise.all(Array.from({ length: workerCount }, () => worker()));
-
-	// Log summary
-	const successful = fetched.filter((f) => f.content && f.content.length > 100);
+async function fetchMultipleSources(
+	sources,
+	maxSources = 5,
+	maxChars = 8000,
+	concurrency = SOURCE_FETCH_CONCURRENCY,
+) {
+	const toFetch = sources.slice(0, maxSources);
+	if (toFetch.length === 0) return [];
+
+	const workerCount = Math.min(
+		toFetch.length,
+		Math.max(1, parseInt(String(concurrency), 10) || SOURCE_FETCH_CONCURRENCY),
+	);
+
+	process.stderr.write(
+		`[greedysearch] Fetching content from ${toFetch.length} sources via HTTP (concurrency ${workerCount})...\n`,
+	);
+
+	const fetched = new Array(toFetch.length);
+	let nextIndex = 0;
+	let completed = 0;
+
+	async function worker() {
+		while (true) {
+			const index = nextIndex++;
+			if (index >= toFetch.length) return;
+
+			const s = toFetch[index];
+			const url = s.canonicalUrl || s.url;
+			process.stderr.write(
+				`[greedysearch] [${index + 1}/${toFetch.length}] Fetching: ${url.slice(0, 60)}...\n`,
+			);
+
+			const result = await fetchSourceContent(url, maxChars);
+			fetched[index] = {
+				id: s.id,
+				...result,
+			};
+
+			if (result.content && result.content.length > 100) {
+				process.stderr.write(
+					`[greedysearch] ✓ ${result.source}: ${result.content.length} chars\n`,
+				);
+			} else if (result.error) {
+				process.stderr.write(`[greedysearch] ✗ ${result.error.slice(0, 80)}\n`);
+			}
+
+			completed += 1;
+			process.stderr.write(`PROGRESS:fetch:${completed}/${toFetch.length}\n`);
+		}
+	}
+
+	await Promise.all(Array.from({ length: workerCount }, () => worker()));
+
+	// Log summary
+	const successful = fetched.filter((f) => f.content && f.content.length > 100);
 	const httpCount = fetched.filter((f) => f.source === "http").length;
 	const browserCount = fetched.filter((f) => f.source === "browser").length;
 
@@ -1119,14 +1093,14 @@ async function synthesizeWithGemini(
 		: buildSourceRegistry(results);
 	const prompt = buildSynthesisPrompt(query, results, sources, { grounded });
 
-	return new Promise((resolve, reject) => {
-		const extraArgs = tabPrefix ? ["--tab", String(tabPrefix)] : [];
-		const proc = spawn(
-			"node",
-			[join(__dir, "..", "extractors", "gemini.mjs"), prompt, ...extraArgs],
-			{
-				stdio: ["ignore", "pipe", "pipe"],
-				env: { ...process.env, CDP_PROFILE_DIR: GREEDY_PROFILE_DIR },
+	return new Promise((resolve, reject) => {
+		const extraArgs = tabPrefix ? ["--tab", String(tabPrefix)] : [];
+		const proc = spawn(
+			"node",
+			[join(__dir, "..", "extractors", "gemini.mjs"), prompt, ...extraArgs],
+			{
+				stdio: ["ignore", "pipe", "pipe"],
+				env: { ...process.env, CDP_PROFILE_DIR: GREEDY_PROFILE_DIR },
 			},
 		);
 		let out = "";
@@ -1166,11 +1140,11 @@ function slugify(query) {
 		.slice(0, 60);
 }
 
-function resultsDir() {
-	const dir = join(__dir, "..", "results");
-	mkdirSync(dir, { recursive: true });
-	return dir;
-}
+function resultsDir() {
+	const dir = join(__dir, "..", "results");
+	mkdirSync(dir, { recursive: true });
+	return dir;
+}
 
 function writeOutput(
 	data,
@@ -1235,57 +1209,57 @@ function probeGreedyChrome(timeoutMs = 3000) {
 // Write (or refresh) the DevToolsActivePort file for the GreedySearch Chrome so
 // cdp.mjs always connects to the right port rather than the user's main Chrome.
 // Uses atomic write (write to temp + rename) to prevent corruption from parallel processes.
-async function refreshPortFile() {
-	const LOCK_FILE = `${ACTIVE_PORT_FILE}.lock`;
-	const TEMP_FILE = `${ACTIVE_PORT_FILE}.tmp`;
-	const LOCK_STALE_MS = 5000;
-	const LOCK_WAIT_MS = 1000;
-
-	// File-based lock with exclusive create + stale lock recovery
-	const lockAcquired = await new Promise((resolve) => {
-		const start = Date.now();
-		const tryLock = () => {
-			try {
-				const payload = JSON.stringify({ pid: process.pid, ts: Date.now() });
-				writeFileSync(LOCK_FILE, payload, { encoding: "utf8", flag: "wx" });
-				resolve(true);
-			} catch (e) {
-				if (e?.code !== "EEXIST") {
-					if (Date.now() - start < LOCK_WAIT_MS) {
-						setTimeout(tryLock, 50);
-					} else {
-						resolve(false);
-					}
-					return;
-				}
-
-				try {
-					const lockRaw = readFileSync(LOCK_FILE, "utf8").trim();
-					const parsed = lockRaw.startsWith("{")
-						? JSON.parse(lockRaw)
-						: { ts: Number(lockRaw) };
-					const lockTime = Number(parsed?.ts) || 0;
-
-					if (lockTime > 0 && Date.now() - lockTime > LOCK_STALE_MS) {
-						try {
-							unlinkSync(LOCK_FILE);
-						} catch {}
-					}
-
-					if (Date.now() - start < LOCK_WAIT_MS) {
-						setTimeout(tryLock, 50);
-					} else {
-						resolve(false);
-					}
-				} catch {
-					if (Date.now() - start < LOCK_WAIT_MS) {
-						setTimeout(tryLock, 50);
-					} else {
-						resolve(false);
-					}
-				}
-			}
-		};
+async function refreshPortFile() {
+	const LOCK_FILE = `${ACTIVE_PORT_FILE}.lock`;
+	const TEMP_FILE = `${ACTIVE_PORT_FILE}.tmp`;
+	const LOCK_STALE_MS = 5000;
+	const LOCK_WAIT_MS = 1000;
+
+	// File-based lock with exclusive create + stale lock recovery
+	const lockAcquired = await new Promise((resolve) => {
+		const start = Date.now();
+		const tryLock = () => {
+			try {
+				const payload = JSON.stringify({ pid: process.pid, ts: Date.now() });
+				writeFileSync(LOCK_FILE, payload, { encoding: "utf8", flag: "wx" });
+				resolve(true);
+			} catch (e) {
+				if (e?.code !== "EEXIST") {
+					if (Date.now() - start < LOCK_WAIT_MS) {
+						setTimeout(tryLock, 50);
+					} else {
+						resolve(false);
+					}
+					return;
+				}
+
+				try {
+					const lockRaw = readFileSync(LOCK_FILE, "utf8").trim();
+					const parsed = lockRaw.startsWith("{")
+						? JSON.parse(lockRaw)
+						: { ts: Number(lockRaw) };
+					const lockTime = Number(parsed?.ts) || 0;
+
+					if (lockTime > 0 && Date.now() - lockTime > LOCK_STALE_MS) {
+						try {
+							unlinkSync(LOCK_FILE);
+						} catch {}
+					}
+
+					if (Date.now() - start < LOCK_WAIT_MS) {
+						setTimeout(tryLock, 50);
+					} else {
+						resolve(false);
+					}
+				} catch {
+					if (Date.now() - start < LOCK_WAIT_MS) {
+						setTimeout(tryLock, 50);
+					} else {
+						resolve(false);
+					}
+				}
+			}
+		};
 		tryLock();
 	});
 
@@ -1428,18 +1402,18 @@ async function main() {
 		// PARALLEL-SAFE: Always create fresh tabs for each engine to avoid race conditions
 		// when multiple "all" searches run concurrently. Previously, reusing cached tabs
 		// caused ERR_ABORTED and Uncaught errors as multiple processes fought over the same tab.
-		const engineTabs = [];
-		for (let i = 0; i < ALL_ENGINES.length; i++) {
-			if (i > 0) await new Promise((r) => setTimeout(r, 300)); // small delay between tab opens
-			const tab = await openNewTab();
-			engineTabs.push(tab);
-		}
+		const engineTabs = [];
+		for (let i = 0; i < ALL_ENGINES.length; i++) {
+			if (i > 0) await new Promise((r) => setTimeout(r, 300)); // small delay between tab opens
+			const tab = await openNewTab();
+			engineTabs.push(tab);
+		}
 
 		// All tabs assigned — run extractors in parallel
 		try {
 			const results = await Promise.allSettled(
-				ALL_ENGINES.map((e, i) =>
-					runExtractor(ENGINES[e], query, engineTabs[i], short)
+				ALL_ENGINES.map((e, i) =>
+					runExtractor(ENGINES[e], query, engineTabs[i], short)
 						.then((r) => {
 							process.stderr.write(`PROGRESS:${e}:done\n`);
 							return { engine: e, ...r };
@@ -1461,7 +1435,7 @@ async function main() {
 				}
 			}
 
-			await closeTabs(engineTabs);
+			await closeTabs(engineTabs);
 
 			// Build a canonical source registry across all engines
 			out._sources = buildSourceRegistry(out, query);
@@ -1486,18 +1460,18 @@ async function main() {
 				process.stderr.write(
 					"[greedysearch] Synthesizing results with Gemini...\n",
 				);
-				try {
-					const geminiTab = await getOrOpenEngineTab("gemini");
-					await activateTab(geminiTab);
-					const synthesis = await synthesizeWithGemini(query, out, {
-						grounded: depth === "deep",
-						tabPrefix: geminiTab,
-					});
-					await activateTab(geminiTab);
-					out._synthesis = {
-						...synthesis,
-						synthesized: true,
-					};
+				try {
+					const geminiTab = await openNewTab();
+					await activateTab(geminiTab);
+					const synthesis = await synthesizeWithGemini(query, out, {
+						grounded: depth === "deep",
+						tabPrefix: geminiTab,
+					});
+					await activateTab(geminiTab);
+					out._synthesis = {
+						...synthesis,
+						synthesized: true,
+					};
 					process.stderr.write("PROGRESS:synthesis:done\n");
 				} catch (e) {
 					process.stderr.write(
@@ -1523,9 +1497,9 @@ async function main() {
 			});
 			return;
 		} finally {
-			await closeTabs(engineTabs);
-		}
-	}
+			await closeTabs(engineTabs);
+		}
+	}
 
 	const script = ENGINES[engine];
 	if (!script) {

package/extractors/bing-copilot.mjs

@@ -18,7 +18,9 @@ import {
 	outputJson,
 	parseArgs,
 	parseSourcesFromMarkdown,
+	TIMING,
 	validateQuery,
+	waitForCopyButton,
 } from "./common.mjs";
 import { dismissConsent, handleVerification } from "./consent.mjs";
 import { SELECTORS } from "./selectors.mjs";
@@ -30,20 +32,6 @@ const GLOBAL_VAR = "__bingClipboard";
 // Bing Copilot-specific helpers
 // ============================================================================
 
-async function waitForCopyButton(tab, timeout = 60000) {
-	const deadline = Date.now() + timeout;
-	while (Date.now() < deadline) {
-		await new Promise((r) => setTimeout(r, 700));
-		const found = await cdp([
-			"eval",
-			tab,
-			`!!document.querySelector('${S.copyButton}')`,
-		]).catch(() => "false");
-		if (found === "true") return;
-	}
-	throw new Error(`Copilot copy button did not appear within ${timeout}ms`);
-}
-
 async function extractAnswer(tab) {
 	await cdp([
 		"eval",
@@ -78,7 +66,7 @@ async function main() {
 
 		// Navigate to Copilot homepage and use the chat input
 		await cdp(["nav", tab, "https://copilot.microsoft.com/"], 35000);
-		await new Promise((r) => setTimeout(r, 2000));
+		await new Promise((r) => setTimeout(r, TIMING.postNavSlow));
 		await dismissConsent(tab, cdp);
 
 		// Handle verification challenges (Cloudflare Turnstile, Microsoft auth, etc.)
@@ -91,7 +79,7 @@ async function main() {
 
 		// After verification, page may have redirected or reloaded — wait for it to settle
 		if (verifyResult === "clicked") {
-			await new Promise((r) => setTimeout(r, 3000));
+			await new Promise((r) => setTimeout(r, TIMING.afterVerify));
 
 			// Re-navigate if we got redirected
 			const currentUrl = await cdp([
@@ -101,7 +89,7 @@ async function main() {
 			]).catch(() => "");
 			if (!currentUrl.includes("copilot.microsoft.com")) {
 				await cdp(["nav", tab, "https://copilot.microsoft.com/"], 35000);
-				await new Promise((r) => setTimeout(r, 2000));
+				await new Promise((r) => setTimeout(r, TIMING.postNavSlow));
 				await dismissConsent(tab, cdp);
 			}
 		}
@@ -133,9 +121,9 @@ async function main() {
 
 		await injectClipboardInterceptor(tab, GLOBAL_VAR);
 		await cdp(["click", tab, S.input]);
-		await new Promise((r) => setTimeout(r, 400));
+		await new Promise((r) => setTimeout(r, TIMING.postClick));
 		await cdp(["type", tab, query]);
-		await new Promise((r) => setTimeout(r, 400));
+		await new Promise((r) => setTimeout(r, TIMING.postType));
 
 		// Submit with Enter (most reliable across locales and Chrome instances)
 		await cdp([
@@ -144,7 +132,7 @@ async function main() {
 			`document.querySelector('${S.input}')?.dispatchEvent(new KeyboardEvent('keydown',{key:'Enter',bubbles:true,keyCode:13})), 'ok'`,
 		]);
 
-		await waitForCopyButton(tab);
+		await waitForCopyButton(tab, S.copyButton, { timeout: 60000 });
 
 		const { answer, sources } = await extractAnswer(tab);
 		if (!answer)

package/extractors/common.mjs

@@ -6,7 +6,7 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const __dir = dirname(fileURLToPath(import.meta.url));
-const CDP = join(__dir, "..", "bin", "cdp.mjs");
+const CDP = join(__dir, "..", "bin", "cdp.mjs");
 
 // ============================================================================
 // CDP wrapper
@@ -119,6 +119,46 @@ export function parseSourcesFromMarkdown(text) {
 		.slice(0, 10);
 }
 
+// ============================================================================
+// Timing constants
+// ============================================================================
+
+export const TIMING = {
+	postNav: 1500,       // settle after navigation
+	postNavSlow: 2000,   // settle after slower navigations (Bing, Gemini)
+	postClick: 400,      // settle after a UI click
+	postType: 400,       // settle after typing
+	inputPoll: 400,      // polling interval when waiting for input to appear
+	copyPoll: 600,       // polling interval when waiting for copy button
+	afterVerify: 3000,   // settle after a verification challenge completes
+};
+
+// ============================================================================
+// Copy button polling
+// ============================================================================
+
+/**
+ * Wait for a copy button to appear in the DOM.
+ * @param {string} tab - Tab identifier
+ * @param {string} selector - CSS selector for the copy button
+ * @param {object} [options]
+ * @param {number} [options.timeout=60000] - Max wait in ms
+ * @param {Function} [options.onPoll] - Optional async callback on each poll tick (e.g. scroll)
+ * @returns {Promise<void>}
+ */
+export async function waitForCopyButton(tab, selector, options = {}) {
+	const { timeout = 60000, onPoll } = options;
+	const deadline = Date.now() + timeout;
+	let tick = 0;
+	while (Date.now() < deadline) {
+		await new Promise((r) => setTimeout(r, TIMING.copyPoll));
+		if (onPoll) await onPoll(++tick).catch(() => null);
+		const found = await cdp(["eval", tab, `!!document.querySelector('${selector}')`]).catch(() => "false");
+		if (found === "true") return;
+	}
+	throw new Error(`Copy button ('${selector}') did not appear within ${timeout}ms`);
+}
+
 // ============================================================================
 // Stream completion detection
 // ============================================================================
@@ -139,6 +179,7 @@ export async function waitForStreamComplete(tab, options = {}) {
 		interval = 600,
 		stableRounds = 3,
 		selector = "document.body",
+		minLength = 0,
 	} = options;
 
 	const deadline = Date.now() + timeout;
@@ -154,7 +195,7 @@ export async function waitForStreamComplete(tab, options = {}) {
 		]).catch(() => "0");
 		const currentLen = parseInt(lenStr, 10) || 0;
 
-		if (currentLen > 0) {
+		if (currentLen >= minLength) {
 			if (currentLen === lastLen) {
 				stableCount++;
 				if (stableCount >= stableRounds) return currentLen;
@@ -165,6 +206,7 @@ export async function waitForStreamComplete(tab, options = {}) {
 		}
 	}
 
+	if (lastLen >= minLength) return lastLen;
 	throw new Error(`Generation did not stabilise within ${timeout}ms`);
 }
 

package/extractors/gemini.mjs

@@ -18,7 +18,9 @@ import {
 	outputJson,
 	parseArgs,
 	parseSourcesFromMarkdown,
+	TIMING,
 	validateQuery,
+	waitForCopyButton,
 } from "./common.mjs";
 import { dismissConsent, handleVerification } from "./consent.mjs";
 import { SELECTORS } from "./selectors.mjs";
@@ -46,36 +48,15 @@ async function typeIntoGemini(tab, text) {
 	]);
 }
 
-async function waitForCopyButton(tab, timeout = 120000) {
-	const deadline = Date.now() + timeout;
-	let scrollCount = 0;
-	while (Date.now() < deadline) {
-		await new Promise((r) => setTimeout(r, 600));
-
-		// Scroll to bottom every ~6 seconds to trigger lazy loading and ensure copy button appears
-		if (++scrollCount % 10 === 0) {
-			await cdp([
-				"eval",
-				tab,
-				`
-				(function() {
-					const chat = document.querySelector('chat-window, [role="main"], main') || document.body;
-					const scrollHeight = chat.scrollHeight || document.body.scrollHeight || 0;
-					// Scroll to bottom to ensure all content is loaded
-					chat.scrollTo ? chat.scrollTo({ top: scrollHeight, behavior: 'smooth' }) : window.scrollTo(0, scrollHeight);
-				})()
-			`,
-			]).catch(() => null);
-		}
-
-		const found = await cdp([
-			"eval",
-			tab,
-			`!!document.querySelector('${S.copyButton}')`,
-		]).catch(() => "false");
-		if (found === "true") return;
-	}
-	throw new Error(`Gemini copy button did not appear within ${timeout}ms`);
+async function scrollToBottom(tab) {
+	await cdp([
+		"eval",
+		tab,
+		`(function() {
+			const chat = document.querySelector('chat-window, [role="main"], main') || document.body;
+			chat.scrollTo ? chat.scrollTo({ top: chat.scrollHeight, behavior: 'smooth' }) : window.scrollTo(0, document.body.scrollHeight);
+		})()`,
+	]);
 }
 
 async function extractAnswer(tab) {
@@ -111,7 +92,7 @@ async function main() {
 
 		// Each search = fresh conversation
 		await cdp(["nav", tab, "https://gemini.google.com/app"], 35000);
-		await new Promise((r) => setTimeout(r, 2000));
+		await new Promise((r) => setTimeout(r, TIMING.postNavSlow));
 		await dismissConsent(tab, cdp);
 		await handleVerification(tab, cdp, 60000);
 
@@ -124,13 +105,13 @@ async function main() {
 				`!!document.querySelector('${S.input}')`,
 			]).catch(() => "false");
 			if (ready === "true") break;
-			await new Promise((r) => setTimeout(r, 400));
+			await new Promise((r) => setTimeout(r, TIMING.inputPoll));
 		}
-		await new Promise((r) => setTimeout(r, 300));
+		await new Promise((r) => setTimeout(r, TIMING.postClick));
 
 		await injectClipboardInterceptor(tab, GLOBAL_VAR);
 		await typeIntoGemini(tab, query);
-		await new Promise((r) => setTimeout(r, 400));
+		await new Promise((r) => setTimeout(r, TIMING.postType));
 
 		await cdp([
 			"eval",
@@ -138,7 +119,11 @@ async function main() {
 			`document.querySelector('${S.sendButton}')?.click()`,
 		]);
 
-		await waitForCopyButton(tab);
+		// Scroll to bottom every ~6s while waiting to trigger lazy-loaded content
+		await waitForCopyButton(tab, S.copyButton, {
+			timeout: 120000,
+			onPoll: (tick) => tick % 10 === 0 ? scrollToBottom(tab) : Promise.resolve(),
+		});
 
 		const { answer, sources } = await extractAnswer(tab);
 		if (!answer) throw new Error("No answer captured from Gemini clipboard");