@apmantza/greedysearch-pi 1.9.2 → 2.1.2

package/test.mjs

@@ -9,6 +9,7 @@
 //   node test.mjs flags          # flag/option tests only
 //   node test.mjs edge           # edge case tests only
 //   node test.mjs unit           # fast unit tests only (no Chrome needed)
+//   node test.mjs synth          # synthesis config smoke (gemini + chatgpt)
 
 import { spawn } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
@@ -93,11 +94,16 @@ function checkJson(file, checkFn) {
 // Unit Tests (no Chrome required)
 // ─────────────────────────────────────────────────────────────────────────────
 
-if (["", "all", "unit", "quick", "smoke"].includes(mode)) {
+if (["", "all", "unit", "quick", "smoke", "synth"].includes(mode)) {
 	section("🧪 Unit Tests");
 
 	subsection("stripQuotes — param double-escaping workaround (issue #2)");
-	const { stripQuotes } = await import("./src/tools/shared.ts");
+	// Inlined from src/tools/shared.ts — importing the .ts file from
+	// test.mjs works at the project root (Node strips types) but fails
+	// when test.mjs runs from the installed tarball in node_modules
+	// (ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING). Keep in sync with
+	// src/tools/shared.ts.
+	const stripQuotes = (val) => String(val ?? "").replace(/^"|"$/g, "");
 
 	const stripCases = [
 		// [input, expected, label]
@@ -166,24 +172,24 @@ if (["", "all", "unit", "quick", "smoke"].includes(mode)) {
 		["VERIFICATION REQUIRED", true, 'legacy pattern: "VERIFICATION REQUIRED"'],
 		["verification failed", true, 'extended: "verification" in sentence'],
 		[
-			"Clipboard interceptor returned empty text",
+			"Cloudflare Turnstile challenge detected in closed shadow DOM",
 			true,
-			"new: clipboard error (headless Cloudflare block)",
+			"new: CF closed-shadow-dom block triggers visible retry",
 		],
 		[
-			"[bing] Clipboard empty, retrying in 2s...",
+			"Copilot verification required — please solve it manually in the browser window",
 			true,
-			"new: clipboard empty retry message",
+			"new: per-engine 'verification required' triggers visible retry",
 		],
 		[
-			"Cloudflare challenge detected — content blocked in headless",
+			"Network timeout after 30000ms",
 			true,
-			"new: Cloudflare detection triggers visible retry",
+			"new: timeout triggers visible retry",
 		],
 		[
-			"Network timeout after 30000ms",
+			"Perplexity input not found — page may be blocked or in unexpected state",
 			true,
-			"new: timeout triggers visible retry",
+			"new: 'input not found' triggers visible retry",
 		],
 		["", false, "empty string"],
 	];
@@ -217,7 +223,7 @@ if (["", "all", "unit", "quick", "smoke"].includes(mode)) {
 	}
 
 	const retryEngines = findHeadlessBlockedEngines({
-		perplexity: { error: "Clipboard interceptor returned empty text" },
+		perplexity: { error: "Perplexity input not found — page may be blocked or in unexpected state" },
 		bing: { error: "Copilot verification required" },
 		google: { error: "Google verification required" },
 	});
@@ -232,11 +238,16 @@ if (["", "all", "unit", "quick", "smoke"].includes(mode)) {
 	const pplxTestCases = [
 		["ask-input selector not found", true, 'legacy: "ask-input"'],
 		[
-			"Clipboard interceptor returned empty text",
+			"Perplexity input not found — page may be blocked or in unexpected state",
 			true,
-			"new: clipboard also triggers for perplexity",
+			"new: 'input not found' triggers for perplexity",
 		],
 		["Perplexity timeout", true, "timeout triggers visible retry"],
+		[
+			"Clipboard interceptor returned empty text",
+			false,
+			"new: 'clipboard' substring no longer triggers (was too broad — fired on routine DOM-fallback failures)",
+		],
 	];
 	for (const [error, expected, label] of pplxTestCases) {
 		const matched = isHeadlessBlockedError(error);
@@ -245,18 +256,110 @@ if (["", "all", "unit", "quick", "smoke"].includes(mode)) {
 			failMsg(`pplxPattern: ${label} — expected ${expected}, got ${matched}`);
 	}
 
-	subsection("mode marker file — isChromeHeadless detection");
-	const { isChromeHeadless: isHeadlessCheck } = await import(
-		"./src/search/chrome.mjs"
+	subsection("Chrome lifecycle — visible/headless mode detection");
+	const { detectHeadlessFromChromeCommandLine, isChromeHeadless } =
+		await import("./src/search/chrome.mjs");
+	const { commandLineMatchesGreedyChrome } = await import(
+		"./src/search/browser-lifecycle.mjs"
 	);
-	const headlessResult = typeof isHeadlessCheck === "function";
-	if (headlessResult) passMsg("isChromeHeadless: function exists");
+
+	const visibleCmd =
+		'"C:/Program Files/Google/Chrome/Application/chrome.exe" --remote-debugging-port=9222 --user-data-dir=C:\\Users\\me\\AppData\\Local\\Temp\\greedysearch-chrome-profile about:blank';
+	const headlessCmd = `${visibleCmd} --headless=new`;
+	const rendererCmd = `${visibleCmd} --type=renderer`;
+
+	if (detectHeadlessFromChromeCommandLine(visibleCmd) === false) {
+		passMsg("chrome mode: live visible command line overrides stale marker");
+	} else {
+		failMsg("chrome mode: visible command line should detect non-headless");
+	}
+	if (detectHeadlessFromChromeCommandLine(headlessCmd) === true) {
+		passMsg("chrome mode: live headless command line detected");
+	} else {
+		failMsg("chrome mode: headless command line should detect headless");
+	}
+	if (detectHeadlessFromChromeCommandLine(rendererCmd) === null) {
+		passMsg("chrome mode: ignores child renderer processes");
+	} else {
+		failMsg("chrome mode: renderer command line should be ignored");
+	}
+	if (
+		commandLineMatchesGreedyChrome(
+			visibleCmd,
+			"C:/Users/me/AppData/Local/Temp/greedysearch-chrome-profile",
+		)
+	) {
+		passMsg(
+			"stale cleanup: Windows backslash profile path verifies as GreedySearch Chrome",
+		);
+	} else {
+		failMsg(
+			"stale cleanup: should accept equivalent slash/backslash profile paths",
+		);
+	}
+	if (
+		!commandLineMatchesGreedyChrome(
+			rendererCmd,
+			"C:/Users/me/AppData/Local/Temp/greedysearch-chrome-profile",
+		)
+	) {
+		passMsg("stale cleanup: renderer child is not treated as browser process");
+	} else {
+		failMsg(
+			"stale cleanup: renderer child should not verify as browser process",
+		);
+	}
+	if (typeof isChromeHeadless === "function")
+		passMsg("isChromeHeadless: function exists");
 	else failMsg("isChromeHeadless: not a function");
 
+	subsection("Synthesis routing — configurable synthesizer helpers");
+	const { normalizeSynthesizer, getSynthesisStartUrl } = await import(
+		"./src/search/synthesis-runner.mjs"
+	);
+	if (normalizeSynthesizer("gem") === "gemini")
+		passMsg("synthesizer: gem alias normalizes to gemini");
+	else failMsg("synthesizer: gem alias should normalize to gemini");
+	if (normalizeSynthesizer("gpt") === "chatgpt")
+		passMsg("synthesizer: gpt alias normalizes to chatgpt");
+	else failMsg("synthesizer: gpt alias should normalize to chatgpt");
+	if (getSynthesisStartUrl("chatgpt") === "https://chatgpt.com/")
+		passMsg("synthesizer: chatgpt start URL");
+	else failMsg("synthesizer: unexpected chatgpt start URL");
+
 	subsection("Research mode option/query normalization");
 	const { clampResearchOptions, normalizeResearchQueries } = await import(
 		"./src/search/research.mjs"
 	);
+	const { ALL_ENGINES, DEFAULT_SYNTHESIZER, ENGINES, RESEARCH_ENGINES } =
+		await import("./src/search/constants.mjs");
+	if (RESEARCH_ENGINES.join(",") === ALL_ENGINES.join(",")) {
+		passMsg("research config: reuses normal all-engine fan-out");
+	} else {
+		failMsg(
+			`research config: expected ${ALL_ENGINES.join(",")}, got ${RESEARCH_ENGINES.join(",")}`,
+		);
+	}
+	if (DEFAULT_SYNTHESIZER === "gemini") {
+		passMsg("research config: default synthesizer is gemini");
+	} else {
+		failMsg(
+			`research config: expected gemini default, got ${DEFAULT_SYNTHESIZER}`,
+		);
+	}
+	if (!ENGINES.consensus && !ENGINES.cns) {
+		passMsg("research config: consensus is not a registered engine");
+	} else {
+		failMsg("research config: consensus should not be registered");
+	}
+	if (
+		ENGINES["semantic-scholar"] &&
+		ENGINES.s2 === ENGINES["semantic-scholar"]
+	) {
+		passMsg("research config: semantic-scholar is registered with s2 alias");
+	} else {
+		failMsg("research config: semantic-scholar registration missing");
+	}
 	const clamped = clampResearchOptions({
 		breadth: 99,
 		iterations: 0,
@@ -367,6 +470,66 @@ if (["", "all", "unit", "quick", "smoke"].includes(mode)) {
 		);
 	}
 
+	const academicRanked = buildSourceRegistry(
+		{
+			"semantic-scholar": {
+				sources: [
+					{
+						title:
+							"Chain of Thought Prompting Elicits Reasoning in Large Language Models",
+						url: "https://arxiv.org/pdf/2201.11903.pdf",
+					},
+				],
+			},
+		},
+		"large language models",
+	);
+	if (
+		academicRanked[0]?.engines.includes("semantic-scholar") &&
+		academicRanked[0]?.sourceType === "academic"
+	) {
+		passMsg("source ranking: semantic-scholar sources are indexed as academic");
+	} else {
+		failMsg(
+			`source ranking: unexpected academic source ${JSON.stringify(academicRanked[0])}`,
+		);
+	}
+
+	// Social hard guardrail: a single-engine x.com citation must never be
+	// S1. Composite score is high (Google rank #1, x.com matched the
+	// "x" letter in "context"), so the smartScore −20 penalty alone
+	// isn't enough — the post-sort demotion is what keeps socials out
+	// of the top 12.
+	const socialGuardrail = buildSourceRegistry(
+		{
+			google: {
+				sources: [
+					{
+						title: "Redis on X",
+						url: "https://x.com/Redisinc/status/123",
+					},
+					{
+						title: "Self-Route paper",
+						url: "https://arxiv.org/abs/2407.16833",
+					},
+				],
+			},
+		},
+		"retrieval augmented generation vs long context LLMs for factual accuracy and hallucination reduction",
+	);
+	if (
+		socialGuardrail[0]?.sourceType !== "social" &&
+		socialGuardrail[0]?.domain === "arxiv.org"
+	) {
+		passMsg(
+			"source ranking: social sources are demoted below academic even with a higher composite score",
+		);
+	} else {
+		failMsg(
+			`source ranking: S1 should be arxiv, got ${socialGuardrail[0]?.domain} (${socialGuardrail[0]?.sourceType})`,
+		);
+	}
+
 	// ─── Phase 2: Quality Evaluator + Novelty Gate ────────────────────────
 
 	subsection("Novelty Gate — Jaccard similarity");
@@ -496,6 +659,139 @@ if (["", "all", "unit", "quick", "smoke"].includes(mode)) {
 	if (gapTargets) passMsg("fallback queries: targets identified gaps");
 	else failMsg("fallback queries: gaps not targeted");
 
+	// ─────────────────────────────────────────────────────────────────────────
+	// Synthesis routing — config-driven live smoke
+	//
+	// Verifies the `synthesizer` field in ~/.pi/greedyconfig is honored by
+	// `engine: "all" --synthesize`. Runs both the default (gemini) and an
+	// override (chatgpt). Backups the user's config and restores it after.
+	//
+	// Mode gating: only runs in "", "all", or "synth". Skipped in unit/quick/
+	// smoke because it requires Chrome + network and takes several minutes.
+	// ─────────────────────────────────────────────────────────────────────────
+	if (["", "all", "synth"].includes(mode)) {
+		subsection(
+			"Synthesis routing — config-driven live smoke (gemini + chatgpt)",
+		);
+		const { existsSync, copyFileSync, writeFileSync, unlinkSync } =
+			await import("node:fs");
+		const { homedir } = await import("node:os");
+		const { join } = await import("node:path");
+		const cfgDir = join(homedir(), ".pi");
+		const cfgFile = join(cfgDir, "greedyconfig");
+		const backup = join(cfgDir, "greedyconfig.test-backup");
+		const hadOriginal = existsSync(cfgFile);
+		if (hadOriginal) copyFileSync(cfgFile, backup);
+
+		const meaningfulQuery = "Who is Apostolos Mantzaris?";
+		const engines = ["perplexity", "google", "chatgpt", "gemini"];
+		const results = {};
+
+		const runSynth = async (synthesizer) => {
+			mkdirSync(cfgDir, { recursive: true });
+			writeFileSync(
+				cfgFile,
+				JSON.stringify({ engines, synthesizer }, null, 2) + "\n",
+				"utf8",
+			);
+			const outFile = join(resultsDir, `synth_${synthesizer}.json`);
+			const script = `
+import { spawn } from 'node:child_process';
+import { writeFileSync } from 'node:fs';
+const proc = spawn(process.execPath, [
+  '${join(__dir, "bin", "search.mjs").replace(/\\/g, "\\\\")}',
+  'all', '--inline', '--stdin', '--headless', '--synthesize'
+], { stdio: ['pipe', 'pipe', 'pipe'] });
+let out = '', err = '';
+proc.stdout.on('data', d => out += d);
+proc.stderr.on('data', d => err += d);
+proc.stdin.end(${JSON.stringify(meaningfulQuery)});
+proc.on('close', code => {
+  writeFileSync(${JSON.stringify(outFile.replace(/\\/g, "\\\\"))}, JSON.stringify({
+    code, out, err,
+  }, null, 2));
+});
+`;
+			const tmp = join(resultsDir, `_synth_${synthesizer}.mjs`);
+			writeFileSync(tmp, script, "utf8");
+			await runNode([tmp], 240);
+			const data = JSON.parse(readFileSync(outFile, "utf8"));
+			let parsed = null;
+			try {
+				parsed = JSON.parse(data.out);
+			} catch (e) {
+				return {
+					synthesized: false,
+					synthesizedBy: null,
+					parseError: e.message,
+					rawOut: data.out.slice(0, 200),
+				};
+			}
+			return {
+				synthesized: parsed._synthesis?.synthesized === true,
+				synthesizedBy: parsed._synthesis?.synthesizedBy || null,
+				engines: Object.keys(parsed).filter((k) => !k.startsWith("_")),
+				chatgptAnswer: parsed.chatgpt?.answer || null,
+				chatgptError: parsed.chatgpt?.error || null,
+				chatgptStage: parsed.chatgpt?._envelope?.lastStage || null,
+				chatgptStages: parsed.chatgpt?._envelope?.stages || null,
+				answerPreview: String(parsed._synthesis?.answer || "").slice(0, 120),
+			};
+		};
+
+		try {
+			results.gemini = await runSynth("gemini");
+			if (
+				results.gemini.synthesized &&
+				results.gemini.synthesizedBy === "gemini"
+			) {
+				passMsg("synth=gemini: synthesizedBy === gemini");
+			} else {
+				failMsg(
+					`synth=gemini: expected synthesizedBy=gemini, got ${JSON.stringify(results.gemini)}`,
+				);
+			}
+
+			results.chatgpt = await runSynth("chatgpt");
+			if (
+				results.chatgpt.synthesized &&
+				results.chatgpt.synthesizedBy === "chatgpt"
+			) {
+				passMsg("synth=chatgpt: synthesizedBy === chatgpt");
+			} else {
+				failMsg(
+					`synth=chatgpt: expected synthesizedBy=chatgpt, got ${JSON.stringify(results.chatgpt)}`,
+				);
+			}
+
+			// Also assert chatgpt-search succeeded under parallel load — a
+			// regression of the throttling fix or the engine budget would
+			// re-introduce the "cdp timeout: eval" failure at stream-wait.
+			// We require an actual answer (not just a synthesis routing
+			// marker) so the test catches the underlying engine problem.
+			if (results.gemini.chatgptAnswer) {
+				passMsg(
+					"chatgpt-search: produced an answer (parallel contention not blocking)",
+				);
+			} else {
+				failMsg(
+					`chatgpt-search: no answer — error=${JSON.stringify(results.gemini.chatgptError)} lastStage=${results.gemini.chatgptStage}`,
+				);
+			}
+		} finally {
+			if (hadOriginal) {
+				copyFileSync(backup, cfgFile);
+				try {
+					unlinkSync(backup);
+				} catch {}
+			} else {
+				try {
+					unlinkSync(cfgFile);
+				} catch {}
+			}
+		}
+	}
+
 	// ─── Phase 3: Action Planner ──────────────────────────────────────────
 
 	subsection("Action Planner — validation & parsing");
@@ -689,6 +985,229 @@ END_JSON`,
 	} else {
 		failMsg("citation audit: S2 should be flagged as unfetched");
 	}
+
+	subsection("Citation URL Reachability — checkCitationUrls");
+	const { checkCitationUrls, runCitationUrlCheck } = await import(
+		"./src/search/research.mjs"
+	);
+
+	// Empty sources → ok
+	const emptyResult = await checkCitationUrls([]);
+	if (emptyResult.ok && emptyResult.reachable.length === 0) {
+		passMsg("checkCitationUrls: empty sources returns ok");
+	} else {
+		failMsg(
+			`checkCitationUrls: empty sources unexpected: ${JSON.stringify(emptyResult)}`,
+		);
+	}
+
+	// Non-HTTP URLs are skipped
+	const nonHttpResult = await checkCitationUrls([
+		{ id: "S1", url: "ftp://example.com/file" },
+		{ id: "S2", url: "not-a-url" },
+	]);
+	if (
+		nonHttpResult.ok &&
+		nonHttpResult.skipped.length === 2 &&
+		nonHttpResult.reachable.length === 0
+	) {
+		passMsg("checkCitationUrls: non-HTTP URLs are skipped");
+	} else {
+		failMsg(
+			`checkCitationUrls: non-HTTP unexpected: ${JSON.stringify(nonHttpResult)}`,
+		);
+	}
+
+	// Concurrency guard: concurrency=0 should not infinite loop
+	// Skip in CI — makes a real HEAD request to example.com which may be
+	// blocked in sandboxed CI environments
+	if (!process.env.CI) {
+		const concurrencyResult = await checkCitationUrls(
+			[{ id: "S1", url: "https://example.com" }],
+			{ concurrency: 0, timeoutMs: 2000 },
+		);
+		if (concurrencyResult.ok || concurrencyResult.dead.length > 0) {
+			passMsg("checkCitationUrls: concurrency=0 does not infinite loop");
+		} else {
+			failMsg(
+				`checkCitationUrls: concurrency=0 unexpected: ${JSON.stringify(concurrencyResult)}`,
+			);
+		}
+	}
+
+	// runCitationUrlCheck returns null on error (non-throwing)
+	const runResult = await runCitationUrlCheck([]);
+	if (runResult && runResult.ok) {
+		passMsg("runCitationUrlCheck: empty sources returns ok");
+	} else {
+		failMsg(
+			`runCitationUrlCheck: empty sources unexpected: ${JSON.stringify(runResult)}`,
+		);
+	}
+
+	subsection("Provenance Sidecar — writeProvenanceSidecar");
+	const { writeProvenanceSidecar } = await import("./src/search/research.mjs");
+	const { existsSync, rmSync } = await import("node:fs");
+	const { tmpdir } = await import("node:os");
+
+	const testProvenanceDir = join(
+		tmpdir(),
+		`greedysearch-test-provenance-${Date.now()}`,
+	);
+	mkdirSync(testProvenanceDir, { recursive: true });
+
+	try {
+		writeProvenanceSidecar(testProvenanceDir, {
+			query: "test query",
+			rounds: [{ round: 1, actions: [], learnings: [], gaps: [] }],
+			sources: [{ id: "S1", title: "Test Source" }],
+			fetchedSources: [{ id: "S1", contentChars: 500 }],
+			citationAudit: { ok: true, cited: ["S1"], missing: [], unfetched: [] },
+			citationUrls: { reachable: [], dead: [], skipped: [], ok: true },
+			floor: { floorMet: true, checks: { citationsPresent: true } },
+			manifest: {
+				startedAt: "2026-01-01",
+				finishedAt: "2026-01-01",
+				durationMs: 1000,
+			},
+		});
+
+		const provenancePath = join(testProvenanceDir, "provenance.md");
+		if (existsSync(provenancePath)) {
+			const content = readFileSync(provenancePath, "utf8");
+			if (content.includes("test query") && content.includes("S1")) {
+				passMsg(
+					"writeProvenanceSidecar: writes provenance.md with query and sources",
+				);
+			} else {
+				failMsg(
+					"writeProvenanceSidecar: provenance.md missing expected content",
+				);
+			}
+		} else {
+			failMsg("writeProvenanceSidecar: provenance.md not created");
+		}
+	} catch (e) {
+		failMsg(`writeProvenanceSidecar: threw error: ${e.message}`);
+	} finally {
+		try {
+			rmSync(testProvenanceDir, { recursive: true, force: true });
+		} catch {}
+	}
+
+	subsection("Research Floor and Question Ledger");
+	const { computeResearchFloor, createQuestionLedger, updateQuestionLedger } =
+		await import("./src/search/research.mjs");
+	const floorOk = computeResearchFloor({
+		sources: [
+			{ id: "S1", sourceType: "official-docs" },
+			{ id: "S2", sourceType: "community" },
+		],
+		fetchedSources: [
+			{ id: "S1", contentChars: 500 },
+			{ id: "S2", contentChars: 500 },
+			{ id: "S3", contentChars: 500 },
+		],
+		synthesis: {
+			claims: [{ claim: "React has docs", sourceIds: ["S1"] }],
+		},
+		citationAudit: { ok: true, cited: ["S1"], unfetched: [] },
+		rounds: [{ round: 1 }],
+		qualityScore: 8.2,
+		maxSources: 3,
+	});
+	if (floorOk.floorMet)
+		passMsg("research floor: passes with evidence and citations");
+	else failMsg(`research floor: expected pass, got ${JSON.stringify(floorOk)}`);
+
+	const floorMissingCitation = computeResearchFloor({
+		sources: [{ id: "S1", sourceType: "official-docs" }],
+		fetchedSources: [{ id: "S1", contentChars: 500 }],
+		synthesis: { claims: [] },
+		citationAudit: { ok: true, cited: [], unfetched: [] },
+		rounds: [{ round: 1 }],
+		qualityScore: 9,
+		maxSources: 1,
+	});
+	if (
+		!floorMissingCitation.floorMet &&
+		!floorMissingCitation.checks.citationsPresent
+	) {
+		passMsg("research floor: rejects missing citations");
+	} else {
+		failMsg("research floor: missing citations should fail");
+	}
+
+	const ledger = createQuestionLedger("What is React 19?");
+	updateQuestionLedger(ledger, {
+		roundNumber: 1,
+		actions: [
+			{
+				type: "search",
+				query: "React 19 actions",
+				researchGoal: "Find React 19 feature list",
+			},
+		],
+		learningPayload: {
+			answeredQuestions: [
+				{ id: "Q1", evidence: "React 19 is documented", sourceIds: ["S1"] },
+			],
+			newQuestions: ["Which React 19 features are stable?"],
+		},
+	});
+	const closedQ1 = ledger.find((q) => q.id === "Q1")?.status === "closed";
+	const addedOpen = ledger.some(
+		(q) => q.question.includes("stable") && q.status === "open",
+	);
+	if (closedQ1 && addedOpen) {
+		passMsg("question ledger: closes answered questions and adds follow-ups");
+	} else {
+		failMsg(`question ledger: unexpected ${JSON.stringify(ledger)}`);
+	}
+
+	subsection("Structured JSON parser");
+	const { parseStructuredJson } = await import("./src/search/synthesis.mjs");
+	const parsedLooseJson = parseStructuredJson(`BEGIN_JSON
+{"answer":"line one
+line two","claims":[{"claim":"x"}]}
+END_JSON
+trailing note`);
+	if (parsedLooseJson?.answer?.includes("line two")) {
+		passMsg("structured JSON: repairs raw newlines inside strings");
+	} else {
+		failMsg(
+			`structured JSON: failed to repair ${JSON.stringify(parsedLooseJson)}`,
+		);
+	}
+
+	subsection("Progress tracker — bar rendering and ETA");
+	const { createProgressTracker } = await import("./src/search/progress.mjs");
+	const silentTracker = createProgressTracker({
+		totalActions: 4,
+		silent: true,
+	});
+	silentTracker.startAction("search", "test");
+	silentTracker.endAction();
+	silentTracker.startAction("fetch", "https://example.com");
+	silentTracker.endAction();
+	if (silentTracker.getElapsedMs() >= 0) {
+		passMsg("progress: tracker records action timing");
+	} else {
+		failMsg("progress: tracker elapsed time invalid");
+	}
+	// Test bar formatting indirectly via duration
+	const tracker2 = createProgressTracker({
+		totalActions: 2,
+		totalRounds: 1,
+		silent: true,
+	});
+	tracker2.startAction("search", "q1");
+	tracker2.endAction();
+	if (tracker2.getElapsedMs() >= 0) {
+		passMsg("progress: round tracking works");
+	} else {
+		failMsg("progress: round tracking broken");
+	}
 }
 
 // ─────────────────────────────────────────────────────────────────────────────