@lincoln504/pi-research 1.3.3 → 1.3.4

package/dist/thread-worker.mjs

@@ -45,12 +45,7 @@ function formatArg(arg) {
   return String(arg);
 }
 function redactSecrets(message) {
-  let keep = MAX_LOG_MESSAGE_LENGTH;
-  if (message.length > keep) {
-    const lastKeptUnit = message.charCodeAt(keep - 1);
-    if (lastKeptUnit >= 55296 && lastKeptUnit <= 56319) keep -= 1;
-  }
-  let out = message.length > MAX_LOG_MESSAGE_LENGTH ? `${message.slice(0, keep)}\u2026[truncated ${message.length - keep} chars]` : message;
+  let out = message;
   out = out.replace(ANSI_PATTERN, "");
   out = out.replace(URL_CREDENTIALS_PATTERN, "$1[REDACTED]@");
   out = out.replace(JWT_PATTERN, "[REDACTED]");
@@ -61,6 +56,14 @@ function redactSecrets(message) {
   out = out.replace(KNOWN_TOKEN_PATTERN, "[REDACTED]");
   out = out.replace(PROVIDER_TOKEN_PATTERN, "[REDACTED]");
   out = out.replace(LONG_HEX_SECRET_PATTERN, "[REDACTED]");
+  let keep = MAX_LOG_MESSAGE_LENGTH;
+  if (out.length > keep) {
+    const lastKeptUnit = out.charCodeAt(keep - 1);
+    if (lastKeptUnit >= 55296 && lastKeptUnit <= 56319) keep -= 1;
+  }
+  if (out.length > MAX_LOG_MESSAGE_LENGTH) {
+    out = `${out.slice(0, keep)}\u2026[truncated ${out.length - keep} chars]`;
+  }
   return out;
 }
 function stripTerminalEscapes(message) {
@@ -75,7 +78,7 @@ var init_log_utils = __esm({
     ANSI_PATTERN = /\x1b\[[0-9;]*[A-Za-z]/g;
     URL_CREDENTIALS_PATTERN = /([a-z][a-z0-9+.-]*:\/\/)[^/\s:@]+:[^/\s:@]+@/gi;
     COOKIE_HEADER_PATTERN = /\b(set[_-]?cookie|cookie)\b(["']?\s*[:=]\s*["']?)([^\r\n]+)/gi;
-    SENSITIVE_KV_PATTERN = /\b(api[_-]?key|apikey|access[_-]?token|auth[_-]?token|refresh[_-]?token|secret|client[_-]?secret|password|passwd|pwd|authorization|bearer|set[_-]?cookie|cookie|session[_-]?id|session|csrf[_-]?token|xsrf[_-]?token|private[_-]?key)\b(["']?\s*[:=]\s*["']?)([^\s"',&)]+)/gi;
+    SENSITIVE_KV_PATTERN = /\b(api[_-]?key|apikey|access[_-]?token|auth[_-]?token|refresh[_-]?token|secret|client[_-]?secret|password|passwd|pwd|authorization|bearer|set[_-]?cookie|cookie|session[_-]?id|session|csrf[_-]?token|xsrf[_-]?token|private[_-]?key|key)\b(["']?\s*[:=]\s*["']?)([^\s"',&)]+)/gi;
     KNOWN_TOKEN_PATTERN = /\b(sk-[A-Za-z0-9_-]{16,}|gh[posru]_[A-Za-z0-9]{16,}|github_pat_[A-Za-z0-9_]{20,}|AKIA[0-9A-Z]{16}|xox[baprs]-[A-Za-z0-9-]{10,})\b/g;
     JWT_PATTERN = /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g;
     BASIC_AUTH_PATTERN = /\bBasic\s+[A-Za-z0-9+/]{16,}={0,2}/gi;
@@ -588,7 +591,10 @@ async function captureStdio(logFile, hasSufficientDiskSpace, task, sessionId) {
     unkeyedCaptureDepth++;
     isAnyLoggerCapturingOutput = true;
   }
-  const decoder = new TextDecoder();
+  const stderrDecoder = new TextDecoder();
+  const stdoutDecoder = new TextDecoder();
+  const fd1SyncDecoder = new TextDecoder();
+  const fd2SyncDecoder = new TextDecoder();
   const originalStderrWrite = process.stderr.write;
   const originalStdoutWrite = process.stdout.write;
   const originalFsWriteSync = fs4.writeSync;
@@ -634,7 +640,11 @@ async function captureStdio(logFile, hasSufficientDiskSpace, task, sessionId) {
   console.debug = createConsolePatch("debug", logFile, hasSufficientDiskSpace);
   process.stderr.write = (chunk, encodingOrCb, callback) => {
     const cb = typeof encodingOrCb === "function" ? encodingOrCb : callback;
-    const message = typeof chunk === "string" ? chunk : decoder.decode(chunk);
+    const message = typeof chunk === "string" ? chunk : stderrDecoder.decode(chunk, { stream: true });
+    if (message.length === 0) {
+      if (typeof cb === "function") cb();
+      return true;
+    }
     if (!hasSufficientDiskSpace()) {
       if (typeof cb === "function") cb();
       return true;
@@ -655,7 +665,7 @@ async function captureStdio(logFile, hasSufficientDiskSpace, task, sessionId) {
     return true;
   };
   process.stdout.write = (chunk, encodingOrCb, callback) => {
-    const message = typeof chunk === "string" ? chunk : decoder.decode(chunk);
+    const message = typeof chunk === "string" ? chunk : stdoutDecoder.decode(chunk, { stream: true });
     const isNative = isNativeLog(message);
     const complexTui = isComplexTui(message);
     const boxDrawing = isBoxDrawing(message);
@@ -709,7 +719,11 @@ async function captureStdio(logFile, hasSufficientDiskSpace, task, sessionId) {
     if (!descriptor || (descriptor.writable || descriptor.set)) {
       fs4.writeSync = (fd, chunk, ...args) => {
         if (fd === 1 || fd === 2) {
-          const message = typeof chunk === "string" ? chunk : decoder.decode(chunk);
+          const fdDecoder = fd === 1 ? fd1SyncDecoder : fd2SyncDecoder;
+          const message = typeof chunk === "string" ? chunk : fdDecoder.decode(chunk, { stream: true });
+          if (fd === 2 && message.length === 0) {
+            return typeof chunk === "string" ? Buffer.from(chunk).length : chunk.length;
+          }
           const isNative = isNativeLog(message);
           const boxDrawing = isBoxDrawing(message);
           const complexTui = isComplexTui(message);
@@ -1489,6 +1503,7 @@ function isBenignScrapeFailure(error) {
   return msg.startsWith("Fetch blocked:") || // bot-protection interstitial (Cloudflare, DDoS-Guard, …)
   msg.startsWith("Fetch returned stub:") || // nav-only / near-empty page
   msg.startsWith("Could not extract content from PDF") || // malformed/encrypted/scanned-only PDF
+  msg.startsWith("PDF too large") || // exceeds the deliberate 100MB policy cap
   /^HTTP \d{3}\b/.test(msg) || // remote 4xx/5xx status
   isCloudflareBlockError(error) || isTaskTimeoutError(error) || isPoolShutdownError(error);
 }
@@ -1914,32 +1929,29 @@ async function createPageSafe(context2) {
   const currentLock = pageCreationLock;
   pageCreationLock = currentLock.then(() => nextLock);
   await currentLock;
+  const pagePromise = context2.newPage();
+  pagePromise.then(release, release);
+  pagePromise.catch((err) => logToDebugFile2("DEBUG", `[ThreadWorker] Background page creation rejection: ${err.message}`));
+  let timeoutId;
   try {
-    const pagePromise = context2.newPage();
-    pagePromise.catch((err) => logToDebugFile2("DEBUG", `[ThreadWorker] Background page creation rejection: ${err.message}`));
-    let timeoutId;
-    try {
-      const result = await Promise.race([
-        pagePromise,
-        new Promise((_, reject) => {
-          timeoutId = setTimeout(() => reject(new Error("Browser page creation timed out after 60000ms")), 6e4);
-        })
-      ]);
-      if (timeoutId) clearTimeout(timeoutId);
-      return result;
-    } catch (err) {
-      if (timeoutId) clearTimeout(timeoutId);
-      pagePromise.then((p) => {
-        try {
-          p?.close?.();
-        } catch {
-        }
-      }).catch(() => {
-      });
-      throw err;
-    }
-  } finally {
-    release();
+    const result = await Promise.race([
+      pagePromise,
+      new Promise((_, reject) => {
+        timeoutId = setTimeout(() => reject(new Error("Browser page creation timed out after 60000ms")), 6e4);
+      })
+    ]);
+    if (timeoutId) clearTimeout(timeoutId);
+    return result;
+  } catch (err) {
+    if (timeoutId) clearTimeout(timeoutId);
+    pagePromise.then((p) => {
+      try {
+        p?.close?.();
+      } catch {
+      }
+    }).catch(() => {
+    });
+    throw err;
   }
 }
 function setWorkerId2(id) {
@@ -2339,6 +2351,7 @@ init_logger();
 
 // src/utils/url-utils.ts
 init_logger();
+init_log_utils();
 
 // src/config.ts
 var ConfigSchema = Type.Object({
@@ -2508,6 +2521,7 @@ var initPromise = null;
 var workerId3 = "";
 var activeTaskCount = 0;
 var resetPending = false;
+var resetPendingForBrowser = null;
 function setWorkerId3(id) {
   workerId3 = id;
 }
@@ -2518,7 +2532,11 @@ function taskFinished() {
   activeTaskCount = Math.max(0, activeTaskCount - 1);
   if (activeTaskCount === 0 && resetPending) {
     resetPending = false;
-    doResetBrowser();
+    const capturedBrowser = resetPendingForBrowser;
+    resetPendingForBrowser = null;
+    if (browser === capturedBrowser) {
+      doResetBrowser();
+    }
   }
 }
 var isBrowserConnected = () => {
@@ -2655,6 +2673,7 @@ function doResetBrowser() {
 function resetBrowser() {
   if (activeTaskCount > 1) {
     resetPending = true;
+    resetPendingForBrowser = browser;
     return;
   }
   doResetBrowser();

package/docs/CHANGELOG.md

@@ -5,6 +5,45 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.3.4] - 2026-08-09
+
+Two rounds on the clean 1.3.3 tree: a full-tree re-audit (10 independent
+reviews, each a disjoint `src/` slice) followed by a targeted security/
+cross-platform/dead-code sweep (parallel reviews of secret-redaction
+call sites, path/URL handling, Windows/macOS compatibility, and unused
+exports). Every fix below is paired with a regression test confirmed (via
+a local revert-and-rerun) to fail against the pre-fix code.
+
+### Fixed
+
+- **`createPageSafe()`'s page-creation mutex released before `newPage()` itself had settled.** The lock released in an outer `finally` as soon as its internal 60s race settled — including when the timeout won, while the real `context.newPage()` call was still pending in the background. That let the next queued caller start its own `newPage()` concurrently with the still-unsettled prior one — exactly the concurrent-`newPage()` Firefox/Juggler deadlock scenario the lock exists to prevent, and it happens precisely when the browser is already stalling under stress. Release is now tied to the underlying `newPage()` promise itself settling, independent of which branch of the timeout race resolves.
+- **A deferred `resetBrowser()` could tear down a later, unrelated, healthy browser.** The deferred-reset flag was a bare boolean with no identity tied to which browser instance it was requested against. A sibling task's own crash could take the *immediate* reset path (activeTaskCount ≤ 1) and relaunch a fresh browser without ever clearing the stale deferred flag; once the task counter later hit zero, the stale flag fired against whatever browser was current — tearing down a healthy instance a subsequent task had just started using. The flag now captures the specific browser instance at defer time and only applies if that instance is still current.
+- **`ServiceContainer.disposeAll()` could double-invoke a service's `dispose()`.** Teardown snapshotted "instances to dispose" without waiting for a `clear()`/`replace()` disposal already in flight for the same service — if that disposal had called `instance.dispose()` but not yet nulled/replaced `registration.instance`, the snapshot included it, and the DAG-teardown loop called `dispose()` a second time on the same instance, concurrently with the original call. `get()` already guarded this window for reads; `disposeAll()` now waits it out the same way before reading instances.
+- **The `WRITER_QUEUE` DI registration cached its first writer-queue object forever.** Once resolved, the registry never re-resolved it — but the writer queue is rebuilt whenever the knowledge store re-initializes (a Knowledge Mode or cwd change via `/research-config`), so every write after such a change silently landed on a disposed, closed writer queue. `storeLinkDescriptions` now resolves the writer queue directly from the already-fresh `KnowledgeStoreService` instead of through the stale cache.
+- **`KnowledgeStoreService.dispose()` lacked the identity guard `initialize()` already has.** Two concurrent `dispose()` calls arriving while an `initialize()` was in flight could both pass the early checks and both build their own teardown closure from the same instance snapshot — double-invoking `dispose()` on the embedder/store/writer-queue, the same class of race fixed in the service registry above.
+- **Chunker UTF-16 surrogate corruption at tight overlap ratios.** At a `targetSize`/`overlap` combination that left less than one code unit of slack (e.g. `targetSize:2, overlap:1`), the surrogate-pair read-side guard's two escape branches (pull back / push forward) could both be simultaneously blocked, leaving a chunk boundary mid-surrogate-pair and opening the next chunk with a lone low surrogate — silently corrupted on UTF-8 encode. The push-forward bound was off by one; landing exactly on `end` (zero overlap for that transition) is a safe position that was wrongly excluded.
+- **`redactSecrets()` truncated before redacting.** A secret straddling the 10,000-char truncation boundary had its patterns matched against the already-cut string — a credential split mid-token was too short for any pattern to recognize, leaking a fragment in the clear right before the "…[truncated N chars]" marker. Redaction now always runs on the full message before truncation.
+- **The same truncate-before-redact bug had already spread to five other call sites** that built their own short log-line summaries by truncating `error.message` before ever passing it through `redactSecrets` — `task-execution-service.ts` (5 retry-path WARN logs), `sdk.ts`'s end-of-run error summary, and `url-utils.ts`'s unparseable-URL debug log. A failing scrape/navigation routinely echoes the failing URL verbatim, which can carry userinfo credentials; each site now redacts the full message before truncating for display.
+- **`redactSecrets()`'s key/value pattern had no bare `key` alternative.** Several provider APIs (e.g. StackExchange's `?key=<apikey>` query parameter) name their credential with no qualifying prefix like `api_` or `private_`, so it fell through every existing pattern uncaught. Added `key` to the sensitive-key-name alternation, after the more specific `*_key` variants so those still match first.
+- **`stdio-capture.ts`'s `TextDecoder` instances were missing `{stream: true}`.** A single native write/writeSync call can split a multi-byte UTF-8 character's bytes across two separate calls; without streaming mode each half decoded independently to U+FFFD instead of reconstructing the original character. Also split the previously-shared decoder into one per logical byte stream (stdout, stderr, FD1, FD2) — a shared decoder's carried-over partial bytes are only valid within one continuous stream, and mixing streams could try to complete one stream's dangling sequence with another's bytes.
+- **Path traversal in `github-advisories.ts`'s repo-scoped search.** An owner or repo name of exactly `.` or `..` passed the character-allowlist regex (dots are permitted, for names like `node.js`) and, once interpolated into the API path, was collapsed by the URL parser before the request was sent — `owner=".."` turned `/repos/../rate_limit/...` into a request for `/rate_limit/...`, escaping the intended `/repos/{owner}/{name}/` scope with this tool's own GitHub credentials. The allowlist now additionally rejects a segment that is entirely dots.
+- **PDF-extraction failures conflated a broken native install with a routine malformed PDF.** `pdf-oxide-wasm` failing to load (missing prebuilt binary, corrupted install) meant PDF extraction was broken for every URL, not just one — but it shared a catch block with genuine per-PDF parse failures, so both logged at `debug` and were classified as the same benign, routine outcome. The two are now caught separately: a native-module load failure surfaces at `error` with its own metric label and is never classified as benign. Also added the missing `PDF too large` case to the benign-failure classifier (it exceeds a deliberate size cap, exactly as routine as a malformed PDF, but had never been added).
+- **Skill-installer copy-version laundering.** An ordinary re-run of `installSkill()` against an already-installed owned *copy* stamped the manifest's recorded version to the current package version without ever refreshing the actual on-disk copy — permanently defeating `reconcileSkillInstalls()`'s later staleness check, which compares the recorded version against current. The unrefreshed branch now preserves whatever version was already recorded instead of claiming it's current.
+- **`installSkill()`'s stale-symlink re-point could silently report success after deleting the skill.** The re-point unlinks the old symlink, then creates the new one; if the second step failed (e.g. a Windows junction cannot cross volumes, and `pi update` can relocate the package to a different drive) the error escaped to an outer catch that fell through to reporting "already-installed" — even though the skill directory no longer existed on disk at all. It now falls back to a copy, mirroring the fresh-install path's existing fallback for the identical failure.
+- **StackExchange REST client ignored an already-aborted signal.** The client chained an external `AbortSignal` via a bare `addEventListener('abort', ...)`, which never fires for a signal that was already aborted before the call started — an already-cancelled request still went out to the network. Replaced the hand-rolled `AbortController` + listener wiring with `createTimeoutSignal` (already used by the `security/*.ts` clients), whose `AbortSignal.any` combination correctly produces an already-aborted signal up front.
+- **StackExchange `format=compact` with `command=get` fell through to a raw JSON dump.** The compact formatter only branched on an array result (search/user/site); `get`'s single-question-with-answers object shape had no matching branch, unlike the table formatter's equivalent case. Wired up the existing (previously unused) `formatQuestionsCompact`/`formatAnswersCompact` compact formatters for this shape.
+- **A misleading, permanently-zero "sessions" healthcheck stat.** The `StateManager` health diagnostic reported `stats.activeSessions` from `state.sessions` — a field nothing in production code ever writes to (the session-tracking write API has no live caller anywhere in the codebase), so the figure was always 0, presented as if it were live data. Removed from the diagnostic; the underlying write-side API is still dead code, flagged for a future cleanup round rather than a risky mid-release refactor of state-manager's DI wiring.
+
+### Removed
+
+- `neutralizeControlChars()` (superseded by `stripTerminalEscapes()`, which already performs the same control-character neutralization as part of a superset of its job; zero remaining callers).
+- Six other dead exported utilities with zero production callers, independently verified: `didResearcherScrape`/`getResearcherScrapes` (`shared-links.ts`), `validateComplexity` (`input-validation.ts`), `normalizeStringArrayDetailed`/`NormalizeArrayResult` (`json-utils.ts`), `getCurrentRunRegistry` (`metrics.ts` — its own internal consumer already reads the underlying `AsyncLocalStorage` directly).
+
+Patch, not minor: every fix is an internal correctness/security/robustness
+change with no change to pi-research's own CLI, tool, or SDK contract —
+matching this project's established precedent for audit-round releases
+(1.3.1, 1.3.2, 1.3.3).
+
 ## [1.3.3] - 2026-08-07
 
 pi 0.84.1 compatibility. Triggered by updating the local `pi` install and

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lincoln504/pi-research",
-  "version": "1.3.3",
+  "version": "1.3.4",
   "description": "A set of web research tools (search, scrape, and others) and research agent system that uses them safely and efficiently.",
   "type": "module",
   "private": false,

package/skills/pi-research/SKILL.md

@@ -2,7 +2,7 @@
 name: pi-research
 description: "Multi-agent web research for any coding agent. Use for anything requiring current information from the internet — news, trends, product/service/company facts, statistics, people, places, events, APIs, library behavior, or 'what is X / how does X work' questions. Also use to search a local knowledge store of previously researched findings before doing live research. Powered by the pi-research engine (search, stealth scraping, security databases, Stack Exchange). Not for reading local files, running project commands, or analyzing this repository's own source."
 license: MIT
-metadata: { "author": "Lincoln Deen", "version": "1.3.3", "package": "@lincoln504/pi-research", "engine": "pi-research-sdk", "openclaw": { "requires": { "bins": ["node"] } } }
+metadata: { "author": "Lincoln Deen", "version": "1.3.4", "package": "@lincoln504/pi-research", "engine": "pi-research-sdk", "openclaw": { "requires": { "bins": ["node"] } } }
 allowed-tools: Bash(node:*)
 ---
 

package/src/core/service-registry.ts

@@ -18,9 +18,10 @@ import { AsyncLocalStorage } from 'node:async_hooks';
 
 
 /**
- * How long teardown waits for an initialization that is still in flight. Long
- * enough to cover a normal service coming up, short enough that a service blocked
- * on something slow (a model download) cannot hold shutdown open indefinitely.
+ * How long teardown waits for an initialization or a clear()/replace()
+ * disposal that is still in flight. Long enough to cover a normal service
+ * coming up or tearing down, short enough that a service blocked on
+ * something slow (a model download) cannot hold shutdown open indefinitely.
  */
 const DISPOSE_INFLIGHT_INIT_TIMEOUT_MS = 5_000;
 
@@ -521,6 +522,39 @@ export class ServiceContainer {
         if (settleTimer) clearTimeout(settleTimer);
       }
 
+      // A concurrent clear()/replace() can be mid-disposal right now: its
+      // async IIFE has already called instance.dispose() (or is about to)
+      // but hasn't yet nulled/replaced registration.instance. Snapshotting
+      // activeServices without waiting for this would include that service,
+      // and the loop below would call instance.dispose() a SECOND time on
+      // the very same instance concurrently with clear()/replace()'s own
+      // call — get() already guards against reading mid-disposal state (see
+      // its own disposalPromise wait above); teardown needs the same guard
+      // before it reads/touches registration.instance below. Bounded for the
+      // same reason as the init wait: a service stuck disposing must not
+      // hold overall teardown open indefinitely — the snapshot below still
+      // catches whatever state is left after the timeout.
+      const inFlightDisposals = Array.from(this.services.values())
+        .map((r) => r.disposalPromise)
+        .filter((p): p is Promise<void> => p != null);
+      if (inFlightDisposals.length > 0) {
+        if (this.defaultOptions.enableLogging) {
+          logger.debug(`[ServiceContainer] Waiting for ${inFlightDisposals.length} in-flight disposal(s) before teardown`);
+        }
+        let disposalSettleTimer: ReturnType<typeof setTimeout> | undefined;
+        await Promise.race([
+          Promise.allSettled(inFlightDisposals),
+          new Promise<void>((resolve) => {
+            disposalSettleTimer = setTimeout(() => {
+              logger.warn('[ServiceContainer] Timed out waiting for in-flight service disposal; proceeding with teardown');
+              resolve();
+            }, DISPOSE_INFLIGHT_INIT_TIMEOUT_MS);
+            disposalSettleTimer.unref?.();
+          }),
+        ]);
+        if (disposalSettleTimer) clearTimeout(disposalSettleTimer);
+      }
+
       const activeServices = Array.from(this.services.keys()).filter(name =>
         this.services.get(name)?.instance !== null
       );

package/src/healthcheck/index.ts

@@ -233,17 +233,19 @@ export function registerHealthChecks(registry: IHealthRegistryService, container
   registry.register('StateManager', async () => {
     try {
       const stateManager = await getService<IStateManager>(ServiceNames.STATE_MANAGER, { container }, container);
-      const stats = await stateManager.getMetrics();
       const gpuOwner = await stateManager.getGpuOwner();
-      
-      return { 
-          healthy: true, 
-          diagnostic: { 
+
+      // No `sessions` field here: the session-tracking API (addSession/
+      // removeSession/updateHeartbeat) that would ever populate state.sessions
+      // has no production caller anywhere in the codebase — stats.activeSessions
+      // was always 0, permanently, presenting fake data as a live diagnostic.
+      return {
+          healthy: true,
+          diagnostic: {
               status: 'operational',
-              sessions: stats.activeSessions,
               gpuLocked: !!gpuOwner,
               gpuOwner: gpuOwner?.sessionId || 'none'
-          } 
+          }
       };
     } catch (e) {
       return { healthy: false, error: `State manager healthcheck failed: ${e instanceof Error ? e.message : String(e)}` };

package/src/infrastructure/browser/task-execution-service.ts

@@ -9,6 +9,7 @@ import type { Config } from '../../config.ts';
 import type { SearchResult } from '../../web-research/types.ts';
 import type { BrowserTask } from '../../types/index.ts';
 import { logger } from '../../logger.ts';
+import { redactSecrets } from '../../utils/log-utils.ts';
 import { errorTracker } from '../../utils/error-tracker.ts';
 import { getBrowserCircuitBreaker, browserCircuitBreaker, isTransientSocketError, isPoolShutdownError, isTaskTimeoutError, isCloudflareBlockError } from './browser-error-utils.ts';
 import { getScheduler as _getScheduler, forceSchedulerRestart as _forceSchedulerRestart } from './scheduler-factory.ts';
@@ -42,6 +43,21 @@ const LEADER_HANDOVER_RETRIES = 3;
 /** Backoff between handover attempts — long enough for an election to complete. */
 const HANDOVER_BACKOFF_MS = 1200;
 
+/**
+ * A short, log-line-sized summary of an error — redacted BEFORE truncating.
+ * A raw error.message can echo the failing URL verbatim (Playwright/undici
+ * navigation errors routinely do), and a URL can carry userinfo credentials
+ * (https://user:pass@host/...). Truncating first — the old `.substring(0,
+ * 100)` at each call site below — can cut a credential mid-token, leaving a
+ * short unredacted fragment in the log: redactSecrets' patterns need to see
+ * the whole token to recognize it. Same class of bug as the truncate-before-
+ * redact fix in log-utils.ts itself; redact the full message first here too.
+ */
+export function briefErrorMessage(error: unknown): string {
+    const msg = error instanceof Error ? error.message : String(error);
+    return redactSecrets(msg).substring(0, 100);
+}
+
 /**
  * Recover from a leader handover before retrying.
  *
@@ -225,7 +241,7 @@ export async function runBrowserTask<T>(
                 taskType: type,
                 errorType: 'leader_handover',
             });
-            logger.warn(`[BrowserManager] Leader handover during ${type} task (handover attempts left: ${handoverRetries}): ${(error instanceof Error ? error.message : String(error)).substring(0, 100)}...`);
+            logger.warn(`[BrowserManager] Leader handover during ${type} task (handover attempts left: ${handoverRetries}): ${briefErrorMessage(error)}...`);
             await recoverFromLeaderHandover(container);
             await new Promise((resolve) => setTimeout(resolve, HANDOVER_BACKOFF_MS + Math.floor(Math.random() * 400)));
             return runBrowserTask<T>(taskOrUrl, type, config, signal, retries, container, handoverRetries - 1);
@@ -238,7 +254,7 @@ export async function runBrowserTask<T>(
                 taskType: type,
                 errorType: 'transient_socket_error',
             });
-            logger.warn(`[BrowserManager] Transient socket error during ${type} task (retries left: ${retries}): ${(error instanceof Error ? error.message : String(error)).substring(0, 100)}...`);
+            logger.warn(`[BrowserManager] Transient socket error during ${type} task (retries left: ${retries}): ${briefErrorMessage(error)}...`);
 
             if (isPoolShutdownError(error)) {
                 // Handover budget already spent — fall back to a plain drain wait.
@@ -280,7 +296,7 @@ export async function runBrowserHealthCheck(config?: Config, retries = 1, signal
                 operation: 'healthcheck',
                 errorType: 'transient_socket_error',
             });
-            logger.warn(`[BrowserManager] Transient socket error during healthcheck (retries left: ${retries}): ${(error instanceof Error ? error.message : String(error)).substring(0, 100)}...`);
+            logger.warn(`[BrowserManager] Transient socket error during healthcheck (retries left: ${retries}): ${briefErrorMessage(error)}...`);
 
             if (isPoolShutdownError(error)) {
                 // Same stale-handle trap as the task paths: waiting alone leaves the
@@ -329,7 +345,7 @@ export async function runWorkerSearch(query: string, config?: Config, signal?: A
                 query,
                 errorType: 'leader_handover',
             });
-            logger.warn(`[BrowserManager] Leader handover during search (handover attempts left: ${handoverRetries}): ${(error instanceof Error ? error.message : String(error)).substring(0, 100)}...`);
+            logger.warn(`[BrowserManager] Leader handover during search (handover attempts left: ${handoverRetries}): ${briefErrorMessage(error)}...`);
             await recoverFromLeaderHandover(container);
             await new Promise((resolve) => setTimeout(resolve, HANDOVER_BACKOFF_MS + Math.floor(Math.random() * 400)));
             return runWorkerSearch(query, config, signal, retries, sessionId, container, handoverRetries - 1);
@@ -342,7 +358,7 @@ export async function runWorkerSearch(query: string, config?: Config, signal?: A
                 query,
                 errorType: 'transient_socket_error',
             });
-            logger.warn(`[BrowserManager] Transient socket error during search (retries left: ${retries}): ${(error instanceof Error ? error.message : String(error)).substring(0, 100)}...`);
+            logger.warn(`[BrowserManager] Transient socket error during search (retries left: ${retries}): ${briefErrorMessage(error)}...`);
 
             if (isPoolShutdownError(error)) {
                 await waitForBrowserPoolIdle(15000).catch((err) => logger.debug('Wait for browser idle timed out or failed:', err));

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

@@ -30,6 +30,12 @@ let activeTaskCount = 0;
 // A reset that resetBrowser() deferred because sibling tasks were still
 // active, to be applied once the last one finishes.
 let resetPending = false;
+// The browser instance resetPending was requested against, captured at defer
+// time. An intervening resetBrowser() call from a SIBLING task can take the
+// immediate path (doResetBrowser() + a fresh initBrowser() relaunch) while
+// this flag is still pending — see taskFinished() below for why the flag
+// alone isn't enough to know whether it's still safe to apply.
+let resetPendingForBrowser: any = null;
 
 /**
  * Set the worker ID for logging purposes
@@ -48,7 +54,19 @@ export function taskFinished(): void {
   activeTaskCount = Math.max(0, activeTaskCount - 1);
   if (activeTaskCount === 0 && resetPending) {
     resetPending = false;
-    doResetBrowser();
+    const capturedBrowser = resetPendingForBrowser;
+    resetPendingForBrowser = null;
+    // A sibling task's OWN crash can call resetBrowser() while this flag is
+    // still pending; if that call sees activeTaskCount <= 1 it takes the
+    // IMMEDIATE path (doResetBrowser() below), which tears the browser down
+    // and lets the next task's initBrowser() relaunch a brand-new, unrelated
+    // instance — all without ever touching this flag. Applying a stale
+    // deferred reset unconditionally would then tear down that later,
+    // healthy instance instead of being the no-op it should be. Only apply
+    // it if the browser is still the exact instance it was requested against.
+    if (browser === capturedBrowser) {
+      doResetBrowser();
+    }
   }
 }
 
@@ -301,6 +319,7 @@ function doResetBrowser(): void {
 export function resetBrowser(): void {
   if (activeTaskCount > 1) {
     resetPending = true;
+    resetPendingForBrowser = browser;
     return;
   }
   doResetBrowser();

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

@@ -16,35 +16,43 @@ import { MAX_HTML_SIZE, MAX_PDF_SIZE } from '../../web-research/scraper-types.ts
  */
 let pageCreationLock = Promise.resolve();
 
-async function createPageSafe(context: any): Promise<any> {
+/** Exported for unit testing of the page-creation mutex's timeout behavior. */
+export async function createPageSafe(context: any): Promise<any> {
   let release!: () => void;
   const nextLock = new Promise<void>(resolve => { release = resolve; });
   const currentLock = pageCreationLock;
   pageCreationLock = currentLock.then(() => nextLock);
 
   await currentLock;
+  const pagePromise = context.newPage();
+  // Release the mutex only once newPage() itself has actually settled — NOT when
+  // the timeout race below settles. Releasing in an outer `finally` (the old
+  // shape) fired as soon as the 60s timeout won the race, while newPage() was
+  // still pending in the background — so the NEXT queued caller started its OWN
+  // newPage() concurrently with this still-unsettled one, exactly the concurrent-
+  // newPage() scenario this lock exists to prevent (see the comment above), and
+  // it happens precisely when the browser is already under the stress that
+  // causes 60s+ page-creation stalls in the first place. Attached before the
+  // race starts so it's independent of which branch below returns/throws.
+  pagePromise.then(release, release);
+  pagePromise.catch((err: Error) => logToDebugFile('DEBUG', `[ThreadWorker] Background page creation rejection: ${err.message}`));
+
+  let timeoutId: NodeJS.Timeout | undefined;
   try {
-    const pagePromise = context.newPage();
-    pagePromise.catch((err: Error) => logToDebugFile('DEBUG', `[ThreadWorker] Background page creation rejection: ${err.message}`));
-    let timeoutId: NodeJS.Timeout | undefined;
-    try {
-      const result = await Promise.race([
-        pagePromise,
-        new Promise<never>((_, reject) => {
-          timeoutId = setTimeout(() => reject(new Error('Browser page creation timed out after 60000ms')), 60000);
-        })
-      ]);
-      if (timeoutId) clearTimeout(timeoutId);
-      return result;
-    } catch (err) {
-      if (timeoutId) clearTimeout(timeoutId);
-      // The timeout (or another error) won the race. If newPage() later resolves,
-      // close that orphaned page so it doesn't accumulate in the long-lived context.
-      pagePromise.then((p: any) => { try { p?.close?.(); } catch { /* already gone */ } }).catch(() => {});
-      throw err;
-    }
-  } finally {
-    release();
+    const result = await Promise.race([
+      pagePromise,
+      new Promise<never>((_, reject) => {
+        timeoutId = setTimeout(() => reject(new Error('Browser page creation timed out after 60000ms')), 60000);
+      })
+    ]);
+    if (timeoutId) clearTimeout(timeoutId);
+    return result;
+  } catch (err) {
+    if (timeoutId) clearTimeout(timeoutId);
+    // The timeout (or another error) won the race. If newPage() later resolves,
+    // close that orphaned page so it doesn't accumulate in the long-lived context.
+    pagePromise.then((p: any) => { try { p?.close?.(); } catch { /* already gone */ } }).catch(() => {});
+    throw err;
   }
 }