@lincoln504/pi-research 1.4.1 → 1.5.0

package/src/infrastructure/browser/thread-worker-browser.ts

@@ -11,21 +11,23 @@
 import { platform } from 'node:os';
 import { setupMocking } from './thread-worker-messaging.ts';
 import { redactSecrets } from '../../utils/log-utils.ts';
-import { resolveHeadlessMode } from './config.ts';
+import { resolveHeadlessMode, BROWSER_LAUNCH_TIMEOUT_MS, CONTEXT_CREATION_TIMEOUT_MS } from './config.ts';
 
 let browser: any = null;
-let context: any = null;
 let initPromise: Promise<void> | null = null;
 let workerId: string = '';
 
 // How many tasks this worker process currently has in flight. poolifier's
 // tasksQueueOptions.concurrency (WORKER_CONCURRENCY, default 2 — see
 // worker-pool-manager.ts) dispatches more than one task at a time to the SAME
-// worker process, and every dispatched task shares this module's browser/
-// context singletons (each gets its own page via createPageSafe(context), but
-// the context/browser themselves are one shared instance). resetBrowser()
-// uses this to avoid tearing that shared instance down out from under a
-// sibling task that is still actively using it — see resetBrowser() below.
+// worker process, and every dispatched task shares this module's browser
+// singleton (each gets its own FRESH BrowserContext via acquireTaskContext()
+// below — a real Firefox process is too expensive to launch per task, but a
+// context is cheap, and per-task contexts keep cookies/storage/route-mocking
+// from one task bleeding into a concurrent or later, unrelated one).
+// resetBrowser() uses this to avoid tearing the shared BROWSER down out from
+// under a sibling task that is still actively using it — see resetBrowser()
+// below.
 let activeTaskCount = 0;
 // A reset that resetBrowser() deferred because sibling tasks were still
 // active, to be applied once the last one finishes.
@@ -119,12 +121,12 @@ function logToDebugFile(level: string, ...args: any[]): void {
  * Initialize the browser instance
  */
 export async function initBrowser(): Promise<void> {
-  if (isBrowserConnected() && context) return;
+  if (isBrowserConnected()) return;
   if (initPromise) return initPromise;
 
   initPromise = (async () => {
     try {
-      if (!isBrowserConnected() || !context) {
+      if (!isBrowserConnected()) {
         logToDebugFile('INFO', `[Worker-${workerId}] Initializing browser instance...`);
 
         // ---------------------------------------------------------------------
@@ -196,8 +198,12 @@ export async function initBrowser(): Promise<void> {
         //
         // 90s launch timeout: CI runners (2 vCPU) need up to 60s to start Firefox
         // when it has both CPUs. The old 45s limit was too tight and caused silent
-        // init failures under resource pressure.
-        const launchTimeoutMs = 90000;
+        // init failures under resource pressure. Imported from config.ts (single
+        // source of truth) rather than a local literal — the scheduler's task
+        // deadlines (browser-task-scheduler.ts) and the healthcheck budget
+        // (getHealthCheckBudgetMs) both have to budget for this exact worst case,
+        // via COLD_START_ALLOWANCE_MS.
+        const launchTimeoutMs = BROWSER_LAUNCH_TIMEOUT_MS;
         const launchOnce = async (headless: boolean | 'virtual') => {
           const launchPromise = Camoufox({
             headless,
@@ -295,35 +301,6 @@ export async function initBrowser(): Promise<void> {
         }
 
         browser = launchedBrowser;
-        // newContext() can hang if the browser process becomes unresponsive immediately
-        // after launch (e.g. OOM, GPU crash). Guard with a hard timeout.
-        const contextPromise = browser.newContext();
-        contextPromise.catch((err: Error) => logToDebugFile('DEBUG', `[ThreadWorker] Background browser context rejection: ${err.message}`));
-        let contextTimeoutId: NodeJS.Timeout | undefined;
-        let contextRaceLost = false;
-        // Same adoption as the launch above. Here the catch below CAN close the
-        // browser (it is assigned by now), which disposes the stray context with it —
-        // but only when initBrowser is entered with a dead browser, and it leaves the
-        // context open for the window in between. Closing it directly is unconditional.
-        contextPromise.then((c: any) => {
-          if (!contextRaceLost) return;
-          logToDebugFile('WARN', `[Worker-${workerId}] Browser context creation completed after its deadline; closing the orphaned context.`);
-          try { c?.close?.(); } catch { /* already gone */ }
-        }).catch(() => { /* rejection already logged above */ });
-        context = await Promise.race([
-          contextPromise,
-          new Promise<never>((_, reject) => {
-            contextTimeoutId = setTimeout(() => {
-              contextRaceLost = true;
-              reject(new Error('Browser context creation timed out after 30000ms'));
-            }, 30000);
-          })
-        ]);
-        if (contextTimeoutId) clearTimeout(contextTimeoutId);
-        
-        // Setup mocking for CI if enabled
-        await setupMocking(context);
-        
         logToDebugFile('INFO', `[Worker-${workerId}] Browser initialized.`);
       }
     } catch (e: unknown) {
@@ -334,7 +311,6 @@ export async function initBrowser(): Promise<void> {
         Promise.resolve(browser.close()).catch((err: Error) => logToDebugFile('DEBUG', `[Worker-${workerId}] Swallowed browser close error during failed init: ${err.message}`));
       }
       browser = null;
-      context = null;
       const msg = e instanceof Error ? e.message : String(e);
 
       if (msg.includes('Camoufox is not installed') || msg.includes('Version information not found')) {
@@ -361,16 +337,60 @@ export async function initBrowser(): Promise<void> {
 }
 
 /**
- * Get the current browser context
+ * Create a FRESH BrowserContext for one task, against the shared browser
+ * process. Call once per task, right after initBrowser() resolves; the
+ * caller owns the returned context and must close it itself (in a `finally`,
+ * covering the success, error, AND timeout-abort paths) once the task ends.
+ *
+ * Never reused across tasks — that was the bug this replaced. Two tasks
+ * dispatched concurrently to the same worker (WORKER_CONCURRENCY > 1, the
+ * default) used to share one BrowserContext, so cookies/storage a site set
+ * for one task's request were visible to a different, unrelated task's later
+ * request to the same site — a content-consistency gap with no counterpart
+ * anywhere else in this codebase, which scopes browser-adjacent state
+ * (circuit breakers, scrape caches) per session deliberately.
+ *
+ * The launch race/timeout/orphan-adoption pattern below is the exact one
+ * initBrowser() used when context creation lived there (moved here wholesale,
+ * not reinvented): newContext() can hang if the browser process is
+ * unresponsive (OOM, GPU crash), so it is guarded with a hard timeout, and a
+ * context that finishes creating AFTER that timeout is adopted and closed
+ * rather than left to leak.
  */
-export function getContext(): any {
-  return context;
+export async function acquireTaskContext(): Promise<any> {
+  const contextPromise = browser.newContext();
+  contextPromise.catch((err: Error) => logToDebugFile('DEBUG', `[ThreadWorker] Background browser context rejection: ${err.message}`));
+  let contextTimeoutId: NodeJS.Timeout | undefined;
+  let contextRaceLost = false;
+  contextPromise.then((c: any) => {
+    if (!contextRaceLost) return;
+    logToDebugFile('WARN', `[Worker-${workerId}] Browser context creation completed after its deadline; closing the orphaned context.`);
+    try { c?.close?.(); } catch { /* already gone */ }
+  }).catch(() => { /* rejection already logged above */ });
+  let newContext: any;
+  try {
+    newContext = await Promise.race([
+      contextPromise,
+      new Promise<never>((_, reject) => {
+        contextTimeoutId = setTimeout(() => {
+          contextRaceLost = true;
+          reject(new Error(`Browser context creation timed out after ${CONTEXT_CREATION_TIMEOUT_MS}ms`));
+        }, CONTEXT_CREATION_TIMEOUT_MS);
+      })
+    ]);
+  } finally {
+    if (contextTimeoutId) clearTimeout(contextTimeoutId);
+  }
+
+  // Route interception is per-context, so mocking must be (re-)applied to
+  // every fresh context, not just the first one ever created.
+  await setupMocking(newContext);
+
+  return newContext;
 }
 
 function doResetBrowser(): void {
-  if (context) Promise.resolve(context.close()).catch((err: Error) => logToDebugFile('DEBUG', `[Worker-${workerId}] Swallowed context close error during reset: ${err.message}`));
   if (browser) Promise.resolve(browser.close()).catch((err: Error) => logToDebugFile('DEBUG', `[Worker-${workerId}] Swallowed browser close error during reset: ${err.message}`));
-  context = null;
   browser = null;
 }
 
@@ -407,7 +427,9 @@ export async function cleanupBrowser(): Promise<void> {
   const timeoutMs = 2000;
   
   const cleanup = async () => {
-    if (context) await Promise.resolve(context.close()).catch((err: Error) => logToDebugFile('DEBUG', `[Worker-${workerId}] Swallowed context close error during cleanup: ${err.message}`));
+    // Closes every context still open under it (any task whose own close()
+    // hasn't run yet) as a side effect — no separate context bookkeeping
+    // needed here now that contexts are task-owned, not module-owned.
     if (browser) await Promise.resolve(browser.close()).catch((err: Error) => logToDebugFile('DEBUG', `[Worker-${workerId}] Swallowed browser close error during cleanup: ${err.message}`));
   };
 
@@ -419,7 +441,6 @@ export async function cleanupBrowser(): Promise<void> {
   } catch {
     // Ignore timeout — we just want to ensure cleanup doesn't hang indefinitely
   } finally {
-    context = null;
     browser = null;
   }
 }

package/src/infrastructure/browser/thread-worker-messaging.ts

@@ -433,6 +433,13 @@ export async function executeScrapeTask(
   let poisonedError: Error | null = null;
   const pendingAddrChecks: Array<Promise<void>> = [];
 
+  // Set by the response-side early-abort check (see page.on('response') below) when the
+  // main-frame document's OWN headers already declare a PDF larger than MAX_PDF_SIZE.
+  // Declared outside the try for the same reason as poisonedError: the catch below needs
+  // to surface this instead of the secondary 'Target closed' error the triggering
+  // page.close() produces.
+  let oversizedPdfError: Error | null = null;
+
   try {
     logToDebugFile('DEBUG', `[Worker-${workerId}] Starting scrape for: ${url}`);
 
@@ -511,6 +518,46 @@ export async function executeScrapeTask(
       try {
         if (resp.request().resourceType() === 'document' && resp.frame() === page.mainFrame()) {
           finalMainFrameAddr = resp.serverAddr().catch(() => null);
+
+          // Early-abort a declared-oversized PDF as soon as its headers arrive, rather
+          // than waiting for page.goto() to finish downloading the whole thing first.
+          // 'response' fires on headers-received, well before the body is fully
+          // transferred — for a direct navigation to a PDF URL, Playwright's goto()
+          // does not resolve until the download completes, so without this the full
+          // (possibly multi-hundred-MB) body is pulled into the browser process before
+          // the PDF branch below ever gets to check Content-Length.
+          //
+          // This closes the gap only for a server that HONESTLY declares an oversized
+          // Content-Length up front. A chunked-transfer response (no Content-Length) or
+          // one that understates its length and then sends far more cannot be caught
+          // this way — Playwright's public API exposes no incremental
+          // bytes-received/streaming hook to abort mid-body on either engine. That
+          // residual case is bounded instead by the task's own SCRAPE_TIMEOUT_MS +
+          // BROWSER_TASK_TIMEOUT_MS deadline (see the onAbort/page.close() wiring
+          // above), which forcibly closes the page — and with it any in-flight
+          // download — once the task's time budget is exhausted, converting an
+          // otherwise-unbounded read into one bounded by (bandwidth x that budget).
+          const check2: Promise<void> = Promise.resolve(resp.headerValue('content-type'))
+            .then(async (ct: string | null) => {
+              // Matches the PDF branch below AND the fetch layer's own detection
+              // (web-scraper.ts): a server can mislabel or omit content-type, so a
+              // `.pdf` URL extension is an equally-trusted signal, not just the header.
+              // resp.url() — THIS response's URL, not the original task URL: goto()
+              // follows redirects, and a download endpoint without `.pdf` that
+              // redirects to the real `.pdf` file must still arm the early abort
+              // (same redirect-aware fix the fetch layer got via currentUrl).
+              const looksLikePdf = ct?.includes('application/pdf') || String(resp.url()).toLowerCase().endsWith('.pdf');
+              if (!looksLikePdf || oversizedPdfError || poisonedError) return;
+              const declared = parseInt((await resp.headerValue('content-length').catch(() => null)) || '', 10);
+              if (Number.isFinite(declared) && declared > MAX_PDF_SIZE) {
+                const sizeMB = Math.round(declared / 1024 / 1024);
+                oversizedPdfError = new Error(`PDF too large (${sizeMB}MB, max 100MB)`);
+                logToDebugFile('DEBUG', `[Worker-${workerId}] Aborting oversized PDF (${sizeMB}MB declared) before download completes: ${url}`);
+                page.close().catch(() => {});
+              }
+            })
+            .catch(() => {});
+          pendingAddrChecks.push(check2);
         }
         const check: Promise<void> = Promise.resolve(resp.serverAddr())
           .then((addr: { ipAddress?: string } | null) => {
@@ -562,7 +609,14 @@ export async function executeScrapeTask(
     // 403/503 — the HTML branch defers to the challenge wait below for that.
     const status = response?.status?.() ?? 0;
 
-    if (contentType.includes('application/pdf')) {
+    // `.pdf` extension is an equally-trusted signal alongside the header (matches
+    // the fetch layer's own detection in web-scraper.ts): a server that mislabels
+    // or omits content-type would otherwise fall into the HTML branch below, whose
+    // page.content() would serialize Firefox's PDF-viewer chrome instead of
+    // extracting the document — a silent content loss for exactly the URLs this
+    // feature advertises as supported, and specifically for the malformed/oddly-
+    // served PDFs most likely to reach this browser fallback in the first place.
+    if (contentType.includes('application/pdf') || url.toLowerCase().endsWith('.pdf')) {
       if (!response) throw new Error(`[Worker] No response received for PDF URL: ${url}`);
       // An errored "PDF" is an error page: fail BEFORE buffering its body.
       if (status >= 400) throw new Error(`HTTP ${status}`);
@@ -576,6 +630,10 @@ export async function executeScrapeTask(
         const sizeMB = Math.round(declaredLength / 1024 / 1024);
         throw new Error(`PDF too large (${sizeMB}MB, max 100MB)`);
       }
+      // The response-side early-abort check above (page.on('response')) may already have
+      // decided this and be in the middle of closing the page — skip the (redundant,
+      // about-to-fail) download attempt rather than race it.
+      if (oversizedPdfError) throw oversizedPdfError;
       const buffer = await response.body();
       // ...then the actual bytes: the header is advisory and absent on chunked
       // responses, so the byte count is the check that actually bounds memory.
@@ -692,9 +750,12 @@ export async function executeScrapeTask(
     return { contentType, html, jitter };
   } catch (error) {
     await page.close().catch((err: any) => logToDebugFile('DEBUG', `[ThreadWorker] Swallowed page close/wait error: ${err.message || String(err)}`));
-    // A poison-triggered page.close() makes the in-flight goto/content() reject
-    // with 'Target closed'; report the SSRF poisoning (a benign-classified
-    // 'Fetch blocked:' failure), not the secondary teardown error.
+    // An early-abort-triggered page.close() (oversized PDF, or SSRF poisoning) makes
+    // the in-flight goto/content()/body() reject with 'Target closed'; report the
+    // actual reason (a benign-classified failure) instead of that secondary teardown
+    // error. oversizedPdfError takes priority since it can only be set on the PDF path,
+    // where poisonedError (an HTML-only DOM-exfil concern) is not meaningful.
+    if (oversizedPdfError) throw oversizedPdfError;
     if (poisonedError) throw poisonedError;
     throw error;
   } finally {

package/src/infrastructure/browser/thread-worker.mjs

@@ -71,6 +71,8 @@ function redactSecrets(message) {
   }
   if (out.length > MAX_LOG_MESSAGE_LENGTH) {
     out = `${out.slice(0, keep)}\u2026[truncated ${Math.max(rawLength, out.length) - keep} chars]`;
+  } else if (rawLength > scanEnd) {
+    out = `${out}\u2026[truncated ${rawLength - scanEnd} chars]`;
   }
   return out;
 }
@@ -247,7 +249,7 @@ var init_error_tracker = __esm({
        * @param error - The error to track (Error object, string message, or unknown)
        * @param context - Optional context information about where the error occurred
        */
-      trackError(error, context2 = {}) {
+      trackError(error, context = {}) {
         let message;
         if (error instanceof Error) {
           message = error.message;
@@ -276,15 +278,15 @@ var init_error_tracker = __esm({
         }
         pattern.count++;
         pattern.lastSeen = now;
-        if (context2.domain) {
-          const existing = pattern.domainCounts.get(context2.domain);
+        if (context.domain) {
+          const existing = pattern.domainCounts.get(context.domain);
           if (existing !== void 0) {
-            pattern.domainCounts.set(context2.domain, existing + 1);
+            pattern.domainCounts.set(context.domain, existing + 1);
           } else if (pattern.domainCounts.size < this.MAX_DOMAINS_PER_PATTERN) {
-            pattern.domainCounts.set(context2.domain, 1);
+            pattern.domainCounts.set(context.domain, 1);
           }
         }
-        pattern.contexts.push(context2);
+        pattern.contexts.push(context);
         if (pattern.contexts.length > this.MAX_CONTEXTS_PER_PATTERN) {
           pattern.contexts.shift();
         }
@@ -1109,8 +1111,8 @@ var init_logger = __esm({
       error(...args) {
         const errArg = args.find((arg) => arg instanceof Error);
         if (errArg) {
-          const context2 = getLogContext();
-          errorTracker.trackError(errArg, context2);
+          const context = getLogContext();
+          errorTracker.trackError(errArg, context);
         }
         this.emit("ERROR" /* ERROR */, ...args);
       }
@@ -2025,7 +2027,7 @@ var workerId2 = "";
 var pageCreationLock = Promise.resolve();
 var PAGE_CREATION_HARD_RELEASE_MS = 5 * 60 * 1e3;
 var wedgedContext = null;
-async function createPageSafe(context2) {
+async function createPageSafe(context) {
   let release;
   const nextLock = new Promise((resolve) => {
     release = resolve;
@@ -2033,11 +2035,11 @@ async function createPageSafe(context2) {
   const currentLock = pageCreationLock;
   pageCreationLock = currentLock.then(() => nextLock);
   await currentLock;
-  if (context2 === wedgedContext) {
+  if (context === wedgedContext) {
     release();
     throw new Error("Browser context is wedged from a prior page-creation call that never settled; a new browser context is required.");
   }
-  const pagePromise = context2.newPage();
+  const pagePromise = context.newPage();
   let hardReleased = false;
   const releaseOnce = () => {
     if (hardReleased) return;
@@ -2047,17 +2049,17 @@ async function createPageSafe(context2) {
   };
   const hardReleaseTimer = setTimeout(() => {
     logToDebugFile2("WARN", "[ThreadWorker] page-creation mutex force-released \u2014 newPage() did not settle within the hard timeout");
-    wedgedContext = context2;
+    wedgedContext = context;
     releaseOnce();
   }, PAGE_CREATION_HARD_RELEASE_MS);
   safeUnref(hardReleaseTimer);
   pagePromise.then(
     () => {
-      if (wedgedContext === context2) wedgedContext = null;
+      if (wedgedContext === context) wedgedContext = null;
       releaseOnce();
     },
     () => {
-      if (wedgedContext === context2) wedgedContext = null;
+      if (wedgedContext === context) wedgedContext = null;
       releaseOnce();
     }
   );
@@ -2119,12 +2121,12 @@ function logToDebugFile2(level, ...args) {
   } catch {
   }
 }
-async function setupMocking(context2) {
+async function setupMocking(context) {
   const mockSearch = process.env["PI_RESEARCH_MOCK_SEARCH"] === "true";
   const mockScrape = process.env["PI_RESEARCH_MOCK_SCRAPE"] === "true";
   if (!mockSearch && !mockScrape) return;
   logToDebugFile2("INFO", `[Worker-${workerId2}] Setting up browser mocking (Search: ${mockSearch}, Scrape: ${mockScrape})`);
-  await context2.route("**", (route, request) => {
+  await context.route("**", (route, request) => {
     const urlStr = request.url();
     let url;
     try {
@@ -2297,6 +2299,7 @@ async function executeScrapeTask(_context, url, signal) {
   }
   let poisonedError = null;
   const pendingAddrChecks = [];
+  let oversizedPdfError = null;
   try {
     logToDebugFile2("DEBUG", `[Worker-${workerId2}] Starting scrape for: ${url}`);
     const { validateUrlForSSRF: validateForWorker, validateUrlForSSRFSync: validateForWorkerSync } = await Promise.resolve().then(() => (init_scraper_utils(), scraper_utils_exports));
@@ -2328,6 +2331,20 @@ async function executeScrapeTask(_context, url, signal) {
       try {
         if (resp.request().resourceType() === "document" && resp.frame() === page.mainFrame()) {
           finalMainFrameAddr = resp.serverAddr().catch(() => null);
+          const check2 = Promise.resolve(resp.headerValue("content-type")).then(async (ct) => {
+            const looksLikePdf = ct?.includes("application/pdf") || String(resp.url()).toLowerCase().endsWith(".pdf");
+            if (!looksLikePdf || oversizedPdfError || poisonedError) return;
+            const declared = parseInt(await resp.headerValue("content-length").catch(() => null) || "", 10);
+            if (Number.isFinite(declared) && declared > MAX_PDF_SIZE) {
+              const sizeMB = Math.round(declared / 1024 / 1024);
+              oversizedPdfError = new Error(`PDF too large (${sizeMB}MB, max 100MB)`);
+              logToDebugFile2("DEBUG", `[Worker-${workerId2}] Aborting oversized PDF (${sizeMB}MB declared) before download completes: ${url}`);
+              page.close().catch(() => {
+              });
+            }
+          }).catch(() => {
+          });
+          pendingAddrChecks.push(check2);
         }
         const check = Promise.resolve(resp.serverAddr()).then((addr) => {
           const ip = addr?.ipAddress;
@@ -2357,7 +2374,7 @@ async function executeScrapeTask(_context, url, signal) {
     }
     const contentType = await response?.headerValue("content-type") || "";
     const status = response?.status?.() ?? 0;
-    if (contentType.includes("application/pdf")) {
+    if (contentType.includes("application/pdf") || url.toLowerCase().endsWith(".pdf")) {
       if (!response) throw new Error(`[Worker] No response received for PDF URL: ${url}`);
       if (status >= 400) throw new Error(`HTTP ${status}`);
       const declaredLength = parseInt(await response.headerValue("content-length").catch(() => null) || "", 10);
@@ -2365,6 +2382,7 @@ async function executeScrapeTask(_context, url, signal) {
         const sizeMB = Math.round(declaredLength / 1024 / 1024);
         throw new Error(`PDF too large (${sizeMB}MB, max 100MB)`);
       }
+      if (oversizedPdfError) throw oversizedPdfError;
       const buffer = await response.body();
       if (buffer.byteLength > MAX_PDF_SIZE) {
         const sizeMB = Math.round(buffer.byteLength / 1024 / 1024);
@@ -2422,6 +2440,7 @@ async function executeScrapeTask(_context, url, signal) {
     return { contentType, html, jitter };
   } catch (error) {
     await page.close().catch((err) => logToDebugFile2("DEBUG", `[ThreadWorker] Swallowed page close/wait error: ${err.message || String(err)}`));
+    if (oversizedPdfError) throw oversizedPdfError;
     if (poisonedError) throw poisonedError;
     throw error;
   } finally {
@@ -2566,10 +2585,16 @@ var ConfigSchema = Type.Object({
   SEARCH_TIMEOUT_MS: Type.Number({ minimum: 5e3, maximum: 12e4, default: 45e3 }),
   /** TUI refresh debounce in milliseconds (default: 100ms) */
   TUI_REFRESH_DEBOUNCE_MS: Type.Number({ minimum: 0, maximum: 1e3, default: 100 }),
-  /** Queue-wait / overhead margin (ms) added on top of each browser operation's own nav
-   *  timeout to form its scheduler task-timeout ceiling: a search task times out after
-   *  SEARCH_TIMEOUT_MS + this, a scrape after SCRAPE_TIMEOUT_MS + this. Sized so a task is
-   *  never killed before it has used its full nav budget plus time waiting in the queue.
+  /** Overhead margin (ms) added on top of each browser operation's own nav timeout to
+   *  form its scheduler task-timeout ceiling: a search task times out after
+   *  SEARCH_TIMEOUT_MS + this, a scrape after SCRAPE_TIMEOUT_MS + this — covering
+   *  per-task work beyond raw navigation (page setup, result parsing). Queue wait is
+   *  NOT part of this margin: the deadline is armed on dispatch, not on enqueue, so
+   *  time spent waiting for a free worker never counts against it (see
+   *  browser-task-scheduler.ts). Cold browser-launch/context-creation time is also
+   *  separate from this margin — COLD_START_ALLOWANCE_MS
+   *  (infrastructure/browser/config.ts) covers that unconditionally on top of it,
+   *  since it isn't something a user should need to tune.
    *  (default: 10000) */
   BROWSER_TASK_TIMEOUT_MS: Type.Number({ minimum: 2e3, maximum: 12e4, default: 1e4 }),
   /** Timeout for coordinator/research-lead/repair/knowledge LLM calls in ms (default: 300000 = 5 min, range: 60s-30min).
@@ -2669,10 +2694,12 @@ function resolveHeadlessMode() {
   return true;
 }
 var HEALTHCHECK_MIN_BUDGET_MS = 45e3 + 6e4;
+var BROWSER_LAUNCH_TIMEOUT_MS = 9e4;
+var CONTEXT_CREATION_TIMEOUT_MS = 3e4;
+var COLD_START_ALLOWANCE_MS = BROWSER_LAUNCH_TIMEOUT_MS + CONTEXT_CREATION_TIMEOUT_MS;
 
 // src/infrastructure/browser/thread-worker-browser.ts
 var browser = null;
-var context = null;
 var initPromise = null;
 var workerId3 = "";
 var activeTaskCount = 0;
@@ -2726,11 +2753,11 @@ function logToDebugFile3(level, ...args) {
   }
 }
 async function initBrowser() {
-  if (isBrowserConnected() && context) return;
+  if (isBrowserConnected()) return;
   if (initPromise) return initPromise;
   initPromise = (async () => {
     try {
-      if (!isBrowserConnected() || !context) {
+      if (!isBrowserConnected()) {
         logToDebugFile3("INFO", `[Worker-${workerId3}] Initializing browser instance...`);
         let CamoufoxModule;
         try {
@@ -2739,7 +2766,7 @@ async function initBrowser() {
           throw new Error(`[Worker] camoufox-js not found in node_modules. Please run 'npm install'. Original error: ${e instanceof Error ? e.message : String(e)}`, { cause: e });
         }
         const { Camoufox } = CamoufoxModule;
-        const launchTimeoutMs = 9e4;
+        const launchTimeoutMs = BROWSER_LAUNCH_TIMEOUT_MS;
         const launchOnce = async (headless) => {
           const launchPromise = Camoufox({
             headless,
@@ -2822,30 +2849,6 @@ async function initBrowser() {
           }
         }
         browser = launchedBrowser;
-        const contextPromise = browser.newContext();
-        contextPromise.catch((err) => logToDebugFile3("DEBUG", `[ThreadWorker] Background browser context rejection: ${err.message}`));
-        let contextTimeoutId;
-        let contextRaceLost = false;
-        contextPromise.then((c) => {
-          if (!contextRaceLost) return;
-          logToDebugFile3("WARN", `[Worker-${workerId3}] Browser context creation completed after its deadline; closing the orphaned context.`);
-          try {
-            c?.close?.();
-          } catch {
-          }
-        }).catch(() => {
-        });
-        context = await Promise.race([
-          contextPromise,
-          new Promise((_, reject) => {
-            contextTimeoutId = setTimeout(() => {
-              contextRaceLost = true;
-              reject(new Error("Browser context creation timed out after 30000ms"));
-            }, 3e4);
-          })
-        ]);
-        if (contextTimeoutId) clearTimeout(contextTimeoutId);
-        await setupMocking(context);
         logToDebugFile3("INFO", `[Worker-${workerId3}] Browser initialized.`);
       }
     } catch (e) {
@@ -2853,7 +2856,6 @@ async function initBrowser() {
         Promise.resolve(browser.close()).catch((err) => logToDebugFile3("DEBUG", `[Worker-${workerId3}] Swallowed browser close error during failed init: ${err.message}`));
       }
       browser = null;
-      context = null;
       const msg = e instanceof Error ? e.message : String(e);
       if (msg.includes("Camoufox is not installed") || msg.includes("Version information not found")) {
         throw new Error(`[Worker] Browser binaries not found. Please run 'npx camoufox-js fetch' to install them.`, { cause: e });
@@ -2872,13 +2874,39 @@ async function initBrowser() {
   })();
   return initPromise;
 }
-function getContext() {
-  return context;
+async function acquireTaskContext() {
+  const contextPromise = browser.newContext();
+  contextPromise.catch((err) => logToDebugFile3("DEBUG", `[ThreadWorker] Background browser context rejection: ${err.message}`));
+  let contextTimeoutId;
+  let contextRaceLost = false;
+  contextPromise.then((c) => {
+    if (!contextRaceLost) return;
+    logToDebugFile3("WARN", `[Worker-${workerId3}] Browser context creation completed after its deadline; closing the orphaned context.`);
+    try {
+      c?.close?.();
+    } catch {
+    }
+  }).catch(() => {
+  });
+  let newContext;
+  try {
+    newContext = await Promise.race([
+      contextPromise,
+      new Promise((_, reject) => {
+        contextTimeoutId = setTimeout(() => {
+          contextRaceLost = true;
+          reject(new Error(`Browser context creation timed out after ${CONTEXT_CREATION_TIMEOUT_MS}ms`));
+        }, CONTEXT_CREATION_TIMEOUT_MS);
+      })
+    ]);
+  } finally {
+    if (contextTimeoutId) clearTimeout(contextTimeoutId);
+  }
+  await setupMocking(newContext);
+  return newContext;
 }
 function doResetBrowser() {
-  if (context) Promise.resolve(context.close()).catch((err) => logToDebugFile3("DEBUG", `[Worker-${workerId3}] Swallowed context close error during reset: ${err.message}`));
   if (browser) Promise.resolve(browser.close()).catch((err) => logToDebugFile3("DEBUG", `[Worker-${workerId3}] Swallowed browser close error during reset: ${err.message}`));
-  context = null;
   browser = null;
 }
 function resetBrowser() {
@@ -2892,7 +2920,6 @@ function resetBrowser() {
 async function cleanupBrowser2() {
   const timeoutMs = 2e3;
   const cleanup = async () => {
-    if (context) await Promise.resolve(context.close()).catch((err) => logToDebugFile3("DEBUG", `[Worker-${workerId3}] Swallowed context close error during cleanup: ${err.message}`));
     if (browser) await Promise.resolve(browser.close()).catch((err) => logToDebugFile3("DEBUG", `[Worker-${workerId3}] Swallowed browser close error during cleanup: ${err.message}`));
   };
   try {
@@ -2902,7 +2929,6 @@ async function cleanupBrowser2() {
     ]);
   } catch {
   } finally {
-    context = null;
     browser = null;
   }
 }
@@ -2951,20 +2977,22 @@ async function runTask(data) {
     taskTimer = setTimeout(() => abortController.abort(new Error(`Task timed out after ${taskTimeoutMs}ms`)), taskTimeoutMs);
   }
   taskStarted();
+  let taskContext;
   try {
     await initBrowser();
     const initMs = Date.now() - startTime;
+    taskContext = await acquireTaskContext();
     let result;
     if (type === "search") {
       if (!query) throw new Error("Search task requires a query");
-      const searchResult = await executeSearchTask(getContext(), query, abortController.signal);
+      const searchResult = await executeSearchTask(taskContext, query, abortController.signal);
       result = { results: searchResult.results, duration: Date.now() - startTime, jitter: searchResult.jitter };
     } else if (type === "scrape") {
       if (!url) throw new Error("Scrape task requires a URL");
-      const scrapeResult = await executeScrapeTask(getContext(), url, abortController.signal);
+      const scrapeResult = await executeScrapeTask(taskContext, url, abortController.signal);
       result = { ...scrapeResult, duration: Date.now() - startTime };
     } else if (type === "healthcheck") {
-      const healthResult = await executeHealthCheck(getContext(), initMs, abortController.signal);
+      const healthResult = await executeHealthCheck(taskContext, initMs, abortController.signal);
       result = { ...healthResult, duration: Date.now() - startTime };
     } else {
       result = { error: "Unknown task type", duration: Date.now() - startTime };
@@ -2987,6 +3015,10 @@ async function runTask(data) {
     };
   } finally {
     if (taskTimer !== void 0) clearTimeout(taskTimer);
+    if (taskContext) {
+      Promise.resolve(taskContext.close()).catch(() => {
+      });
+    }
     taskFinished();
   }
 }