@lincoln504/pi-research 1.3.5 → 1.3.7

package/README.md

@@ -1,9 +1,9 @@
 <p align="center">
-  <img src="https://raw.githubusercontent.com/Lincoln504/pi-research/main/docs/media/banner.jpg" alt="pi-research" width="100%" />
+  <img src="https://raw.githubusercontent.com/Lincoln504/pi-research/main/docs/media/banner.jpg" alt="pi-research — free, unlimited web search and deep research for coding agents" width="100%" />
 </p>
 
 <p align="center">
-  <strong>Local web research and knowledge store</strong>
+  <strong>Free, unlimited web search &amp; deep research for coding agents — no API key, no quota</strong>
 </p>
 
 <p align="center">
@@ -24,75 +24,55 @@
 
 <a href="https://github.com/Lincoln504/pi-research/actions/workflows/ci.yml"><img alt="Build status" src="https://img.shields.io/github/actions/workflow/status/Lincoln504/pi-research/ci.yml?style=flat-square&branch=main" /></a> <a href="https://www.npmjs.com/package/@lincoln504/pi-research"><img alt="npm version" src="https://img.shields.io/npm/v/@lincoln504/pi-research.svg?style=flat-square" /></a>
 
-**Free, unlimited web search &amp; scraping — no monthly quota, no subscription.**
-You pay only for the LLM tokens you use, and it builds your own private, searchable
-knowledge store on your machine.
+Search and scraping run locally through a stealth browser — no search provider, no monthly cap. You pay only for the LLM tokens you use.
+
+### Install
+
+```bash
+pi install npm:@lincoln504/pi-research
+```
+
+In [pi](https://github.com/earendil-works/pi) it works out of the box, on your session's model and pi's configuration. Standalone use — [agent skill](docs/AGENT-SKILL.md), CLI, or [SDK](docs/SDK.md) — needs a model configured; see [Configuration](docs/CONFIGURATION.md). The first install pulls the stealth browser engine, which takes a few minutes.
 
 ### How it works
 
-A research run is a loop of agent teams: a coordinator plans the work and runs an
-opening search, parallel researcher agents scrape and read sources through a fixed,
-sandboxed toolkit (no shell access, and no ability to write or modify files), and an evaluator decides whether
-to run another round or synthesize — returning one cited Markdown report while its
-sources are saved to the knowledge store in the background.
+A research run loops through agent teams: a coordinator plans and opens with a search, researcher agents scrape and read in parallel, and an evaluator decides whether to go another round or synthesize. The result is one cited Markdown report, with findings optionally saved to the knowledge store.
 
-Three depth levels — normal, deep, ultra — set the team size and number of rounds;
-ask in natural language and the tool picks the right one:
+Three depth levels — normal, deep, ultra — set the team size and number of rounds. Ask in natural language and the tool picks the right one:
 
 ![Prompt-driven multi-round research in the pi TUI](https://raw.githubusercontent.com/Lincoln504/pi-research/main/docs/media/02-prompt-research.gif)
 
 ### Use cases
 
-- Plug-and-play (no API key needed) research tool for your [Pi](https://github.com/earendil-works/pi) Coding Agent.
-- Research from Claude Code, Codex, or another coding agent, with a cheaper lightweight or local model driving the research so it doesn't spend your main agent's budget.
-- Populating a dataset or building an index of knowledge sources from the web.
-- Holding research in the knowledge store with a configurable scope — project-specific or globally user-scoped, set per directory from the `/research-config` TUI.
-- Using the pi-research agent skill as OpenClaw's web access.
-- Building agent systems that identify and examine web sources.
+- Researching for your [Pi](https://github.com/earendil-works/pi) Coding Agent — plug-and-play, no API key needed.
+- Researching from Claude Code, Codex, OpenClaw, or another coding agent, with a cheaper or local model driving the run so it doesn't spend your main agent's budget.
+- Keeping a persistent, searchable knowledge store of findings — global or per-project.
+- Building agent systems that find and read web content, or populating a dataset of web sources.
 
 ### Why pi-research
 
-- **Free, unlimited search &amp; scrape — no quota, no monthly fee.** Most AI-search providers cap free searches per month and then charge; results run on *their* index on *their* servers. pi-research's search and scraping layer (DuckDuckGo via a stealth browser) is free and unlimited — you pay only for the LLM tokens you use, never per search or per month.
-- **You own your index.** Every finding is written into a local [LanceDB](https://lancedb.com) knowledge store on *your* machine — a persistent, searchable index you control and keep, which also seeds future runs so repeat questions get faster, cheaper answers. No borrowed, server-side index you can't keep or query. Findings can also be kept **globally**, scoped to a **single project**, or **not kept at all** — set per directory, changed whenever you like. The optionality is the point: the store is yours to build, partition, or switch off.
-- **Cited reports, not raw dumps.** It returns one synthesized, sourced Markdown report to the chat instead of dumping raw web content into the conversation — context-efficient and easy to verify.
-- **Read-only by design.** Web access runs inside a specialized, limited research agent that cannot run shell commands or write, edit, or delete anything. It can read and search files, so treat it as you would any read-only agent with access to your machine.
-- **Search a little or a lot** — three depth levels in the pi tool (four via the SDK and standalone CLI, which add the quick depth-0 path). Levels 1 and 2 are recommended for everyday workflow use; level 3 is for larger-scale investigations.
+- **No quota, no monthly fee.** Most AI-search providers cap free searches and then charge, with results served from *their* index on *their* servers. pi-research searches and scrapes locally — DuckDuckGo via a stealth browser.
+- **You own your index.** Every finding is written to a local [LanceDB](https://lancedb.com) knowledge store that seeds future runs, so repeat questions get faster, cheaper answers.
+- **Cited reports, not raw dumps.** One synthesized, sourced Markdown report instead of raw web content pasted into the conversation — context-efficient and easy to verify.
+- **Read-only by design.** The research agent cannot run shell commands or write, edit, or delete anything. It can read and search files, so treat it as you would any read-only agent with access to your machine.
+- **Search a little or a lot.** Depth levels span a quick pass to a large-scale investigation.
 
 ### Requirements / limitations
 
 - Node.js >= 22.19.0
-- An LLM with a 100k+ context window (bring your own key or use a local model)
-- Internet access
-- A residential IP address — search, scraping, and YouTube transcripts all rely on a residential connection. A datacenter/VPS/cloud IP gets bot-blocked by the providers these features depend on.
-- The pi runtime the engine builds on — `@earendil-works/pi-ai`, `@earendil-works/pi-coding-agent`, and `@earendil-works/pi-tui`. The pi extension uses the host's copies; the standalone CLI / agent skill install them as dependencies.
-- Cloudflare and similar anti-automation systems block scraping on some sites, so runs will identify sources they cannot reach. pi-research compensates with volume: the search tool rapidly pulls a large set of results off free DuckDuckGo, giving the model a wide selection of reachable content to cite.
-
-### Install
-
-```bash
-pi install npm:@lincoln504/pi-research
-```
-
-See [Agent skill](docs/AGENT-SKILL.md) or [SDK](docs/SDK.md) for standalone (no pi extension) installation.
-
-The pi extension works out of the box — it runs on your pi session's model and pi's own configuration. Standalone use (agent skill / CLI) requires a configured model: set `PI_RESEARCH_MODEL` (e.g. `openai/gpt-4o`) as an environment variable or in `~/.pi/research/config.env` (the CLI also accepts a per-run `--model`), plus `PI_RESEARCH_API_KEY` if you don't use pi; the SDK takes a `model` option. See [Configuration](docs/CONFIGURATION.md).
-
-The first install pulls the stealth browser engine, which takes a few minutes.
-
-### Stability (v1.x.x)
+- An LLM with a 100k+ context window — bring your own key or use a local model
+- Internet access on a residential IP — search, scraping, and YouTube transcripts rely on a residential connection; a datacenter/VPS/cloud IP gets bot-blocked
+- The [pi runtime](https://github.com/earendil-works/pi) — the pi extension uses the host's copy; the standalone CLI and agent skill install it as a dependency
+- Cloudflare and similar systems block scraping on some sites — a run flags pages it can't reach and compensates with a wide pool of search results to cite
 
-v0.1.13 (April 2026) was the last release before a rebuild against current pi APIs
-and the stealth-browser stack. v1.0.0 is the first stable release since. Channels:
+### Channels
 
-- npm (`npm:@lincoln504/pi-research`) is the stable channel, kept current with breaking pi changes.
-- A git install is the development channel: latest commits, first to break.
+npm (`npm:@lincoln504/pi-research`) is the stable channel, kept current with breaking pi changes. A git install is the development channel: latest commits, first to break.
 
 ### License
 
-MIT. Bundled third-party licenses are listed in
-[docs/THIRD-PARTY-NOTICES.md](docs/THIRD-PARTY-NOTICES.md).
+MIT. Bundled third-party licenses are listed in [docs/THIRD-PARTY-NOTICES.md](docs/THIRD-PARTY-NOTICES.md).
 
 ### Package identity
 
-This project is always `@lincoln504/pi-research` on npm. The unscoped `pi-research`
-package is unrelated and deprecated.
+This project is always `@lincoln504/pi-research` on npm. The `pi-research` (unscoped) package is unrelated and deprecated.

package/dist/cli.mjs

@@ -216,7 +216,14 @@ function formatArg(arg) {
 }
 function redactSecrets(message) {
   const rawLength = message.length;
-  let out = rawLength > REDACT_SCAN_LENGTH ? message.slice(0, REDACT_SCAN_LENGTH) : message;
+  let scanEnd = REDACT_SCAN_LENGTH;
+  if (rawLength > scanEnd) {
+    const extensionLimit = Math.min(rawLength, scanEnd + REDACT_SCAN_EXTENSION_MAX);
+    while (scanEnd < extensionLimit && TOKEN_CHAR_PATTERN.test(message.charAt(scanEnd))) {
+      scanEnd += 1;
+    }
+  }
+  let out = rawLength > scanEnd ? message.slice(0, scanEnd) : message;
   out = out.replace(ANSI_PATTERN, "");
   out = out.replace(URL_CREDENTIALS_PATTERN, "$1[REDACTED]@");
   out = out.replace(JWT_PATTERN, "[REDACTED]");
@@ -233,14 +240,14 @@ function redactSecrets(message) {
     if (lastKeptUnit >= 55296 && lastKeptUnit <= 56319) keep -= 1;
   }
   if (out.length > MAX_LOG_MESSAGE_LENGTH) {
-    out = `${out.slice(0, keep)}\u2026[truncated ${rawLength - keep} chars]`;
+    out = `${out.slice(0, keep)}\u2026[truncated ${Math.max(rawLength, out.length) - keep} chars]`;
   }
   return out;
 }
 function stripTerminalEscapes(message) {
   return message.replace(TERMINAL_ESCAPE_PATTERN, "").replace(CONTROL_CHARS_PATTERN, " ");
 }
-var logContextStorage, MAX_LOG_MESSAGE_LENGTH, ANSI_PATTERN, URL_CREDENTIALS_PATTERN, COOKIE_HEADER_PATTERN, SENSITIVE_KV_PATTERN, KNOWN_TOKEN_PATTERN, JWT_PATTERN, BASIC_AUTH_PATTERN, BEARER_AUTH_PATTERN, PROVIDER_TOKEN_PATTERN, LONG_HEX_SECRET_PATTERN, CONTROL_CHARS_PATTERN, REDACT_SCAN_LENGTH, TERMINAL_ESCAPE_PATTERN;
+var logContextStorage, MAX_LOG_MESSAGE_LENGTH, ANSI_PATTERN, URL_CREDENTIALS_PATTERN, COOKIE_HEADER_PATTERN, SENSITIVE_KV_PATTERN, KNOWN_TOKEN_PATTERN, JWT_PATTERN, BASIC_AUTH_PATTERN, BEARER_AUTH_PATTERN, PROVIDER_TOKEN_PATTERN, LONG_HEX_SECRET_PATTERN, CONTROL_CHARS_PATTERN, REDACT_SCAN_LENGTH, TOKEN_CHAR_PATTERN, REDACT_SCAN_EXTENSION_MAX, TERMINAL_ESCAPE_PATTERN;
 var init_log_utils = __esm({
   "src/utils/log-utils.ts"() {
     "use strict";
@@ -258,6 +265,8 @@ var init_log_utils = __esm({
     LONG_HEX_SECRET_PATTERN = /\b[0-9a-fA-F]{32,}\b/g;
     CONTROL_CHARS_PATTERN = /[\x00-\x1f\x7f]/g;
     REDACT_SCAN_LENGTH = MAX_LOG_MESSAGE_LENGTH * 4;
+    TOKEN_CHAR_PATTERN = /[A-Za-z0-9_\-./+=]/;
+    REDACT_SCAN_EXTENSION_MAX = 2048;
     TERMINAL_ESCAPE_PATTERN = new RegExp(
       "\\x1b\\[[0-?]*[ -/]*[@-~]?|\\x1b\\][^\\x07\\x1b]*(?:\\x07|\\x1b\\\\)?|\\x1b[PX^_][^\\x1b]*(?:\\x1b\\\\)?|\\x1b.?",
       "g"
@@ -269,9 +278,18 @@ var init_log_utils = __esm({
 import * as fs from "node:fs";
 import * as path2 from "node:path";
 function touchOwnerOnly(filePath, mode) {
+  let fd;
   try {
-    fs.closeSync(fs.openSync(filePath, APPEND_CREATE_NOFOLLOW_FLAGS, mode));
+    fd = fs.openSync(filePath, APPEND_CREATE_NOFOLLOW_FLAGS, mode);
+    fs.fchmodSync(fd, mode);
   } catch {
+  } finally {
+    if (fd !== void 0) {
+      try {
+        fs.closeSync(fd);
+      } catch {
+      }
+    }
   }
 }
 var APPEND_CREATE_NOFOLLOW_FLAGS, LogRotation;
@@ -297,10 +315,6 @@ var init_log_rotation = __esm({
           if (fs.existsSync(logFile)) {
             fs.unlinkSync(logFile);
             touchOwnerOnly(logFile, 384);
-            try {
-              fs.chmodSync(logFile, 384);
-            } catch {
-            }
           }
           const files = fs.readdirSync(logDir);
           const baseName = path2.basename(logFile);
@@ -337,10 +351,6 @@ var init_log_rotation = __esm({
             return;
           }
           touchOwnerOnly(logFile, 384);
-          try {
-            fs.chmodSync(logFile, 384);
-          } catch {
-          }
           try {
             const files = fs.readdirSync(logDir);
             const logFiles = files.filter((f) => f.startsWith(path2.basename(logFile)) && f !== path2.basename(logFile)).sort();
@@ -9914,19 +9924,19 @@ function reconcileSkillInstalls(opts = {}) {
     if (e.type !== "symlink") {
       const stale2 = currentVersion !== null && e.version !== currentVersion;
       if (stale2 && source !== null && fs16.existsSync(e.path) && isOwnedCopy(e.path)) {
-        const dir = path17.dirname(e.path);
-        const base = path17.basename(e.path);
+        const dir2 = path17.dirname(e.path);
+        const base2 = path17.basename(e.path);
         try {
-          for (const name of fs16.readdirSync(dir)) {
-            if (name.startsWith(`.${base}.new-`) || name.startsWith(`.${base}.old-`)) {
-              fs16.rmSync(path17.join(dir, name), { recursive: true, force: true });
+          for (const name of fs16.readdirSync(dir2)) {
+            if (name.startsWith(`.${base2}.new-`) || name.startsWith(`.${base2}.old-`)) {
+              fs16.rmSync(path17.join(dir2, name), { recursive: true, force: true });
             }
           }
         } catch {
         }
         const suffix = crypto10.randomBytes(4).toString("hex");
-        const fresh = path17.join(dir, `.${base}.new-${suffix}`);
-        const retired = path17.join(dir, `.${base}.old-${suffix}`);
+        const fresh = path17.join(dir2, `.${base2}.new-${suffix}`);
+        const retired = path17.join(dir2, `.${base2}.old-${suffix}`);
         try {
           copyDir(source, fresh);
         } catch {
@@ -9972,6 +9982,16 @@ function reconcileSkillInstalls(opts = {}) {
       }
       continue;
     }
+    const dir = path17.dirname(e.path);
+    const base = path17.basename(e.path);
+    try {
+      for (const name of fs16.readdirSync(dir)) {
+        if (name.startsWith(`.${base}.new-`)) {
+          fs16.rmSync(path17.join(dir, name), { recursive: true, force: true });
+        }
+      }
+    } catch {
+    }
     if (!isSymlinkPresent(e.path)) {
       result.pruned.push(e.path);
       continue;
@@ -10000,8 +10020,6 @@ function reconcileSkillInstalls(opts = {}) {
           keep.push({ ...e, type: "symlink", source });
           result.repointed.push(e.path);
         } catch {
-          const dir = path17.dirname(e.path);
-          const base = path17.basename(e.path);
           const suffix = crypto10.randomBytes(4).toString("hex");
           const fresh = path17.join(dir, `.${base}.new-${suffix}`);
           try {
@@ -20677,14 +20695,22 @@ function describeError(error) {
   return String(error);
 }
 var mintChain = Promise.resolve();
+var wedged = false;
 var MINT_HARD_RELEASE_MS = 5 * 60 * 1e3;
 async function mintPoTokens(identifiers, opts = {}) {
+  if (wedged) {
+    throw new Error("PoToken minter is wedged by a prior mint that never settled; refusing to start a new mint until it resolves.");
+  }
   const run = mintChain.then(() => doMint(identifiers, opts), () => doMint(identifiers, opts));
   const settled = run.then(() => void 0, () => void 0);
+  settled.then(() => {
+    wedged = false;
+  });
   let hardTimer;
   const hardRelease = new Promise((resolve9) => {
     hardTimer = setTimeout(() => {
       logger.warn("[youtube] potoken mint mutex force-released \u2014 doMint() did not settle within the hard timeout");
+      wedged = true;
       resolve9();
     }, MINT_HARD_RELEASE_MS);
     safeUnref(hardTimer);

package/dist/thread-worker.mjs

@@ -46,7 +46,14 @@ function formatArg(arg) {
 }
 function redactSecrets(message) {
   const rawLength = message.length;
-  let out = rawLength > REDACT_SCAN_LENGTH ? message.slice(0, REDACT_SCAN_LENGTH) : message;
+  let scanEnd = REDACT_SCAN_LENGTH;
+  if (rawLength > scanEnd) {
+    const extensionLimit = Math.min(rawLength, scanEnd + REDACT_SCAN_EXTENSION_MAX);
+    while (scanEnd < extensionLimit && TOKEN_CHAR_PATTERN.test(message.charAt(scanEnd))) {
+      scanEnd += 1;
+    }
+  }
+  let out = rawLength > scanEnd ? message.slice(0, scanEnd) : message;
   out = out.replace(ANSI_PATTERN, "");
   out = out.replace(URL_CREDENTIALS_PATTERN, "$1[REDACTED]@");
   out = out.replace(JWT_PATTERN, "[REDACTED]");
@@ -63,14 +70,14 @@ function redactSecrets(message) {
     if (lastKeptUnit >= 55296 && lastKeptUnit <= 56319) keep -= 1;
   }
   if (out.length > MAX_LOG_MESSAGE_LENGTH) {
-    out = `${out.slice(0, keep)}\u2026[truncated ${rawLength - keep} chars]`;
+    out = `${out.slice(0, keep)}\u2026[truncated ${Math.max(rawLength, out.length) - keep} chars]`;
   }
   return out;
 }
 function stripTerminalEscapes(message) {
   return message.replace(TERMINAL_ESCAPE_PATTERN, "").replace(CONTROL_CHARS_PATTERN, " ");
 }
-var logContextStorage, MAX_LOG_MESSAGE_LENGTH, ANSI_PATTERN, URL_CREDENTIALS_PATTERN, COOKIE_HEADER_PATTERN, SENSITIVE_KV_PATTERN, KNOWN_TOKEN_PATTERN, JWT_PATTERN, BASIC_AUTH_PATTERN, BEARER_AUTH_PATTERN, PROVIDER_TOKEN_PATTERN, LONG_HEX_SECRET_PATTERN, CONTROL_CHARS_PATTERN, REDACT_SCAN_LENGTH, TERMINAL_ESCAPE_PATTERN;
+var logContextStorage, MAX_LOG_MESSAGE_LENGTH, ANSI_PATTERN, URL_CREDENTIALS_PATTERN, COOKIE_HEADER_PATTERN, SENSITIVE_KV_PATTERN, KNOWN_TOKEN_PATTERN, JWT_PATTERN, BASIC_AUTH_PATTERN, BEARER_AUTH_PATTERN, PROVIDER_TOKEN_PATTERN, LONG_HEX_SECRET_PATTERN, CONTROL_CHARS_PATTERN, REDACT_SCAN_LENGTH, TOKEN_CHAR_PATTERN, REDACT_SCAN_EXTENSION_MAX, TERMINAL_ESCAPE_PATTERN;
 var init_log_utils = __esm({
   "src/utils/log-utils.ts"() {
     "use strict";
@@ -88,6 +95,8 @@ var init_log_utils = __esm({
     LONG_HEX_SECRET_PATTERN = /\b[0-9a-fA-F]{32,}\b/g;
     CONTROL_CHARS_PATTERN = /[\x00-\x1f\x7f]/g;
     REDACT_SCAN_LENGTH = MAX_LOG_MESSAGE_LENGTH * 4;
+    TOKEN_CHAR_PATTERN = /[A-Za-z0-9_\-./+=]/;
+    REDACT_SCAN_EXTENSION_MAX = 2048;
     TERMINAL_ESCAPE_PATTERN = new RegExp(
       "\\x1b\\[[0-?]*[ -/]*[@-~]?|\\x1b\\][^\\x07\\x1b]*(?:\\x07|\\x1b\\\\)?|\\x1b[PX^_][^\\x1b]*(?:\\x1b\\\\)?|\\x1b.?",
       "g"
@@ -360,9 +369,18 @@ var init_error_tracker = __esm({
 import * as fs2 from "node:fs";
 import * as path2 from "node:path";
 function touchOwnerOnly(filePath, mode) {
+  let fd;
   try {
-    fs2.closeSync(fs2.openSync(filePath, APPEND_CREATE_NOFOLLOW_FLAGS, mode));
+    fd = fs2.openSync(filePath, APPEND_CREATE_NOFOLLOW_FLAGS, mode);
+    fs2.fchmodSync(fd, mode);
   } catch {
+  } finally {
+    if (fd !== void 0) {
+      try {
+        fs2.closeSync(fd);
+      } catch {
+      }
+    }
   }
 }
 var APPEND_CREATE_NOFOLLOW_FLAGS, LogRotation;
@@ -388,10 +406,6 @@ var init_log_rotation = __esm({
           if (fs2.existsSync(logFile)) {
             fs2.unlinkSync(logFile);
             touchOwnerOnly(logFile, 384);
-            try {
-              fs2.chmodSync(logFile, 384);
-            } catch {
-            }
           }
           const files = fs2.readdirSync(logDir);
           const baseName = path2.basename(logFile);
@@ -428,10 +442,6 @@ var init_log_rotation = __esm({
             return;
           }
           touchOwnerOnly(logFile, 384);
-          try {
-            fs2.chmodSync(logFile, 384);
-          } catch {
-          }
           try {
             const files = fs2.readdirSync(logDir);
             const logFiles = files.filter((f) => f.startsWith(path2.basename(logFile)) && f !== path2.basename(logFile)).sort();
@@ -1920,11 +1930,21 @@ import { platform as platform2 } from "node:os";
 
 // src/infrastructure/browser/thread-worker-messaging.ts
 init_log_utils();
-init_scraper_types();
 import { appendFileSync as appendFileSync2 } from "node:fs";
+
+// src/utils/safe-unref.ts
+function safeUnref(timer) {
+  if (timer && typeof timer.unref === "function") {
+    timer.unref();
+  }
+}
+
+// src/infrastructure/browser/thread-worker-messaging.ts
+init_scraper_types();
 var workerId2 = "";
 var pageCreationLock = Promise.resolve();
 var PAGE_CREATION_HARD_RELEASE_MS = 5 * 60 * 1e3;
+var wedgedContext = null;
 async function createPageSafe(context2) {
   let release;
   const nextLock = new Promise((resolve) => {
@@ -1933,6 +1953,10 @@ async function createPageSafe(context2) {
   const currentLock = pageCreationLock;
   pageCreationLock = currentLock.then(() => nextLock);
   await currentLock;
+  if (context2 === 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();
   let hardReleased = false;
   const releaseOnce = () => {
@@ -1943,9 +1967,20 @@ 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;
     releaseOnce();
   }, PAGE_CREATION_HARD_RELEASE_MS);
-  pagePromise.then(releaseOnce, releaseOnce);
+  safeUnref(hardReleaseTimer);
+  pagePromise.then(
+    () => {
+      if (wedgedContext === context2) wedgedContext = null;
+      releaseOnce();
+    },
+    () => {
+      if (wedgedContext === context2) wedgedContext = null;
+      releaseOnce();
+    }
+  );
   pagePromise.catch((err) => logToDebugFile2("DEBUG", `[ThreadWorker] Background page creation rejection: ${err.message}`));
   let timeoutId;
   try {

package/docs/CHANGELOG.md

@@ -5,6 +5,32 @@ 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.7] - 2026-08-11
+
+Discovery and packaging metadata only — no engine changes.
+
+### Changed
+
+- **README rewritten for concision and effectiveness.** The pitch ("free, unlimited web search & deep research for coding agents — no API key, no quota") now leads the page, install moved up to directly under the badges, each claim is stated once, and detail that only matters after adoption moved to `docs/`. 88 → 78 lines.
+- **npm description and keywords rewritten.** The description is now benefit-led and survives catalog truncation; keywords gained `pi-coding-agent`, `web-research`, `deep-research`, `knowledge-store`, `duckduckgo`, and `skills`, and dropped `security` and `stack-exchange`.
+
+## [1.3.6] - 2026-08-10
+
+An independent fresh-eyes review of the entire 1.3.4→1.3.5 diff — the previous
+release's own fixes had only ever been reviewed by their author. It found seven
+further defects, several in the exact hard-release-timer and redaction-boundary
+patterns 1.3.5 introduced. Every fix below is covered by a regression test
+confirmed (via a local revert-and-rerun) to fail against the pre-fix code.
+
+### Fixed
+
+- **The page-creation and PoToken-mint hard-release timers (new in 1.3.5) could still let two calls race.** Both mutexes force-release after a 5-minute bound so a truly wedged call can't livelock the queue forever — but the bound has no way to tell "permanently hung" apart from "just very slow." A call that resolves a moment after the hard release fires was already let straight through to the next queued caller, who then ran its own `newPage()`/`doMint()` concurrently with the still-in-flight first one: the exact race each mutex exists to prevent (Playwright/Firefox deadlock on concurrent `newPage()`; corrupted `globalThis.window`/`document`/`navigator` from two overlapping bridge/unbridge pairs). Both now mark the wedged resource (the browser context; the whole PoToken minter, since `globalThis` is process-global) and reject further calls against it fast — no second `newPage()`/`doMint()` call — until the original stuck call actually settles.
+- **`redactSecrets()`'s own cost-bounding pre-slice (new in 1.3.5) could itself cut a secret in half.** The 4×`MAX_LOG_MESSAGE_LENGTH` pre-slice added to bound redaction's cost on huge inputs runs before any pattern sees the text — the same class of mid-token truncation the truncate-before-redact fix (1.3.4) closed at the *final* boundary, just reopened at this new earlier one. A secret straddling that cut, in a message dense enough with other redactable content that the cut point's post-redaction position falls inside the final visible window, leaked its un-redacted fragment. The slice boundary now extends forward past any run of token-shaped characters (bounded to 2KB extra) so it never lands mid-secret.
+- **`fs.chmodSync` right after the new `O_NOFOLLOW`-hardened `touchOwnerOnly()` (1.3.5) still followed symlinks.** The O_NOFOLLOW open correctly refused to write through a symlink planted at the log path, but the very next line re-stamped the file's mode with a plain, path-based `chmodSync` — which happily dereferences a symlink and silently chmods whatever it points at, undoing the hardening one line later. `touchOwnerOnly()` now stamps the mode itself via `fchmodSync` on the same already-open, already-verified file descriptor, and the separate path-based chmod calls are gone.
+- **The truncation-count in a redacted log message could go negative.** 1.3.5 switched the reported "truncated N chars" count to the pre-redaction raw length so it would reflect content discarded by the earlier cost-bounding slice — but several redaction patterns *expand* text (`key=1` → `key=[REDACTED]`), so a short, redaction-dense message could end up with a post-redaction length exceeding the raw length, making the subtraction negative and printing the literal `…[truncated -1 chars]`. Now takes the larger of the raw and post-redaction lengths.
+- **`reconcileSkillInstalls()`'s new (1.3.5) symlink-repoint copy fallback never swept its own staging leftovers.** The fallback stages a fresh copy into a dot-prefixed temp dir before an atomic rename into place; a process killed between the copy succeeding and the rename could leave that temp dir behind. The sibling copy-refresh branch already sweeps its own leftovers before every attempt — this branch didn't, and since a crash also frequently makes the manifest entry look deleted (pruning it before the branch runs again), repeated failures could accumulate orphaned staging directories with nothing ever revisiting them. Now sweeps unconditionally on every visit to a symlink entry, independent of whether that entry survives.
+- **The page-creation mutex's hard-release timer (1.3.5) was never unref'd**, unlike the identical PoToken-mint timer in the same release. A bare `setTimeout` keeps the event loop alive for up to 5 minutes; any shutdown path that doesn't route through the cluster worker's forced `process.exit(0)` would hang waiting on it instead of exiting promptly. Now unref'd like its sibling.
+
 ## [1.3.5] - 2026-08-10
 
 Two rounds of workflow-backed code review on the clean 1.3.4 tree (high-effort,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lincoln504/pi-research",
-  "version": "1.3.5",
-  "description": "A set of web research tools (search, scrape, and others) and research agent system that uses them safely and efficiently.",
+  "version": "1.3.7",
+  "description": "Free, unlimited web search and deep research for the Pi coding agent — no search API key, no quotas. Local knowledge store; also works from Claude Code, Codex, and OpenClaw.",
   "type": "module",
   "private": false,
   "main": "./src/index.ts",
@@ -52,16 +52,20 @@
     "pi",
     "pi-package",
     "pi-extension",
+    "pi-coding-agent",
     "openclaw",
     "agent-skill",
+    "skills",
     "research",
+    "web-research",
+    "deep-research",
     "agent",
     "web-search",
     "scraping",
+    "knowledge-store",
+    "duckduckgo",
     "stealth-browser",
-    "camoufox",
-    "security",
-    "stack-exchange"
+    "camoufox"
   ],
   "author": "Lincoln Deen",
   "contributors": [

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.5", "package": "@lincoln504/pi-research", "engine": "pi-research-sdk", "openclaw": { "requires": { "bins": ["node"] } } }
+metadata: { "author": "Lincoln Deen", "version": "1.3.7", "package": "@lincoln504/pi-research", "engine": "pi-research-sdk", "openclaw": { "requires": { "bins": ["node"] } } }
 allowed-tools: Bash(node:*)
 ---
 

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

@@ -8,6 +8,7 @@ let workerId: string = '';
 
 import { appendFileSync } from 'node:fs';
 import { redactSecrets } from '../../utils/log-utils.ts';
+import { safeUnref } from '../../utils/safe-unref.ts';
 import { MAX_HTML_SIZE, MAX_PDF_SIZE } from '../../web-research/scraper-types.ts';
 
 /**
@@ -21,6 +22,13 @@ let pageCreationLock = Promise.resolve();
  * bound the pathological case where newPage() never settles at all (see comment below). */
 const PAGE_CREATION_HARD_RELEASE_MS = 5 * 60 * 1000;
 
+/** Set when a hard-release fires while its newPage() call is still pending —
+ * identifies the context that call was creating a page on. A concurrent
+ * newPage() on that SAME context is exactly what pageCreationLock exists to
+ * prevent, so any call for this context is rejected fast (without ever
+ * calling newPage()) until the stuck call actually settles and clears this. */
+let wedgedContext: any = null;
+
 /** Exported for unit testing of the page-creation mutex's timeout behavior. */
 export async function createPageSafe(context: any): Promise<any> {
   let release!: () => void;
@@ -29,6 +37,13 @@ export async function createPageSafe(context: any): Promise<any> {
   pageCreationLock = currentLock.then(() => nextLock);
 
   await currentLock;
+  if (context === wedgedContext) {
+    // Release immediately so the queue keeps flowing for OTHER contexts (or
+    // this one, once the stuck call clears wedgedContext) instead of stalling
+    // every future caller behind the still-pending call.
+    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 = context.newPage();
   // Release the mutex once newPage() itself has actually settled — NOT when the
   // timeout race below settles. Releasing in an outer `finally` (the old shape)
@@ -43,7 +58,9 @@ export async function createPageSafe(context: any): Promise<any> {
   // A hard release timer bounds the case where newPage() never settles at all
   // (rather than just being slow) — without it, a single wedged newPage() call
   // would hold this lock forever and livelock every future createPageSafe() call
-  // on this worker thread.
+  // on this worker thread. It marks the context wedged rather than letting the
+  // next caller straight through: a merely-slow (not hung) newPage() would
+  // otherwise still be in flight when a new one starts on the same context.
   let hardReleased = false;
   const releaseOnce = (): void => {
     if (hardReleased) return;
@@ -53,9 +70,14 @@ export async function createPageSafe(context: any): Promise<any> {
   };
   const hardReleaseTimer = setTimeout(() => {
     logToDebugFile('WARN', '[ThreadWorker] page-creation mutex force-released — newPage() did not settle within the hard timeout');
+    wedgedContext = context;
     releaseOnce();
   }, PAGE_CREATION_HARD_RELEASE_MS);
-  pagePromise.then(releaseOnce, releaseOnce);
+  safeUnref(hardReleaseTimer);
+  pagePromise.then(
+    () => { if (wedgedContext === context) wedgedContext = null; releaseOnce(); },
+    () => { if (wedgedContext === context) wedgedContext = null; releaseOnce(); },
+  );
   pagePromise.catch((err: Error) => logToDebugFile('DEBUG', `[ThreadWorker] Background page creation rejection: ${err.message}`));
 
   let timeoutId: NodeJS.Timeout | undefined;

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

@@ -46,7 +46,14 @@ function formatArg(arg) {
 }
 function redactSecrets(message) {
   const rawLength = message.length;
-  let out = rawLength > REDACT_SCAN_LENGTH ? message.slice(0, REDACT_SCAN_LENGTH) : message;
+  let scanEnd = REDACT_SCAN_LENGTH;
+  if (rawLength > scanEnd) {
+    const extensionLimit = Math.min(rawLength, scanEnd + REDACT_SCAN_EXTENSION_MAX);
+    while (scanEnd < extensionLimit && TOKEN_CHAR_PATTERN.test(message.charAt(scanEnd))) {
+      scanEnd += 1;
+    }
+  }
+  let out = rawLength > scanEnd ? message.slice(0, scanEnd) : message;
   out = out.replace(ANSI_PATTERN, "");
   out = out.replace(URL_CREDENTIALS_PATTERN, "$1[REDACTED]@");
   out = out.replace(JWT_PATTERN, "[REDACTED]");
@@ -63,14 +70,14 @@ function redactSecrets(message) {
     if (lastKeptUnit >= 55296 && lastKeptUnit <= 56319) keep -= 1;
   }
   if (out.length > MAX_LOG_MESSAGE_LENGTH) {
-    out = `${out.slice(0, keep)}\u2026[truncated ${rawLength - keep} chars]`;
+    out = `${out.slice(0, keep)}\u2026[truncated ${Math.max(rawLength, out.length) - keep} chars]`;
   }
   return out;
 }
 function stripTerminalEscapes(message) {
   return message.replace(TERMINAL_ESCAPE_PATTERN, "").replace(CONTROL_CHARS_PATTERN, " ");
 }
-var logContextStorage, MAX_LOG_MESSAGE_LENGTH, ANSI_PATTERN, URL_CREDENTIALS_PATTERN, COOKIE_HEADER_PATTERN, SENSITIVE_KV_PATTERN, KNOWN_TOKEN_PATTERN, JWT_PATTERN, BASIC_AUTH_PATTERN, BEARER_AUTH_PATTERN, PROVIDER_TOKEN_PATTERN, LONG_HEX_SECRET_PATTERN, CONTROL_CHARS_PATTERN, REDACT_SCAN_LENGTH, TERMINAL_ESCAPE_PATTERN;
+var logContextStorage, MAX_LOG_MESSAGE_LENGTH, ANSI_PATTERN, URL_CREDENTIALS_PATTERN, COOKIE_HEADER_PATTERN, SENSITIVE_KV_PATTERN, KNOWN_TOKEN_PATTERN, JWT_PATTERN, BASIC_AUTH_PATTERN, BEARER_AUTH_PATTERN, PROVIDER_TOKEN_PATTERN, LONG_HEX_SECRET_PATTERN, CONTROL_CHARS_PATTERN, REDACT_SCAN_LENGTH, TOKEN_CHAR_PATTERN, REDACT_SCAN_EXTENSION_MAX, TERMINAL_ESCAPE_PATTERN;
 var init_log_utils = __esm({
   "src/utils/log-utils.ts"() {
     "use strict";
@@ -88,6 +95,8 @@ var init_log_utils = __esm({
     LONG_HEX_SECRET_PATTERN = /\b[0-9a-fA-F]{32,}\b/g;
     CONTROL_CHARS_PATTERN = /[\x00-\x1f\x7f]/g;
     REDACT_SCAN_LENGTH = MAX_LOG_MESSAGE_LENGTH * 4;
+    TOKEN_CHAR_PATTERN = /[A-Za-z0-9_\-./+=]/;
+    REDACT_SCAN_EXTENSION_MAX = 2048;
     TERMINAL_ESCAPE_PATTERN = new RegExp(
       "\\x1b\\[[0-?]*[ -/]*[@-~]?|\\x1b\\][^\\x07\\x1b]*(?:\\x07|\\x1b\\\\)?|\\x1b[PX^_][^\\x1b]*(?:\\x1b\\\\)?|\\x1b.?",
       "g"
@@ -360,9 +369,18 @@ var init_error_tracker = __esm({
 import * as fs2 from "node:fs";
 import * as path2 from "node:path";
 function touchOwnerOnly(filePath, mode) {
+  let fd;
   try {
-    fs2.closeSync(fs2.openSync(filePath, APPEND_CREATE_NOFOLLOW_FLAGS, mode));
+    fd = fs2.openSync(filePath, APPEND_CREATE_NOFOLLOW_FLAGS, mode);
+    fs2.fchmodSync(fd, mode);
   } catch {
+  } finally {
+    if (fd !== void 0) {
+      try {
+        fs2.closeSync(fd);
+      } catch {
+      }
+    }
   }
 }
 var APPEND_CREATE_NOFOLLOW_FLAGS, LogRotation;
@@ -388,10 +406,6 @@ var init_log_rotation = __esm({
           if (fs2.existsSync(logFile)) {
             fs2.unlinkSync(logFile);
             touchOwnerOnly(logFile, 384);
-            try {
-              fs2.chmodSync(logFile, 384);
-            } catch {
-            }
           }
           const files = fs2.readdirSync(logDir);
           const baseName = path2.basename(logFile);
@@ -428,10 +442,6 @@ var init_log_rotation = __esm({
             return;
           }
           touchOwnerOnly(logFile, 384);
-          try {
-            fs2.chmodSync(logFile, 384);
-          } catch {
-          }
           try {
             const files = fs2.readdirSync(logDir);
             const logFiles = files.filter((f) => f.startsWith(path2.basename(logFile)) && f !== path2.basename(logFile)).sort();
@@ -1920,11 +1930,21 @@ import { platform as platform2 } from "node:os";
 
 // src/infrastructure/browser/thread-worker-messaging.ts
 init_log_utils();
-init_scraper_types();
 import { appendFileSync as appendFileSync2 } from "node:fs";
+
+// src/utils/safe-unref.ts
+function safeUnref(timer) {
+  if (timer && typeof timer.unref === "function") {
+    timer.unref();
+  }
+}
+
+// src/infrastructure/browser/thread-worker-messaging.ts
+init_scraper_types();
 var workerId2 = "";
 var pageCreationLock = Promise.resolve();
 var PAGE_CREATION_HARD_RELEASE_MS = 5 * 60 * 1e3;
+var wedgedContext = null;
 async function createPageSafe(context2) {
   let release;
   const nextLock = new Promise((resolve) => {
@@ -1933,6 +1953,10 @@ async function createPageSafe(context2) {
   const currentLock = pageCreationLock;
   pageCreationLock = currentLock.then(() => nextLock);
   await currentLock;
+  if (context2 === 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();
   let hardReleased = false;
   const releaseOnce = () => {
@@ -1943,9 +1967,20 @@ 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;
     releaseOnce();
   }, PAGE_CREATION_HARD_RELEASE_MS);
-  pagePromise.then(releaseOnce, releaseOnce);
+  safeUnref(hardReleaseTimer);
+  pagePromise.then(
+    () => {
+      if (wedgedContext === context2) wedgedContext = null;
+      releaseOnce();
+    },
+    () => {
+      if (wedgedContext === context2) wedgedContext = null;
+      releaseOnce();
+    }
+  );
   pagePromise.catch((err) => logToDebugFile2("DEBUG", `[ThreadWorker] Background page creation rejection: ${err.message}`));
   let timeoutId;
   try {

package/src/skill-install/skill-installer.ts

@@ -631,6 +631,22 @@ export function reconcileSkillInstalls(opts: InstallOptions = {}): ReconcileResu
       continue;
     }
 
+    // Sweep any `.{base}.new-*` staging leftover from a previous crashed
+    // symlink-repoint attempt at this path, unconditionally — a process kill
+    // between copyDir succeeding and the final renameSync below can leave one
+    // behind, and this branch is not guaranteed to run again for the same
+    // entry (a crash also often leaves isSymlinkPresent() false, pruning the
+    // entry on the very next line before it would otherwise get a chance to).
+    const dir = path.dirname(e.path);
+    const base = path.basename(e.path);
+    try {
+      for (const name of fs.readdirSync(dir)) {
+        if (name.startsWith(`.${base}.new-`)) {
+          fs.rmSync(path.join(dir, name), { recursive: true, force: true });
+        }
+      }
+    } catch { /* hygiene only */ }
+
     // Link the user deleted by hand — nothing on disk; drop the stale entry.
     if (!isSymlinkPresent(e.path)) { result.pruned.push(e.path); continue; }
 
@@ -662,8 +678,6 @@ export function reconcileSkillInstalls(opts: InstallOptions = {}): ReconcileResu
           // partial, SKILL.md-less directory permanently orphaned on disk
           // (unrecognized by isOwnedCopy) when copyDir failed partway (disk
           // full, interrupted process).
-          const dir = path.dirname(e.path);
-          const base = path.basename(e.path);
           const suffix = crypto.randomBytes(4).toString('hex');
           const fresh = path.join(dir, `.${base}.new-${suffix}`);
           try {

package/src/utils/log-rotation.ts

@@ -21,12 +21,27 @@ const APPEND_CREATE_NOFOLLOW_FLAGS =
   (typeof fs.constants.O_NOFOLLOW === 'number' ? fs.constants.O_NOFOLLOW : 0);
 
 /** Best-effort (re)create `filePath` with `mode`, refusing to follow a symlink
- * planted at the path. Failures are swallowed by design — see call sites.
+ * planted at the path, and unconditionally stamp `mode` on it. Uses fchmodSync
+ * on the already-open (and O_NOFOLLOW-verified) descriptor rather than
+ * fs.chmodSync(filePath, ...) — chmodSync operates on the path and follows
+ * symlinks, which would silently re-open the exact hole O_NOFOLLOW closes if
+ * a symlink appears at this path between the open above and a path-based
+ * chmod. mode is only applied by open() when O_CREAT actually creates the
+ * file, so callers relying on the file always ending up at `mode` (even when
+ * a concurrent writer already recreated it) still need this explicit stamp.
+ * Failures are swallowed by design — see call sites.
  * Exported for unit testing of the symlink-refusal behavior. */
 export function touchOwnerOnly(filePath: string, mode: number): void {
+  let fd: number | undefined;
   try {
-    fs.closeSync(fs.openSync(filePath, APPEND_CREATE_NOFOLLOW_FLAGS, mode));
+    fd = fs.openSync(filePath, APPEND_CREATE_NOFOLLOW_FLAGS, mode);
+    fs.fchmodSync(fd, mode);
   } catch { /* best-effort — the next append recreates the file */ }
+  finally {
+    if (fd !== undefined) {
+      try { fs.closeSync(fd); } catch { /* best-effort */ }
+    }
+  }
 }
 
 export class LogRotation {
@@ -48,13 +63,11 @@ export class LogRotation {
         fs.unlinkSync(logFile);
         // Same rationale as the post-rotation recreate in rotateLogFile: the
         // unlink discarded the 0o600 file, and a umask-default recreate by the
-        // next append would drop the owner-only posture.
+        // next append would drop the owner-only posture. touchOwnerOnly stamps
+        // the mode unconditionally (via fchmod on its own fd), covering the
+        // case where a concurrent append already recreated the file at umask
+        // perms between the unlink and this call.
         touchOwnerOnly(logFile, 0o600);
-        // And, as there, re-stamp the mode: a concurrent append landing between
-        // the unlink and the open makes the creation-time 0o600 a no-op.
-        try {
-          fs.chmodSync(logFile, 0o600);
-        } catch { /* best-effort */ }
       }
 
       const files = fs.readdirSync(logDir);
@@ -109,18 +122,12 @@ export class LogRotation {
       // Rotation moved the 0o600 file aside; without an explicit recreate the next
       // append materializes it at the umask default (typically 0644) in a
       // world-traversable tmpdir, silently dropping the owner-only posture Logger
-      // establishes at construction. Mode applies only at creation, so this is
-      // harmless where a file already exists or mode semantics differ (win32).
-      touchOwnerOnly(logFile, 0o600);
-      // The mode above applies only if THIS open created the file. Several
-      // processes append to this consolidated log, so a concurrent async append
-      // can recreate it at umask perms between the rename and the open, turning
-      // the 0o600 into a no-op — stamp the mode unconditionally to close that
-      // window for good. ENOENT (nothing recreated it and the open failed) is
+      // establishes at construction. touchOwnerOnly stamps the mode
+      // unconditionally (via fchmod on its own fd) regardless of whether this
+      // open created the file or a concurrent append already recreated it
+      // between the rename and this call — ENOENT (open itself failed) is
       // tolerable: best-effort posture, same as the recreate itself.
-      try {
-        fs.chmodSync(logFile, 0o600);
-      } catch { /* best-effort */ }
+      touchOwnerOnly(logFile, 0o600);
 
 
       // Clean up old archives

package/src/utils/log-utils.ts

@@ -143,6 +143,15 @@ const CONTROL_CHARS_PATTERN = /[\x00-\x1f\x7f]/g;
 // O(input length) on multi-megabyte scraped payloads.
 const REDACT_SCAN_LENGTH = MAX_LOG_MESSAGE_LENGTH * 4;
 
+// Characters that can appear inside an unbroken secret token (hex, base64url,
+// JWT segments, API keys). Used to push the REDACT_SCAN_LENGTH cut point past
+// the end of whatever token it would otherwise land in the middle of.
+const TOKEN_CHAR_PATTERN = /[A-Za-z0-9_\-./+=]/;
+// Hard cap on how far the boundary can be pushed past REDACT_SCAN_LENGTH —
+// bounds the extra work to a fixed amount even against an adversarial run of
+// token-like characters.
+const REDACT_SCAN_EXTENSION_MAX = 2048;
+
 export function redactSecrets(message: string): string {
   // Redact BEFORE truncating. Every pattern below needs to see a secret in
   // full to match it (e.g. LONG_HEX_SECRET_PATTERN requires 32+ contiguous
@@ -151,7 +160,17 @@ export function redactSecrets(message: string): string {
   // browser auth secret) too short for any pattern to recognize, so it was
   // written out in the clear right before the "…[truncated N chars]" marker.
   const rawLength = message.length;
-  let out = rawLength > REDACT_SCAN_LENGTH ? message.slice(0, REDACT_SCAN_LENGTH) : message;
+  // The REDACT_SCAN_LENGTH cut below is itself a truncation, subject to the
+  // exact same mid-token risk — extend it forward past any run of token
+  // characters straddling the cut point so it never slices a secret in half.
+  let scanEnd = REDACT_SCAN_LENGTH;
+  if (rawLength > scanEnd) {
+    const extensionLimit = Math.min(rawLength, scanEnd + REDACT_SCAN_EXTENSION_MAX);
+    while (scanEnd < extensionLimit && TOKEN_CHAR_PATTERN.test(message.charAt(scanEnd))) {
+      scanEnd += 1;
+    }
+  }
+  let out = rawLength > scanEnd ? message.slice(0, scanEnd) : message;
   out = out.replace(ANSI_PATTERN, '');
   out = out.replace(URL_CREDENTIALS_PATTERN, '$1[REDACTED]@');
   // Redact whole-token formats BEFORE the key/value pass: the KV value class
@@ -183,7 +202,12 @@ export function redactSecrets(message: string): string {
     if (lastKeptUnit >= 0xd800 && lastKeptUnit <= 0xdbff) keep -= 1;
   }
   if (out.length > MAX_LOG_MESSAGE_LENGTH) {
-    out = `${out.slice(0, keep)}…[truncated ${rawLength - keep} chars]`;
+    // rawLength can be SMALLER than out.length when redaction net-expands text
+    // (e.g. "key=1" → "key=[REDACTED]"), which would make `rawLength - keep`
+    // negative. out.length is always > keep in this branch, so the max() is
+    // never negative; it still prefers the larger rawLength when the
+    // REDACT_SCAN_LENGTH cut discarded raw content redaction then shrank.
+    out = `${out.slice(0, keep)}…[truncated ${Math.max(rawLength, out.length) - keep} chars]`;
   }
   return out;
 }

package/src/youtube/potoken.ts

@@ -77,6 +77,13 @@ function describeError(error: unknown): string {
 // Module-level mutex: serialize all globalThis mutation across concurrent callers.
 let mintChain: Promise<unknown> = Promise.resolve();
 
+// Set when a hard-release fires while its doMint() is still bridging globals —
+// globalThis is a single process-global resource, so unlike a per-context lock
+// ANY new bridge while one is still installed is unsafe, not just one from the
+// same caller. Blocks new mints until the stuck call's own doMint() actually
+// settles (success or failure) and unbridges for real.
+let wedged = false;
+
 // How long the mutex waits for a straggling doMint() before force-releasing
 // the chain for the next caller. doMint() awaits non-fetch operations with no
 // abort signal (interpreter eval, BotGuard VM execution against a
@@ -98,19 +105,34 @@ export async function mintPoTokens(
   identifiers: string[],
   opts: MintOptions = {},
 ): Promise<Map<string, string>> {
+  if (wedged) {
+    throw new Error('PoToken minter is wedged by a prior mint that never settled; refusing to start a new mint until it resolves.');
+  }
   // Chain on the mutex so only one bridged section runs at a time.
   const run = mintChain.then(() => doMint(identifiers, opts), () => doMint(identifiers, opts));
   // Keep the chain alive regardless of this call's success/failure, but bound
   // how long the NEXT caller waits on it: if `run` never settles, force the
   // chain open after the hard timeout rather than wedging every future
-  // mintPoTokens() call behind it forever. The abandoned `run` may still
-  // mutate globalThis in the background after this — an accepted trade-off
-  // in the pathological case, same as the sibling browser-worker fix.
+  // mintPoTokens() call behind it forever. Marking `wedged` (rather than
+  // letting the next caller straight through to its own doMint()) prevents
+  // two calls from bridging globalThis at once — the abandoned `run` may
+  // still be mid-bridge in the background, and a second bridge/unbridge pair
+  // racing it would restore the WRONG saved descriptors, permanently
+  // corrupting globalThis.window/document/navigator for the process.
+  //
+  // Derived from `settled` (which never rejects) rather than attaching
+  // directly to `run` — `run.finally(...)` would return a new, unconsumed
+  // promise that adopts `run`'s rejection, becoming an unhandled rejection
+  // whenever doMint() throws.
   const settled = run.then(() => undefined, () => undefined);
+  // Once doMint() actually settles (success or failure), its own `finally`
+  // always runs unbridge() for real — safe for a new mint to bridge again.
+  settled.then(() => { wedged = false; });
   let hardTimer: NodeJS.Timeout;
   const hardRelease = new Promise<void>(resolve => {
     hardTimer = setTimeout(() => {
       logger.warn('[youtube] potoken mint mutex force-released — doMint() did not settle within the hard timeout');
+      wedged = true;
       resolve();
     }, MINT_HARD_RELEASE_MS);
     safeUnref(hardTimer);