@lincoln504/pi-research 1.3.12 → 1.4.3

package/dist/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();
         }
@@ -1060,6 +1062,17 @@ var init_logger = __esm({
           timestamp,
           level,
           ...getLogContext(),
+          // Every process writes to the SAME log file — up to three concurrent research
+          // runs plus the elected browser-pool leader — and until this field existed
+          // there was nothing to tell their lines apart. Reconstructing a lock
+          // contention from the log then meant inferring process boundaries from
+          // timing, which is guesswork: two runs a second apart interleave into what
+          // reads like one process contradicting itself. Twelve bytes a line buys
+          // attributable forensics.
+          //
+          // After the context spread, not before: which process wrote a line is not
+          // something a scoped context gets to claim otherwise.
+          pid: process.pid,
           message,
           ...firstError ? { errorMessage: redactSecrets(firstError.message), errorStack: redactSecrets(firstError.stack ?? "") } : {}
         };
@@ -1098,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);
       }
@@ -1166,7 +1179,7 @@ var init_metrics = __esm({
       increment(name, value = 1, labels) {
         const key = this.getKey(name, labels);
         this.counters.set(key, (this.counters.get(key) ?? 0) + value);
-        if (name === "llm_cost_total" || name === "llm_tokens_total") {
+        if (name.startsWith("llm_")) {
           logger.debug(`[Metrics] Incremented ${name} by ${value}${labels ? ` (labels: ${JSON.stringify(labels)})` : ""}`);
         }
       }
@@ -1270,6 +1283,28 @@ var init_metrics = __esm({
       async measure(name, action, labels) {
         return this.getActive().measure(name, action, labels);
       }
+      /**
+       * Emit API that ALWAYS targets the session registry, ignoring any active run
+       * context.
+       *
+       * For process-lifetime callbacks that happen to be *registered* during a run.
+       * AsyncLocalStorage resolves at emit time from the async resource that fired,
+       * and for a listener installed on a long-lived emitter that resource is the
+       * emitter itself — created, for every lazily-initialized subsystem here, inside
+       * whichever run first needed it. So a worker-pool error handler installed during
+       * run 1 keeps writing into run 1's registry for the rest of the process: those
+       * counts disappear from every later run's summary (the registry was discarded
+       * when the run ended) and the dead registry stays reachable through the closure.
+       *
+       * Use this only where the emission is genuinely process-scoped. Anything that
+       * describes work a run asked for belongs in the run registry, which is what the
+       * plain emit methods above give you.
+       */
+      session = {
+        increment: (name, value = 1, labels) => this._session.increment(name, value, labels),
+        setGauge: (name, value, labels) => this._session.setGauge(name, value, labels),
+        observe: (name, value, labels) => this._session.observe(name, value, labels)
+      };
       // ── Session-level read API ─────────────────────────────────────────────
       /** Snapshot of the session registry (infrastructure / cross-run metrics). */
       getSessionSnapshot() {
@@ -1992,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;
@@ -2000,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;
@@ -2014,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();
     }
   );
@@ -2086,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 {
@@ -2170,11 +2205,21 @@ async function extractSearchResults(page) {
     return found;
   });
 }
-async function executeSearchTask(_context, query) {
+function bindTaskAbortToPage(page, signal) {
+  if (!signal) return;
+  const onAbort = () => {
+    page.close().catch(() => {
+    });
+  };
+  if (signal.aborted) onAbort();
+  else signal.addEventListener("abort", onAbort, { once: true });
+}
+async function executeSearchTask(_context, query, signal) {
   const page = await createPageSafe(_context);
   const SEARCH_TIMEOUT = parseTimeoutMs(process.env["PI_RESEARCH_SEARCH_TIMEOUT_MS"], 45e3);
   page.setDefaultTimeout(SEARCH_TIMEOUT);
   page.setDefaultNavigationTimeout(SEARCH_TIMEOUT);
+  bindTaskAbortToPage(page, signal);
   try {
     logToDebugFile2("DEBUG", `[Worker-${workerId2}] Starting search for: ${query}`);
     if (process.env["PI_RESEARCH_MOCK_SEARCH"] === "true") {
@@ -2254,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));
@@ -2285,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") || 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;
@@ -2314,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);
@@ -2322,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);
@@ -2379,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 {
@@ -2387,10 +2449,11 @@ async function executeScrapeTask(_context, url, signal) {
 }
 var HEALTH_PRIMARY_URL = "https://lite.duckduckgo.com/lite/";
 var HEALTH_FALLBACK_URL = "https://example.com/";
-async function executeHealthCheckAttempt(_context, navTimeoutMs, url = HEALTH_PRIMARY_URL) {
+async function executeHealthCheckAttempt(_context, navTimeoutMs, url = HEALTH_PRIMARY_URL, signal) {
   const page = await createPageSafe(_context);
   page.setDefaultTimeout(navTimeoutMs);
   page.setDefaultNavigationTimeout(navTimeoutMs);
+  bindTaskAbortToPage(page, signal);
   try {
     const navStart = Date.now();
     await page.goto(url, { waitUntil: "domcontentloaded" });
@@ -2406,25 +2469,25 @@ async function executeHealthCheckAttempt(_context, navTimeoutMs, url = HEALTH_PR
     throw error;
   }
 }
-async function executeHealthCheck(_context, initMs) {
+async function executeHealthCheck(_context, initMs, signal) {
   const configuredMs = parseTimeoutMs(process.env["PI_RESEARCH_HEALTH_CHECK_TIMEOUT_MS"], 0);
   const HEALTH_TIMEOUT = configuredMs > 0 ? Math.max(1e4, configuredMs) : 1e4;
   if (initMs > 3e3) {
     logToDebugFile2("WARN", `[Worker-${workerId2}] Browser init was slow: ${initMs}ms \u2014 leaving less headroom for DDG navigation.`);
   }
   try {
-    return await executeHealthCheckAttempt(_context, HEALTH_TIMEOUT);
+    return await executeHealthCheckAttempt(_context, HEALTH_TIMEOUT, HEALTH_PRIMARY_URL, signal);
   } catch (firstError) {
     logToDebugFile2("WARN", `[Worker-${workerId2}] Health check attempt 1 failed: ${firstError instanceof Error ? firstError.message : String(firstError)}. Retrying once...`);
     try {
-      return await executeHealthCheckAttempt(_context, HEALTH_TIMEOUT);
+      return await executeHealthCheckAttempt(_context, HEALTH_TIMEOUT, HEALTH_PRIMARY_URL, signal);
     } catch (retryError) {
       const retryMsg = retryError instanceof Error ? retryError.message : String(retryError);
       const isTimeout = /tim(e|ed)\s*out|timeout/i.test(retryMsg);
       if (!isTimeout) {
         logToDebugFile2("WARN", `[Worker-${workerId2}] Search-provider health probe failed twice (${retryMsg}); verifying open-web reachability via fallback endpoint...`);
         try {
-          const fallback = await executeHealthCheckAttempt(_context, HEALTH_TIMEOUT, HEALTH_FALLBACK_URL);
+          const fallback = await executeHealthCheckAttempt(_context, HEALTH_TIMEOUT, HEALTH_FALLBACK_URL, signal);
           logToDebugFile2("WARN", `[Worker-${workerId2}] Fallback endpoint reachable \u2014 open web is up, search provider is degraded. Proceeding with research.`);
           return fallback;
         } catch (fallbackError) {
@@ -2522,13 +2585,19 @@ 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/evaluator/repair/knowledge LLM calls in ms (default: 300000 = 5 min, range: 60s-30min).
+  /** Timeout for coordinator/research-lead/repair/knowledge LLM calls in ms (default: 300000 = 5 min, range: 60s-30min).
    *  Not exposed in TUI — controlled via PI_RESEARCH_LLM_TIMEOUT_MS env var.
    *  Ceiling raised to 30min (matching RESEARCHER_TIMEOUT_MS): a slow model on a
    *  large-context synthesis/plan call can legitimately run >10min, and the old
@@ -2536,7 +2605,7 @@ var ConfigSchema = Type.Object({
    *  (e.g. 900000), causing those calls to time out mid-generation. */
   LLM_TIMEOUT_MS: Type.Number({ minimum: 6e4, maximum: 18e5, default: 3e5 }),
   /** Chain-of-thought "thinking" level for the engine's own LLM calls (coordinator,
-   *  evaluator, synthesis, JSON-repair, knowledge extraction) AND the researcher
+   *  router, synthesizer, JSON-repair, knowledge extraction) AND the researcher
    *  sub-agents. Default 'off': these calls emit structured JSON / cited reports, not
    *  open-ended reasoning, so thinking only burns the output-token budget (often
    *  truncating before the JSON/report block) and adds latency for at most a marginal
@@ -2551,22 +2620,26 @@ var ConfigSchema = Type.Object({
     Type.Literal("medium"),
     Type.Literal("high")
   ], { default: "off" }),
-  /** Max output tokens for the coordinator plan + mid-round evaluator decision (and,
-   *  when the evaluator synthesizes mid-round, the report). Default 16384. The blanket
+  /** Max output tokens for the coordinator's round-1 plan. Default 16384. The routing
+   *  decision has its OWN, much smaller ceiling (it emits a decision, never a report,
+   *  and cannot synthesize mid-round under the split protocol); the final report uses
+   *  SYNTHESIS_MAX_TOKENS below. The blanket
    *  4096 cap previously throttled every call and could be exhausted by a thinking block
    *  before any text was emitted. Capped at the model's real ceiling at call time.
    *  Not exposed in TUI — controlled via PI_RESEARCH_PLANNING_MAX_TOKENS env var. */
   PLANNING_MAX_TOKENS: Type.Number({ minimum: 1024, maximum: 131072, default: 16384 }),
-  /** Max output tokens for the final synthesized research report (the forced-synthesis
-   *  evaluator call). Default 32768 so a full cited report is never truncated. Capped at
+  /** Max output tokens for the final synthesized research report (the synthesizer call,
+   *  and each pass of a reduce when the corpus does not fit in one). Default 32768 so a
+   *  full cited report is never truncated. It is also the reserve subtracted from the
+   *  model's context window when budgeting that corpus. Capped at
    *  the model's real maxTokens at call time.
    *  Not exposed in TUI — controlled via PI_RESEARCH_SYNTHESIS_MAX_TOKENS env var. */
   SYNTHESIS_MAX_TOKENS: Type.Number({ minimum: 1024, maximum: 131072, default: 32768 }),
   /** LLM Model override for researcher sub-agents and knowledge synthesis.
    *  Format: provider/model-id (e.g. google/gemini-2.0-flash-001) or just model-id.
    *  When set, this overrides ctx.model for researcher sub-agents (both deep and quick)
-   *  and the knowledge synthesis background LLM. The coordinator and evaluator always
-   *  use the caller's model (ctx.model).
+   *  and the knowledge synthesis background LLM. The coordinator and the research lead
+   *  always use the caller's model (ctx.model).
    */
   RESEARCH_MODEL: Type.Optional(Type.String()),
   /** Explicit directory for the knowledge store database (overrides default) */
@@ -2620,10 +2693,13 @@ function resolveHeadlessMode() {
   if (process.env["PI_RESEARCH_USE_XVFB"] === "true") return "virtual";
   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;
@@ -2677,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 {
@@ -2690,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,
@@ -2734,11 +2810,24 @@ async function initBrowser() {
           });
           launchPromise.catch((err) => logToDebugFile3("DEBUG", `[ThreadWorker] Background browser launch rejection: ${err.message}`));
           let launchTimeoutId;
+          let raceLost = false;
+          launchPromise.then((b) => {
+            if (!raceLost) return;
+            logToDebugFile3("WARN", `[Worker-${workerId3}] Browser launch completed after its deadline; closing the orphaned instance.`);
+            try {
+              b?.close?.();
+            } catch {
+            }
+          }).catch(() => {
+          });
           try {
             return await Promise.race([
               launchPromise,
               new Promise((_, reject) => {
-                launchTimeoutId = setTimeout(() => reject(new Error(`Browser launch timed out after ${launchTimeoutMs}ms`)), launchTimeoutMs);
+                launchTimeoutId = setTimeout(() => {
+                  raceLost = true;
+                  reject(new Error(`Browser launch timed out after ${launchTimeoutMs}ms`));
+                }, launchTimeoutMs);
               })
             ]);
           } finally {
@@ -2760,17 +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;
-        context = await Promise.race([
-          contextPromise,
-          new Promise((_, reject) => {
-            contextTimeoutId = setTimeout(() => 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) {
@@ -2778,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 });
@@ -2797,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() {
@@ -2817,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 {
@@ -2827,7 +2929,6 @@ async function cleanupBrowser2() {
     ]);
   } catch {
   } finally {
-    context = null;
     browser = null;
   }
 }
@@ -2876,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);
+      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);
+      const healthResult = await executeHealthCheck(taskContext, initMs, abortController.signal);
       result = { ...healthResult, duration: Date.now() - startTime };
     } else {
       result = { error: "Unknown task type", duration: Date.now() - startTime };
@@ -2912,6 +3015,10 @@ async function runTask(data) {
     };
   } finally {
     if (taskTimer !== void 0) clearTimeout(taskTimer);
+    if (taskContext) {
+      Promise.resolve(taskContext.close()).catch(() => {
+      });
+    }
     taskFinished();
   }
 }

package/docs/ARCHITECTURE.md

@@ -31,8 +31,8 @@ pi CLI
    search burst, then hands each researcher a set of result URLs to start from.
 4. Researchers scrape and read those pages through the scrape tooling and return cited
    reports. They consider only what they scraped this session.
-5. The evaluator reviews the round and either runs another round or synthesizes the
-   final report.
+5. The research lead's **router** reviews the round and either runs another round or ends
+   the loop; its **synthesizer** then writes the final report from every report collected.
 6. The result is returned as a single cited Markdown report; the cited URLs and their
    summaries are queued into the knowledge store for future runs.
 
@@ -49,11 +49,19 @@ agent skill can pass). The pi extension's `research` tool has a minimum depth of
 an in-session agent can never request quick mode.
 
 Depth 1–3 — deep (`DeepResearchOrchestrator`): the run proceeds in **rounds**. A round
-is one coordinate → research → evaluate cycle — the round's agenda is planned (by the
-coordinator in round 1, by the evaluator thereafter), a batch of **researchers** runs it
-in parallel, and the evaluator then decides whether to run another round or synthesize.
-Two limits apply independently: how many researchers run *within* a round, and how many
-rounds the run may take.
+is one coordinate → research → route cycle — the round's agenda is planned (by the
+coordinator in round 1, by the research lead's **router** thereafter), a batch of
+**researchers** runs it in parallel, and the router then decides whether to run another
+round or end the loop. Two limits apply independently: how many researchers run *within*
+a round, and how many rounds the run may take.
+
+The research lead is two roles, not one call doing both jobs. The router only decides; it
+reads each report in full on the one round it arrives and only that report's short
+coverage digest thereafter, so its input grows with team size rather than with the square
+of the round count. The **synthesizer** runs exactly once, at the end, reads every report
+in full, and writes the report — under a corpus budget derived from the model's context
+window, reducing in partial passes and merging when the corpus does not fit. The two
+prompts are `src/prompts/system-lead-router.md` and `system-lead-synthesizer.md`.
 
 | Depth | Label  | Researchers per round (max) | Rounds (max) |
 |-------|--------|-----------------------------|--------------|
@@ -61,7 +69,7 @@ rounds the run may take.
 | 2     | deep   | 3                           | 3            |
 | 3     | ultra  | 5                           | 3            |
 
-These are ceilings, not targets: the coordinator and evaluator use as many researchers
+These are ceilings, not targets: the coordinator and router use as many researchers
 and rounds as the topic needs. A depth-2 run, for example, may spawn up to 3 researchers
 in each of up to 3 rounds. Queued steering messages (Alt+Enter) can unlock a few extra
 rounds past the cap (`MAX_EXTRA_ROUNDS_WITH_STEERING`).
@@ -70,7 +78,7 @@ The coordinator also runs the initial search burst and distributes its result UR
 round 1's researchers (`distributeSearchResults`), so in deep mode the researchers
 themselves do not call `search`.
 
-LLM-call conventions. Coordinator, evaluator, synthesis, JSON-repair, and
+LLM-call conventions. Coordinator, router, synthesizer, JSON-repair, and
 knowledge-extraction calls go through `completeSimple` (`src/core/llm/pi-ai-completion.ts`)
 with `buildSafeOptions` (`src/core/llm/llm-utils.ts`); researcher sub-agents go through
 `createAgentSession`.
@@ -369,7 +377,7 @@ stable `Agent` connector API, so it follows `^8`.)
 
 Transient-failure resilience — every LLM call is a potential single point of failure on a
 streaming endpoint that can drop mid-response (undici surfaces this as `terminated`). The
-coordinator and evaluator calls retry fast transient transport failures (socket aborts, 5xx,
+coordinator and research-lead calls retry fast transient transport failures (socket aborts, 5xx,
 429, provider overload) with bounded exponential backoff — mirroring the per-researcher retry
 (`PI_RESEARCH_MAX_RETRIES`) — and, if still failing, degrade to a deterministic fallback plan
 rather than aborting the run. An app-level LLM timeout is not retried (it already spent the