@lincoln504/pi-research 1.6.10 → 1.6.11

package/src/core/pi-version.ts

@@ -75,7 +75,7 @@ export function compareVersions(a: SemverParts, b: SemverParts): number {
  * option originally existed to prevent. The floor moved to close that gap,
  * not just because the type changed.
  */
-export const PI_MIN_VERSION: SemverParts = { major: 0, minor: 84, patch: 0 };
+export const PI_MIN_VERSION: SemverParts = { major: 0, minor: 85, patch: 0 };
 
 /**
  * Newest host line this release was actually exercised against (CI + a real run).
@@ -83,7 +83,7 @@ export const PI_MIN_VERSION: SemverParts = { major: 0, minor: 84, patch: 0 };
  * Compared on MAJOR.MINOR only: a patch bump within a tested line is not a new
  * surface, and warning on it would be noise.
  */
-export const PI_TESTED_MAX_VERSION: SemverParts = { major: 0, minor: 84, patch: 4 };
+export const PI_TESTED_MAX_VERSION: SemverParts = { major: 0, minor: 85, patch: 0 };
 
 export type PiCompatibilityLevel = 'ok' | 'unparseable' | 'too-old' | 'untested';
 

package/src/core/planning-utils.ts

@@ -160,16 +160,48 @@ You are in the late phase of research. Set a higher threshold for delegation:
  * Parse JSON from LLM response into ResearchPlan
  */
 export function parseJsonPlan(text: string): ResearchPlan {
-  const result = extractJson<unknown>(text, 'object');
+  // Unwrap a doubly-encoded payload up front. Some models (observed: deepseek-v4-flash
+  // via OpenRouter, 2026-09-02) call the submit_plan tool with the plan JSON-encoded
+  // INSIDE a string argument, so the toolCall re-serialization path hands us a
+  // doubly-encoded payload — extractJson('object') then fails outright with the
+  // misleading "No valid JSON found" instead of exposing the plan it contains.
+  let normalized = text.trim();
+  if (normalized.startsWith('"')) {
+    try {
+      const unwrapped = JSON.parse(normalized);
+      if (typeof unwrapped === 'string') normalized = unwrapped.trim();
+    } catch { /* not a JSON string literal — extract below reports the real state */ }
+  }
+
+  const result = extractJson<unknown>(normalized, 'object');
   if (!result.success || !result.value) {
     const preview = text.length > 100 ? text.slice(0, 100) + '...' : text;
     throw new Error(`Failed to extract valid JSON plan: ${result.error}. Raw response preview: "${preview}"`);
   }
 
+  const candidate: unknown = result.value;
+
+  // Normalize explicit nulls for OPTIONAL fields. The schema treats researchers /
+  // allQueries / content / title / action / fallback as optional, but models
+  // frequently emit them as null (observed live 2026-09-02: a "research-complete"
+  // router answer with researchers:null, allQueries:null). With TypeBox 1.3.7 a null
+  // optional field makes Value.Errors report a ROOT error (path undefined, message
+  // "must be object") instead of pointing at the field — reproducing exactly the
+  // "Plan validation failed: undefined: must be object" seen in the logs — and the
+  // plan fell into the costly agentic-repair path even though the model's decision
+  // (synthesize) was perfectly valid. Dropping the key is exactly what the model meant.
+  if (candidate && typeof candidate === 'object' && !Array.isArray(candidate)) {
+    for (const key of ['researchers', 'allQueries', 'content', 'title', 'action', 'fallback'] as const) {
+      if ((candidate as Record<string, unknown>)[key] === null) {
+        delete (candidate as Record<string, unknown>)[key];
+      }
+    }
+  }
+
   // Robust validation using TypeBox
   try {
     // 1. Convert/Coerce values (e.g. string numbers to numbers, single values to arrays if possible)
-    const coerced = Value.Convert(ResearchPlanSchema, result.value);
+    const coerced = Value.Convert(ResearchPlanSchema, candidate);
     
     // 2. Validate against schema
     if (!Value.Check(ResearchPlanSchema, coerced)) {

package/src/infrastructure/browser/config.ts

@@ -171,6 +171,9 @@ export function getBrowserEnv(config?: Config): NodeJS.ProcessEnv {
     const c = config || getConfig();
     env['PI_RESEARCH_SCRAPE_TIMEOUT_MS'] = String(c.SCRAPE_TIMEOUT_MS);
     env['PI_RESEARCH_SEARCH_TIMEOUT_MS'] = String(c.SEARCH_TIMEOUT_MS);
+    // Search results page 2: the thread-worker reads this directly from its
+    // process.env copy inside executeSearchTask.
+    env['PI_RESEARCH_SCRAPE_SECOND_PAGE'] = String(c.SCRAPE_SECOND_PAGE);
     env['PI_RESEARCH_HEALTH_CHECK_TIMEOUT_MS'] = String(c.HEALTH_CHECK_TIMEOUT_MS);
     return env;
 }

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

@@ -9,10 +9,38 @@
  */
 
 import { platform } from 'node:os';
+import { readFileSync, existsSync } from 'node:fs';
+import { homedir } from 'node:os';
 import { setupMocking } from './thread-worker-messaging.ts';
 import { redactSecrets } from '../../utils/log-utils.ts';
 import { resolveHeadlessMode, BROWSER_LAUNCH_TIMEOUT_MS, CONTEXT_CREATION_TIMEOUT_MS } from './config.ts';
 
+// Egress DNS workaround (see scripts/ddg-socks-proxy.mjs): when
+// ~/.pi/research/proxy.json exists with {"host":"127.0.0.1","port":1080}, launch
+// the browser through that SOCKS proxy. Needed because the system resolver
+// returns an unreachable DuckDuckGo front-door IP from this machine's egress
+// path; the local proxy pins DDG hostnames to the verified-live IP. Uses a
+// file rather than env so a long-lived leader picks it up without a restart.
+function loadSocksProxyPrefs(): Record<string, string | number | boolean> {
+  try {
+    const p = `${homedir()}/.pi/research/proxy.json`;
+    if (!existsSync(p)) return {};
+    const cfg = JSON.parse(readFileSync(p, 'utf8')) as { host?: string; port?: number };
+    const host = cfg.host ?? '127.0.0.1';
+    const port = cfg.port ?? 1080;
+    return {
+      'network.proxy.type': 1,
+      'network.proxy.socks': host,
+      'network.proxy.socks_port': port,
+      'network.proxy.socks_remote_dns': true,
+      'network.proxy.socks_version': 5,
+      'network.proxy.no_proxies_on': '',
+    };
+  } catch {
+    return {};
+  }
+}
+
 let browser: any = null;
 let initPromise: Promise<void> | null = null;
 let workerId: string = '';
@@ -240,6 +268,7 @@ export async function initBrowser(): Promise<void> {
             // but headless Firefox on macOS/Windows is not guaranteed to be
             // silent either, so the mute is applied unconditionally.
             firefox_user_prefs: {
+              ...loadSocksProxyPrefs(),
               'media.volume_scale': '0.0',
               'media.autoplay.default': 5,
               // SSRF: WebSocket connections bypass BOTH layers of the browser

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

@@ -182,15 +182,33 @@ export async function setupMocking(context: any): Promise<void> {
 
     if (mockSearch && isDuckDuckGo) {
       logToDebugFile('DEBUG', `[Worker-${workerId}] Mocking search response for: ${urlStr}`);
-      route.fulfill({
-        status: 200,
-        contentType: 'text/html',
-        body: `
-          <html><head><title>DuckDuckGo Lite</title></head><body>
-            <form action="/lite/" method="post">
-              <input name="q" type="text">
-              <input type="submit" value="Search">
-            </form>
+      // When SCRAPE_SECOND_PAGE is on, the mock also exposes DDG's next-page
+      // form (hidden `s`/`dc` offsets + a "Next" submit) and serves a DISTINCT
+      // result set when a page-2 POST arrives — identified by the `s=2` form
+      // field in the request body. This mirrors the real flow (page 1 = a GET,
+      // page 2 = POST with `s`), so the second-page scrape is
+      // end-to-end testable without a live network.
+      const isSecondPageRequest = request.method() === 'POST' &&
+        typeof request.postData() === 'string' &&
+        /(?:^|&)s=2(?:&|$)/.test(request.postData()!);
+      const mockResultsHtml = isSecondPageRequest
+        ? `
+            <table class="result-link">
+              <tr>
+                <td><a class="result-link" href="https://example.com/mock-result-3?uddg=https%3A%2F%2Fexample.com%2Ftarget-3">Mock Result 3</a></td>
+              </tr>
+              <tr>
+                <td class="result-snippet">Page-two mocked search result snippet.</td>
+              </tr>
+              <tr>
+                <td><a class="result-link" href="https://example.com/mock-result-4?uddg=https%3A%2F%2Fexample.com%2Ftarget-4">Mock Result 4</a></td>
+              </tr>
+              <tr>
+                <td class="result-snippet">Another page-two mocked snippet to verify second-page extraction.</td>
+              </tr>
+            </table>
+          `
+        : `
             <table class="result-link">
               <tr>
                 <td><a class="result-link" href="https://example.com/mock-result-1?uddg=https%3A%2F%2Fexample.com%2Ftarget-1">Mock Result 1</a></td>
@@ -205,6 +223,23 @@ export async function setupMocking(context: any): Promise<void> {
                 <td class="result-snippet">Another mocked snippet to verify multiple result extraction.</td>
               </tr>
             </table>
+            <form action="/lite/" method="post">
+              <input type="hidden" name="q" value="">
+              <input type="hidden" name="s" value="2">
+              <input type="hidden" name="dc" value="3">
+              <input type="submit" value="Next">
+            </form>
+          `;
+      route.fulfill({
+        status: 200,
+        contentType: 'text/html',
+        body: `
+          <html><head><title>DuckDuckGo Lite</title></head><body>
+            <form action="/lite/" method="post">
+              <input name="q" type="text">
+              <input type="submit" value="Search">
+            </form>
+            ${mockResultsHtml}
           </body></html>
         `
       });
@@ -233,10 +268,20 @@ async function extractSearchResults(page: any): Promise<any[]> {
     const found: any[] = [];
     // @ts-ignore - document is available in browser context
     // eslint-disable-next-line no-undef
-    const links = Array.from(document.querySelectorAll('a.result-link'));
+    const links = Array.from(document.querySelectorAll('a.result-link, a.result__a'));
     links.forEach((link: any) => {
-      const row = link.closest('tr');
-      const snippet = row?.nextElementSibling?.querySelector('td.result-snippet')?.textContent?.trim() || '';
+      // lite layout: <a class="result-link"> inside a <tr>; the snippet lives in
+      // the NEXT sibling <tr>'s td.result-snippet (each result is a two-row pair:
+      // link row + snippet row). Fall back to inside-row for robustness.
+      // html layout: <a class="result__a"> inside div.result; snippet in
+      // a.result__snippet / .result__snippet inside the same container.
+      const row = link.closest('tr') || link.closest('.result');
+      const snippetEl =
+        row?.querySelector('td.result-snippet') ||
+        row?.querySelector('a.result__snippet') ||
+        row?.querySelector('.result__snippet') ||
+        row?.nextElementSibling?.querySelector('td.result-snippet');
+      const snippet = snippetEl?.textContent?.trim() || '';
       const title = link.textContent?.trim() || '';
       let url = link.href;
       try {
@@ -309,17 +354,69 @@ export async function executeSearchTask(
     if (process.env['PI_RESEARCH_MOCK_SEARCH'] === 'true') {
       await page.goto(`https://lite.duckduckgo.com/lite/?q=${encodeURIComponent(query)}`, { waitUntil: 'domcontentloaded' });
     } else {
-      // Relaxed timeout to accommodate network latency and concurrent worker load
-      await page.goto('https://lite.duckduckgo.com/lite/', { waitUntil: 'domcontentloaded' });
-      await page.fill('input[name="q"]', query);
-      await Promise.all([
-        page.waitForNavigation({ waitUntil: 'domcontentloaded' }),
-        page.keyboard.press('Enter')
-      ]);
+      // Direct GET with the query inline. The old path (goto the empty lite landing
+      // → fill input[name=q] → Enter → waitForNavigation) broke when DDG changed the
+      // landing interaction: the submit↔navigation race extract()ed the empty form
+      // page, so EVERY search returned zero results for days while the same browsers
+      // fetched real results via a plain ?q= GET (observed 2026-09-02..03). We drive
+      // the html endpoint — its result__a markup is static in the initial HTML and is
+      // what the extractor matches — and wait for the result anchors to actually be
+      // in the DOM (domcontentloaded can fire before DDG paints them).
+      const qurl = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+      const nav = await page.goto(qurl, { waitUntil: 'domcontentloaded' });
+      if ((!nav || (nav.status && nav.status() > 399)) && !(await page.$('a.result__a, a.result-link'))) {
+        // HTTP error or no anchors: fall back to the lite endpoint (result-link
+        // class, also directly GET-able).
+        await page.goto(`https://lite.duckduckgo.com/lite/?q=${encodeURIComponent(query)}`, { waitUntil: 'domcontentloaded' });
+      }
+      try {
+        await page.waitForSelector('a.result__a, a.result-link', { timeout: 8000 });
+      } catch {
+        // Results may legitimately be absent (anomaly/no-results page); extract
+        // whatever is there (possibly nothing) rather than throwing.
+      }
     }
 
     const results = await extractSearchResults(page);
 
+    // Optional second results page (SCRAPE_SECOND_PAGE config setting, threaded
+    // to workers as PI_RESEARCH_SCRAPE_SECOND_PAGE via getBrowserEnv). DuckDuckGo
+    // paginates with a small POST form at the bottom of the results table
+    // (hidden `s`/`dc` offsets plus a submit labelled "Next"); clicking THAT form
+    // (rather than hand-building a page-2 URL) reuses the offsets the site itself
+    // issued, so it stays correct whatever per-page count DDG currently serves.
+    // If the primary endpoint doesn't serve the control (or the click fails),
+    // page-2 degrades to page-1-only — see the failure policy below.
+    // Failure policy: page-1 results are already in hand and fully usable, so any
+    // page-2 problem (no next control, click/navigation timeout, abort-triggered
+    // page close) degrades to returning page 1 alone with a WARN — it must never
+    // fail a query that succeeded on page 1. Cross-page and cross-query dedup
+    // happen upstream in performSearch's seenUrls set.
+    const scrapeSecondPage = process.env['PI_RESEARCH_SCRAPE_SECOND_PAGE'] === 'true';
+    if (scrapeSecondPage && results.length > 0) {
+      try {
+        const nextButton = page.locator('form input[type="submit"][value*="next" i]').first();
+        if (await nextButton.count() > 0) {
+          logToDebugFile('DEBUG', `[Worker-${workerId}] SCRAPE_SECOND_PAGE: fetching results page 2 for: ${query}`);
+          await Promise.all([
+            page.waitForNavigation({ waitUntil: 'domcontentloaded' }),
+            nextButton.click(),
+          ]);
+          const seen = new Set(results.map((r: any) => r.url));
+          for (const r of await extractSearchResults(page)) {
+            if (!seen.has(r.url)) {
+              seen.add(r.url);
+              results.push(r);
+            }
+          }
+        } else {
+          logToDebugFile('DEBUG', `[Worker-${workerId}] SCRAPE_SECOND_PAGE: no next-page control (single page of results) for: ${query}`);
+        }
+      } catch (err: any) {
+        logToDebugFile('WARN', `[Worker-${workerId}] SCRAPE_SECOND_PAGE: page-2 fetch failed (keeping page-1 results) for: ${query} — ${err?.message || String(err)}`);
+      }
+    }
+
     await page.close();
     
     // Reduce jitter in CI/mock mode to speed up tests

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

@@ -2014,6 +2014,8 @@ function createKillHandler() {
 
 // src/infrastructure/browser/thread-worker-browser.ts
 import { platform as platform2 } from "node:os";
+import { readFileSync, existsSync as existsSync3 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
 
 // src/infrastructure/browser/thread-worker-messaging.ts
 init_log_utils();
@@ -2143,15 +2145,23 @@ async function setupMocking(context) {
     const isDuckDuckGo = url.hostname === "duckduckgo.com" || url.hostname === "lite.duckduckgo.com" || url.hostname.endsWith(".duckduckgo.com");
     if (mockSearch && isDuckDuckGo) {
       logToDebugFile2("DEBUG", `[Worker-${workerId2}] Mocking search response for: ${urlStr}`);
-      route.fulfill({
-        status: 200,
-        contentType: "text/html",
-        body: `
-          <html><head><title>DuckDuckGo Lite</title></head><body>
-            <form action="/lite/" method="post">
-              <input name="q" type="text">
-              <input type="submit" value="Search">
-            </form>
+      const isSecondPageRequest = request.method() === "POST" && typeof request.postData() === "string" && /(?:^|&)s=2(?:&|$)/.test(request.postData());
+      const mockResultsHtml = isSecondPageRequest ? `
+            <table class="result-link">
+              <tr>
+                <td><a class="result-link" href="https://example.com/mock-result-3?uddg=https%3A%2F%2Fexample.com%2Ftarget-3">Mock Result 3</a></td>
+              </tr>
+              <tr>
+                <td class="result-snippet">Page-two mocked search result snippet.</td>
+              </tr>
+              <tr>
+                <td><a class="result-link" href="https://example.com/mock-result-4?uddg=https%3A%2F%2Fexample.com%2Ftarget-4">Mock Result 4</a></td>
+              </tr>
+              <tr>
+                <td class="result-snippet">Another page-two mocked snippet to verify second-page extraction.</td>
+              </tr>
+            </table>
+          ` : `
             <table class="result-link">
               <tr>
                 <td><a class="result-link" href="https://example.com/mock-result-1?uddg=https%3A%2F%2Fexample.com%2Ftarget-1">Mock Result 1</a></td>
@@ -2166,6 +2176,23 @@ async function setupMocking(context) {
                 <td class="result-snippet">Another mocked snippet to verify multiple result extraction.</td>
               </tr>
             </table>
+            <form action="/lite/" method="post">
+              <input type="hidden" name="q" value="">
+              <input type="hidden" name="s" value="2">
+              <input type="hidden" name="dc" value="3">
+              <input type="submit" value="Next">
+            </form>
+          `;
+      route.fulfill({
+        status: 200,
+        contentType: "text/html",
+        body: `
+          <html><head><title>DuckDuckGo Lite</title></head><body>
+            <form action="/lite/" method="post">
+              <input name="q" type="text">
+              <input type="submit" value="Search">
+            </form>
+            ${mockResultsHtml}
           </body></html>
         `
       });
@@ -2186,10 +2213,11 @@ async function setupMocking(context) {
 async function extractSearchResults(page) {
   return await page.evaluate(() => {
     const found = [];
-    const links = Array.from(document.querySelectorAll("a.result-link"));
+    const links = Array.from(document.querySelectorAll("a.result-link, a.result__a"));
     links.forEach((link) => {
-      const row = link.closest("tr");
-      const snippet = row?.nextElementSibling?.querySelector("td.result-snippet")?.textContent?.trim() || "";
+      const row = link.closest("tr") || link.closest(".result");
+      const snippetEl = row?.querySelector("td.result-snippet") || row?.querySelector("a.result__snippet") || row?.querySelector(".result__snippet") || row?.nextElementSibling?.querySelector("td.result-snippet");
+      const snippet = snippetEl?.textContent?.trim() || "";
       const title = link.textContent?.trim() || "";
       let url = link.href;
       try {
@@ -2230,14 +2258,41 @@ async function executeSearchTask(_context, query, signal) {
     if (process.env["PI_RESEARCH_MOCK_SEARCH"] === "true") {
       await page.goto(`https://lite.duckduckgo.com/lite/?q=${encodeURIComponent(query)}`, { waitUntil: "domcontentloaded" });
     } else {
-      await page.goto("https://lite.duckduckgo.com/lite/", { waitUntil: "domcontentloaded" });
-      await page.fill('input[name="q"]', query);
-      await Promise.all([
-        page.waitForNavigation({ waitUntil: "domcontentloaded" }),
-        page.keyboard.press("Enter")
-      ]);
+      const qurl = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+      const nav = await page.goto(qurl, { waitUntil: "domcontentloaded" });
+      if ((!nav || nav.status && nav.status() > 399) && !await page.$("a.result__a, a.result-link")) {
+        await page.goto(`https://lite.duckduckgo.com/lite/?q=${encodeURIComponent(query)}`, { waitUntil: "domcontentloaded" });
+      }
+      try {
+        await page.waitForSelector("a.result__a, a.result-link", { timeout: 8e3 });
+      } catch {
+      }
     }
     const results = await extractSearchResults(page);
+    const scrapeSecondPage = process.env["PI_RESEARCH_SCRAPE_SECOND_PAGE"] === "true";
+    if (scrapeSecondPage && results.length > 0) {
+      try {
+        const nextButton = page.locator('form input[type="submit"][value*="next" i]').first();
+        if (await nextButton.count() > 0) {
+          logToDebugFile2("DEBUG", `[Worker-${workerId2}] SCRAPE_SECOND_PAGE: fetching results page 2 for: ${query}`);
+          await Promise.all([
+            page.waitForNavigation({ waitUntil: "domcontentloaded" }),
+            nextButton.click()
+          ]);
+          const seen = new Set(results.map((r) => r.url));
+          for (const r of await extractSearchResults(page)) {
+            if (!seen.has(r.url)) {
+              seen.add(r.url);
+              results.push(r);
+            }
+          }
+        } else {
+          logToDebugFile2("DEBUG", `[Worker-${workerId2}] SCRAPE_SECOND_PAGE: no next-page control (single page of results) for: ${query}`);
+        }
+      } catch (err) {
+        logToDebugFile2("WARN", `[Worker-${workerId2}] SCRAPE_SECOND_PAGE: page-2 fetch failed (keeping page-1 results) for: ${query} \u2014 ${err?.message || String(err)}`);
+      }
+    }
     await page.close();
     const jitterBase = process.env["PI_RESEARCH_MOCK_SEARCH"] === "true" ? 10 : 500;
     const jitterRange = process.env["PI_RESEARCH_MOCK_SEARCH"] === "true" ? 10 : 1e3;
@@ -2669,6 +2724,8 @@ var ConfigSchema = Type.Object({
   MAX_CONCURRENT_SCRAPES: Type.Number({ minimum: 1, maximum: 20, default: 3 }),
   /** Maximum URLs fetched per scrape batch; extras are listed under "Not Fetched — Over Batch Cap" (default: 8, range: 1-20) */
   MAX_SCRAPE_URLS: Type.Number({ minimum: 1, maximum: 20, default: 8 }),
+  /** Also fetch DuckDuckGo results page 2 for every search query (default: false). Configured via env/config file; not surfaced in the config TUI. */
+  SCRAPE_SECOND_PAGE: Type.Boolean({ default: false }),
   /** Max YouTube videos transcribed per youtube_transcript call (default: 3, range 1-5) */
   YOUTUBE_TRANSCRIPT_MAX_VIDEOS: Type.Number({ minimum: 1, maximum: 5, default: 3 }),
   /** Per-video timeout for the youtube_transcript tool in ms (default: 20000, range 5-120s) */
@@ -2735,11 +2792,12 @@ var ConfigSchema = Type.Object({
    *  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.
+  /** LLM Model override for the evaluator/synthesis rounds and researcher sub-agents.
    *  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 the research lead
-   *  always use the caller's model (ctx.model).
+   *  When set, this governs the evaluator/synthesis rounds and the researcher
+   *  sub-agents (both deep and quick) and the knowledge synthesis background LLM.
+   *  The initial coordinator (round 1 planning) uses the parent chat's model (ctx.model)
+   *  for prompt-cache continuity with the conversation that triggered research.
    */
   RESEARCH_MODEL: Type.Optional(Type.String()),
   /** Explicit directory for the knowledge store database (overrides default) */
@@ -2799,6 +2857,25 @@ 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
+function loadSocksProxyPrefs() {
+  try {
+    const p = `${homedir2()}/.pi/research/proxy.json`;
+    if (!existsSync3(p)) return {};
+    const cfg = JSON.parse(readFileSync(p, "utf8"));
+    const host = cfg.host ?? "127.0.0.1";
+    const port = cfg.port ?? 1080;
+    return {
+      "network.proxy.type": 1,
+      "network.proxy.socks": host,
+      "network.proxy.socks_port": port,
+      "network.proxy.socks_remote_dns": true,
+      "network.proxy.socks_version": 5,
+      "network.proxy.no_proxies_on": ""
+    };
+  } catch {
+    return {};
+  }
+}
 var browser = null;
 var initPromise = null;
 var workerId3 = "";
@@ -2904,6 +2981,7 @@ async function initBrowser() {
             // but headless Firefox on macOS/Windows is not guaranteed to be
             // silent either, so the mute is applied unconditionally.
             firefox_user_prefs: {
+              ...loadSocksProxyPrefs(),
               "media.volume_scale": "0.0",
               "media.autoplay.default": 5,
               // SSRF: WebSocket connections bypass BOTH layers of the browser

package/src/infrastructure/browser/worker-pool-manager.ts

@@ -284,7 +284,16 @@ export class WorkerPoolManager implements IService {
                         // Every intentional destroy bumps poolEpoch first, so a null-code exit
                         // that still matches the live epoch is an unexpected death and must count
                         // toward auto-recovery like any other abnormal exit.
-                        if (code !== 0 && this.poolEpoch === myEpoch) {
+                        //
+                        // EXCEPT while this instance is mid-shutdown: the SIGTERM path tears the
+                        // process down and workers die with code null while teardown (DAG disposal,
+                        // server stop, browser kill) is still unwinding. Counting those deaths as
+                        // health faults logged ERROR + scheduled a pointless auto-recovery on a
+                        // dying process — every one of the 73 null-code exits across 15 pids in
+                        // the 2026-09-01/02 logs coincided with SDK SIGTERM shutdown, tripping
+                        // "3 consecutive exits → pool unhealthy" once per dying session. Not a
+                        // queue-capacity or OOM problem: zero exits occurred during live research.
+                        if (code !== 0 && !this.isShuttingDown && this.poolEpoch === myEpoch) {
                             logger.error(`[WorkerPoolManager] Worker exited with code ${code}`);
                             this.consecutiveErrors++;
                             if (this.consecutiveErrors >= 3) {

package/src/orchestration/deep-research-orchestrator.ts

@@ -104,13 +104,15 @@ export class DeepResearchOrchestrator {
     const observer = this.observer;
     const container = tryGetServiceContainerFromCtx(ctx);
 
-    // RESEARCH_MODEL contract (config.ts): the coordinator and evaluator always
-    // use the caller's model (ctx.model); RESEARCH_MODEL overrides only the
-    // researcher sub-agents. `model` is the resolved research model — it equals
-    // ctx.model on the SDK/CLI path, but on the pi-tool path it is the
-    // RESEARCH_MODEL override, so planning must key off ctx.model explicitly.
-    // Fall back to `model` when the host exposes no ctx.model.
-    const coordinatorModel = (ctx.model as Model<any> | undefined) ?? model;
+    // The initial coordinator/evaluator (round 1 planning) uses the
+    // parent chat's model (ctx.model) so the prompt-cache prefix is
+    // shared with the conversation that preceded the research tool call —
+    // same provider, same model, same cache lineage.
+    // Later evaluator rounds (round 2+ routing) and final synthesis
+    // use the research model (RESEARCH_MODEL override or host model),
+    // which is also what the researcher sub-agents use.
+    const initialCoordinatorModel = (ctx.model as Model<any> | undefined) ?? model;
+    const evaluatorModel = model;
     
     const orchestrationService = await this.getOrchestrationService();
     const planningService = await this.getPlanningService();
@@ -249,7 +251,7 @@ export class DeepResearchOrchestrator {
                 sessionId: researchId,
                 query,
                 complexity,
-                model: coordinatorModel,
+                model: initialCoordinatorModel,
                 modelRegistry: ctx.modelRegistry,
                 cwd: ctx.cwd,
                 config: this.config,
@@ -274,7 +276,7 @@ export class DeepResearchOrchestrator {
                 query: query,
                 complexity,
                 round: this.currentRound,
-                model: coordinatorModel,
+                model: evaluatorModel,
                 modelRegistry: ctx.modelRegistry,
                 cwd: ctx.cwd,
                 config: this.config,
@@ -568,7 +570,7 @@ export class DeepResearchOrchestrator {
           query: query,
           complexity,
           round: this.currentRound,
-          model: coordinatorModel,
+          model: evaluatorModel,
           modelRegistry: ctx.modelRegistry,
           cwd: ctx.cwd,
           config: this.config,