@lincoln504/pi-research 1.7.9 → 1.7.11

package/README.md

@@ -49,7 +49,7 @@ npm install -g @lincoln504/pi-research
 pi-research skill install
 ```
 
-No extra setup is needed. The package ships ready-made bindings for every platform and declares no build step, so there is nothing to approve or compile. The stealth browser (1GB+ installed) is fetched by the `postinstall` script when npm runs install scripts, which it does by default up to npm 11.18 — that is the bundled npm on the Node 22.22.2 floor this package requires, so expect the fetch during install. Newer npm (11.19+) skips install scripts by default, and the browser is then fetched lazily on the first scrape instead. Either way the first scrape takes a few minutes until it is in place. Set `PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD=1` to defer the fetch deliberately. Only Windows with npm older than 11.19 can fail when the install tries to compile from source. Upgrading npm fixes it.
+No extra setup is needed. The package ships ready-made bindings for every platform and declares no build step, so there is nothing to approve or compile. The stealth browser (1GB+ installed) is fetched by the `postinstall` script whenever npm runs dependency install scripts — which is npm 10 through 11.19 (11.16–11.19 print a warning) — and that includes the npm bundled with the Node 22.22.2 floor this package requires (10.9.7) and the npm bundled with Node 24/25 (11.19.0), so expect the fetch during install. npm 12, the current npm, blocks dependency install scripts by default, and the browser is then fetched lazily on the first scrape instead. Either way the first scrape takes a few minutes until it is in place. Set `PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD=1` to defer the fetch deliberately.
 
 The `@earendil-works/pi-*` host packages are **peer dependencies**. pi supplies its own copies when it loads this as an extension, and npm ≥7 installs them automatically for a standalone (global or project) install. An install that skips peers does not get them: `npm install --legacy-peer-deps`, yarn classic, and `pi install` itself (it passes that flag on purpose) are all in that group. The standalone engine and the agent-skill launcher then stop with a message naming the missing package; add it with:
 
@@ -61,6 +61,10 @@ Standalone use needs that package on disk because the CLI and SDK import it dire
 
 In pi, the extension works out of the box on the session's model and pi's configuration. Standalone use ([agent skill](docs/AGENT-SKILL.md) or [SDK](docs/SDK.md)) needs a model configured. See [Configuration](docs/CONFIGURATION.md).
 
+### Update
+
+`pi update --extensions` moves every installed extension to its newest published version; `pi update npm:@lincoln504/pi-research` targets only this one. A versioned source (`npm:@lincoln504/pi-research@1.7.9`) is pinned and never updates — remove and reinstall it to move versions.
+
 ### Uninstall
 
 `pi remove npm:@lincoln504/pi-research` removes the extension. `npm uninstall -g @lincoln504/pi-research` removes the standalone engine. npm 7+ no longer runs `preuninstall`, so nothing else is removed on its own: skill links into other agents (Claude Code, Codex, …), the state directory (`~/.pi/research/state`), and the cache (`~/.cache/pi-research`, including any downloaded embedding models) stay in place. Remove the skill links first with `pi-research skill uninstall` (or `/research-config` → Remove from External Agents), then remove the rest with `pi-research cleanup`: The shared stealth-browser cache (`~/.cache/camoufox`) is preserved unless `PI_RESEARCH_PURGE_BROWSERS=1`. See [AGENT-SKILL.md](docs/AGENT-SKILL.md#installation-flow) for the full picture.

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

package/dist/cli.mjs

@@ -16617,6 +16617,7 @@ init_metrics();
 init_config();
 import { dirname as dirname10, join as join14 } from "node:path";
 import { existsSync as existsSync9 } from "node:fs";
+import { execFileSync } from "node:child_process";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { FixedClusterPool, WorkerChoiceStrategies } from "poolifier";
 
@@ -16625,7 +16626,7 @@ init_logger();
 import { spawn as spawn2 } from "node:child_process";
 import { createRequire as createRequire6 } from "node:module";
 import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync8, fstatSync, openSync as openSync4, closeSync as closeSync4, rmSync as rmSync2, readFileSync as readFileSync5 } from "node:fs";
+import { existsSync as existsSync8, fstatSync, openSync as openSync4, closeSync as closeSync4, rmSync as rmSync2, readFileSync as readFileSync5, createWriteStream } from "node:fs";
 import { join as join12, dirname as dirname9 } from "node:path";
 import { tmpdir as tmpdir2, platform as platform3, homedir as homedir5 } from "node:os";
 var FETCH_TIMEOUT_MS = 45 * 60 * 1e3;
@@ -16671,18 +16672,36 @@ function runFetch() {
     delete env["CAMOUFOX_INSTALL_DIR"];
     delete env["PLAYWRIGHT_BROWSERS_PATH"];
     logger.info(`[ensure-browser] Camoufox not found; fetching the browser (this runs once, ~1.3GB): ${process.execPath} ${cli} fetch`);
-    const child = spawn2(process.execPath, [cli, "fetch"], { stdio: "inherit", env });
+    const outLogPath = join12(tmpdir2(), `pi-research-camoufox-fetch-${process.pid}-${Date.now()}.log`);
+    const outStream = createWriteStream(outLogPath, { mode: 384 });
+    const child = spawn2(process.execPath, [cli, "fetch"], { stdio: ["ignore", "pipe", "inherit"], env });
+    if (child.stdout) {
+      child.stdout.pipe(outStream);
+    }
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
       reject(new Error(`camoufox fetch timed out after ${FETCH_TIMEOUT_MS}ms`));
     }, FETCH_TIMEOUT_MS);
-    child.on("error", (err) => {
+    const finish = (err, ok) => {
       clearTimeout(timer);
-      reject(err);
+      void outStream.close();
+      if (err) reject(err);
+      else resolve9(ok);
+    };
+    child.on("error", (err) => {
+      const message = err instanceof Error ? err.message : String(err);
+      finish(new Error(`${message} (fetch output logged at ${outLogPath})`), false);
     });
     child.on("exit", (code) => {
-      clearTimeout(timer);
-      resolve9(code === 0);
+      if (code === 0) {
+        try {
+          rmSync2(outLogPath, { force: true });
+        } catch {
+        }
+        finish(null, true);
+      } else {
+        finish(new Error(`camoufox fetch exited with code ${code} (fetch output logged at ${outLogPath})`), false);
+      }
     });
   });
 }
@@ -16904,6 +16923,30 @@ function setupMasterIpcErrorHandler() {
     const w = cluster.workers?.[id];
     if (w) guardClusterWorker(w);
   }
+  guardWorkerEmitReemit();
+}
+var workerEmitGuardPatched = false;
+var workerEmitOriginal = null;
+function guardWorkerEmitReemit() {
+  if (workerEmitGuardPatched || cluster.isWorker) return;
+  const Worker2 = cluster.Worker;
+  if (!Worker2 || !Worker2.prototype) return;
+  workerEmitGuardPatched = true;
+  const origEmit = Worker2.prototype.emit;
+  if (typeof origEmit !== "function") return;
+  workerEmitOriginal = origEmit;
+  Worker2.prototype.emit = function(event, ...args) {
+    if (event === "error" && typeof this.listenerCount === "function" && this.listenerCount("error") === 0) {
+      this.on("error", (err) => {
+        if (isBenignClusterIpcError(err)) {
+          logToDebugFile("DEBUG", `[Master] Last-resort guard swallowed listener-less IPC error: ${err?.code || err?.message}`);
+          return;
+        }
+        logToDebugFile("WARN", `[Master] Last-resort guard handled listener-less worker error: ${err?.stack || err?.message || err}`);
+      });
+    }
+    return origEmit.apply(this, [event, ...args]);
+  };
 }
 function guardClusterWorker(worker) {
   if (!worker || worker.__piIpcGuarded) return;
@@ -17002,6 +17045,34 @@ var WorkerPoolManager = class {
   // Handle for the schedulePoolReset() destroy timer, so shutdown() can cancel a pending
   // reset instead of letting it fire after teardown and clobber a freshly-rebuilt pool.
   _resetTimer = null;
+  // One in-flight destroy promise per pool instance. Both the auto-recovery timer
+  // and shutdown() can try to destroy the same pool (observed 2026-10-08 during a
+  // leader-handover storm: "Cannot destroy an already destroying pool"). A second
+  // destroy() racing the first wipes worker listeners (terminate →
+  // removeAllListeners) while the first is still sending kill messages — the fatal
+  // IPC re-emit window. Sharing one promise per pool makes that race impossible.
+  _destroyInFlight = /* @__PURE__ */ new Map();
+  /**
+   * Serialize pool destruction: the first caller wins; later callers await the
+   * same promise instead of racing a second destroy(). Rejections that merely
+   * report a concurrent/finished destroy are treated as success — the pool is
+   * gone either way, and re-throwing them would turn a benign race into a
+   * logged (and potentially escalated) failure.
+   */
+  destroyPoolOnce(deadPool) {
+    let p = this._destroyInFlight.get(deadPool);
+    if (!p) {
+      p = deadPool.destroy().catch((e) => {
+        if (e instanceof Error && /already (destroying|destroyed|starting)/i.test(e.message)) {
+          return;
+        }
+        throw new Error(`Worker pool destroy failed: ${e instanceof Error ? e.message : String(e)}`, { cause: e });
+      });
+      void p.then(() => this._destroyInFlight.delete(deadPool));
+      this._destroyInFlight.set(deadPool, p);
+    }
+    return p;
+  }
   /**
    * Ensure the pool is initialized with the current config.
    * Recreates the pool if the worker count has changed.
@@ -17036,7 +17107,7 @@ var WorkerPoolManager = class {
         if (this.pool && (this.currentWorkerCount !== maxWorkers || this.currentWorkerConcurrency !== workerConcurrency)) {
           logger.log(`[WorkerPoolManager] Pool shape changed (workers ${this.currentWorkerCount} -> ${maxWorkers}, concurrency ${this.currentWorkerConcurrency} -> ${workerConcurrency}), recreating pool...`);
           this.poolEpoch++;
-          await this.pool.destroy();
+          await this.destroyPoolOnce(this.pool);
           this.pool = null;
         }
         this.currentWorkerCount = maxWorkers;
@@ -17056,6 +17127,14 @@ var WorkerPoolManager = class {
             `Browser worker bundle is missing at ${workerPath}. It is produced by the build step; reinstall the extension (e.g. \`pi update --extensions\`) or run \`npm install\` in the extension directory so the prepare/build script regenerates it.`
           );
         }
+        try {
+          execFileSync(process.execPath, ["--check", workerPath], { stdio: "pipe" });
+        } catch (e) {
+          throw new Error(
+            `Browser worker bundle at ${workerPath} does not parse (${e instanceof Error ? e.message : String(e)}). Reinstall the extension (e.g. \`pi update --extensions\`) so the build step regenerates it.`,
+            { cause: e }
+          );
+        }
         const myEpoch = ++this.poolEpoch;
         this.pool = new FixedClusterPool(maxWorkers, workerPath, {
           env: browserEnv,
@@ -17217,7 +17296,7 @@ var WorkerPoolManager = class {
       try {
         if (this.isShuttingDown || this.generation !== myGen) return;
         this.poolEpoch++;
-        if (deadPool) await deadPool.destroy();
+        if (deadPool) await this.destroyPoolOnce(deadPool);
         logger.info("[WorkerPoolManager] Auto-recovery: old pool destroyed.");
       } catch (err) {
         logger.warn("[WorkerPoolManager] Auto-recovery: error destroying old pool:", err);
@@ -17258,7 +17337,7 @@ var WorkerPoolManager = class {
     if (this.pool) {
       try {
         this.poolEpoch++;
-        const destroyPromise = this.pool.destroy();
+        const destroyPromise = this.destroyPoolOnce(this.pool);
         destroyPromise.catch((err) => logger.debug(`[WorkerPoolManager] Background pool destroy rejection: ${err.message}`));
         await raceWithDeadline(destroyPromise, 5e3);
       } catch (e) {
@@ -18492,7 +18571,7 @@ init_logger();
 
 // src/healthcheck/index.ts
 init_config();
-import { execFileSync } from "node:child_process";
+import { execFileSync as execFileSync2 } from "node:child_process";
 init_service_registry();
 init_service_interfaces();
 
@@ -18584,7 +18663,7 @@ async function checkBrowserCapability() {
   if (isBrowserAvailable() || mockMode) {
     if (!mockMode && resolveHeadlessMode() === "virtual") {
       try {
-        execFileSync("which", ["Xvfb"], { stdio: "ignore" });
+        execFileSync2("which", ["Xvfb"], { stdio: "ignore" });
       } catch {
         return {
           healthy: false,

package/dist/thread-worker.mjs

@@ -1958,12 +1958,22 @@ function setupIpcErrorHandler() {
     return;
   }
   cluster.worker.on("error", (err) => {
-    if (err && err.code === "ERR_IPC_CHANNEL_CLOSED") {
+    if (isBenignClusterIpcError(err)) {
       return;
     }
     throw err;
   });
 }
+var BENIGN_IPC_CODES = /* @__PURE__ */ new Set(["EPIPE", "ERR_IPC_CHANNEL_CLOSED", "ECONNRESET"]);
+function isBenignClusterIpcError(err) {
+  if (!err) return false;
+  if (typeof err.code === "string" && BENIGN_IPC_CODES.has(err.code)) return true;
+  const msg = String(err.message || err);
+  return /\b(EPIPE|ECONNRESET)\b/.test(msg) || /channel closed/i.test(msg);
+}
+function markWorkerBootstrap(id) {
+  logToDebugFile("WARN", `[Worker-${id}] Bootstrap complete (pid ${process2.pid})`);
+}
 function setupUncaughtExceptionHandler() {
   process2.on("uncaughtException", (err) => {
     if (err && err.message && err.message.includes("reading 'url'") && err.stack && err.stack.includes("coreBundle.js")) {
@@ -3232,6 +3242,7 @@ setBrowserCleanup(cleanupBrowser2);
 if (process3.env["GITHUB_ACTIONS"] !== "true") {
   setupOrphanProtection();
 }
+markWorkerBootstrap(workerId4);
 var FULL_MOCK_MODE = process3.env["PI_RESEARCH_MOCK_SEARCH"] === "true" && process3.env["PI_RESEARCH_MOCK_SCRAPE"] === "true";
 async function runTask(data) {
   if (!data) {

package/docs/AGENT-SKILL.md

@@ -21,10 +21,12 @@ npm install -g @lincoln504/pi-research   # the engine (puts `pi-research` on PAT
 pi-research skill install                # link the skill into every detected agent
 ```
 
-On npm ≥11.19 (and npm 12) dependency install scripts are skipped by default — and
+npm 12, the current npm, blocks dependency install scripts by default — and
 none are needed: the only native piece on the launch path is `impit`, which ships
 prebuilt binaries, and the stealth browser self-provisions on its first use (the first
-scrape takes a few minutes). No approval is required (see the [README](../README.md#install)).
+scrape takes a few minutes). On npm 10 through 11.19 the `postinstall` fetch runs
+during install instead; that is the npm bundled with Node 24/25 (11.19.0) and with
+the Node 22.22.2 floor (10.9.7). No approval is required (see the [README](../README.md#install)).
 
 The global install also brings the `@earendil-works/pi-*` host packages in as peer
 dependencies (npm ≥7 resolves them). If your install skips peers

package/docs/ARCHITECTURE.md

@@ -387,7 +387,7 @@ warns on every startup when a host-provided package (`typebox`, `@sinclair/typeb
 loader and create a second live module instance (`resource-loader.js`,
 `collectExtensionPackageWarnings`; pi `docs/packages.md`). Under pi the host's own copy is used,
 so the two agree on `Value.Check`/`Convert` by construction. `@earendil-works/pi-ai` and
-`@earendil-works/pi-coding-agent` 1.0.0 through 1.0.3 all pin `1.3.27` (re-checked 2026-10-05 in
+`@earendil-works/pi-coding-agent` 1.0.0 through 1.1.0 all pin `1.3.27` (re-checked 2026-10-08 in
 the installed packages' `package.json`), which is why the devDependency, and so every test run and
 the type-check, stays on exactly that version: bump it in lockstep with the pi host, not
 independently. A standalone CLI/SDK install resolves the peer automatically on npm >= 7; the

package/docs/CHANGELOG.md

@@ -5,6 +5,38 @@ 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.7.11] - 2026-10-10
+
+### Fixed
+
+- **The browser worker pool crash class observed on 2026-10-08 is closed at four layers.** On a pi host, an `ERR_IPC_CHANNEL_CLOSED` raised by a write to a worker's closed IPC channel reached a `cluster.Worker` with no `error` listener and threw inside `EventEmitter` → `uncaughtException` → the pi process exited mid-research. The full chain was reconstructed from the host's crash log: a storm of worker exits with code 1 (16+ in under a second, **zero worker-side log lines**) fed the 3-consecutive-error threshold, the auto-recovery 1 s timer fired into a leader-handover storm that tore down and rebuilt the pool three times in ten seconds with an explicit `Cannot destroy an already destroying pool` double-destroy, and the fatal `destroy()` → `sendKillMessageToWorker` → `Worker.send` hit the closed channel at 22:00:30.12. Fixes, in `src/infrastructure/browser/thread-worker-lifecycle.ts` and `worker-pool-manager.ts`:
+  - **The worker-side IPC handler now swallows the same benign set as the master side** (`EPIPE`, `ECONNRESET`, `ERR_IPC_CHANNEL_CLOSED`, `channel closed`, via the shared `isBenignClusterIpcError`). The old narrow check (`ERR_IPC_CHANNEL_CLOSED` only) re-threw `EPIPE`/`ECONNRESET` during teardown churn as an uncaught worker-side exception — a code-1 exit that fed the consecutive-error counter driving the storm. Non-benign errors still re-throw (the worker's uncaught handler logs and exits, by design).
+  - **Pool destruction is serialized.** The auto-recovery timer, `shutdown()`, and the shape-change re-init all destroy through one in-flight promise per pool (`destroyPoolOnce`), so a second `destroy()` can no longer race the first — the double-destroy that wiped worker listeners (`terminate` → `removeAllListeners`) while the first destroy was still sending kill messages, which opened the fatal re-emit window. Rejections that merely report a concurrent/finished destroy are swallowed as success.
+  - **A `cluster.Worker` prototype last-resort guard.** `setupMasterIpcErrorHandler` also patches `Worker.prototype.emit` so no Worker can ever emit `error` without a listener, whatever wipe path, timing, or pool generation is involved. The per-worker re-attach patch already survives poolifier's `removeAllListeners`; this makes the crash class unreachable rather than merely guarded. The listener it attaches can only be the first on a listener-less Worker (the exact state where `EventEmitter` throws), so it never shadows poolifier's own error accounting.
+  - **A corrupted worker bundle now fails loudly at pool init.** A bundle that exists but is truncated or overwritten fails with a bare `SyntaxError` in every forked worker — code-1 exits with no worker-side log, the same silent-churn signature the missing-bundle guard could not catch. `ensurePool` now runs `node --check` on `thread-worker.mjs` (~40 ms) and throws an actionable reinstall error on a parse failure. (Observed 2026-10-09 on a consumer git checkout that had also lost `src/cleanup/research-cleanup.ts`, breaking the research tool with `Cannot find module` — a partial-install corruption class, now loud for the bundle and diagnosable for the rest.)
+  - **Each worker writes a startup marker** (`[Worker-<id>] Bootstrap complete (pid …)`, WARN, always recorded). A non-zero exit with no marker means the worker died during top-level module evaluation, before its handlers were installed — the exact signature of the 2026-10-08 silent churn storm, now visible in post-mortems.
+- Tests: new `test/unit/infrastructure/browser/thread-worker-lifecycle.test.ts` (widened swallow, re-attach patch, prototype last-resort guard plus the no-patch control that throws, bootstrap marker) and destroy-serialization cases in `worker-pool-manager.test.ts` (auto-recovery timer vs concurrent `shutdown()` sharing one `destroy()` call; "already destroying" rejection swallowed; parse-guard failure). Full unit suite 3318, integration 103+57, lint, type-check (TypeScript 6 and 7), depcruise and `npm audit` (0) pass.
+
+## [1.7.10] - 2026-10-08
+
+### Changed
+
+- **The pi host dev dependencies move 1.0.4 → 1.1.0** (`@earendil-works/pi-ai`, `pi-coding-agent`, `pi-tui`; the peer range stays `>=0.99.0 <2`). The 1.0.4 → 1.1.0 diff is additive for this package (declaration diff of the installed packages, 2026-10-08): `pi-coding-agent` adds `durationMs` on the tool render context and `tool_execution_end`, `aborted` on `agent_settled` events, and the `+name`/`-name` tool modifiers; `pi-ai` adds the Decisions-API classifier surface and an optional `AuthProvider.agentName`; `pi-tui` adds the OSC 7501 program-status helpers and `Text.setPaddingX`. `docs/extensions.md` is unchanged and nothing was removed or re-signed, so the 0.99.0 floor is unchanged too. `PI_TESTED_MAX_VERSION` moves to 1.1.0 (`src/core/pi-version.ts`), so a pi 1.1.x host runs without the "newer than the tested ceiling" notice; `npm audit` stays at 0 and type-check (TypeScript 6 and 7), lint and the full unit suite (3305) pass against 1.1.0.
+- **The npm install-script boundary is corrected across every user-facing surface and CI comment.** npm 10 through 11.19 run dependency install scripts (11.16–11.19 print a warning); npm 12, the current npm, blocks them by default — the npm bundled with Node 24/25 is 11.19.0, which still runs them, so a stock Node install fetches the browser during install. The old "11.19+ skips install scripts" wording in `README.md`, `docs/AGENT-SKILL.md`, `docs/SDK.md`, the ES/JA/ZH docs and the `ci.yml` comments was wrong — verified against the npm 11.19.0 source (arborist skips a script only when it is explicitly denied; `strict-allow-scripts` is opt-in) and consistent with this repo's own earlier measurement that 11.16–11.19 "warn but still run". The stale "compile from source on Windows" / `better-sqlite3` 13 references that survived the 1.7.9 launcher swap are gone with it.
+- **Update guidance is documented** (README and `docs/PI-EXTENSION.md`): `pi update --extensions` moves every installed extension to its newest published version, `pi update npm:@lincoln504/pi-research` targets only this one, and a versioned source (`npm:@lincoln504/pi-research@1.7.9`) is pinned and never updates — remove and reinstall it to move versions.
+- **`setup.cjs` announces the ~1.3 GB fetch before it starts**, so the postinstall fetch that runs inside `pi install` / `pi update --extensions` on script-running npm (10–11.19) no longer looks like a hang.
+- In-range dev refresh: `vite` 8.3.2 → 8.3.4.
+
+### Fixed
+
+- **The in-host lazy browser fetch no longer writes raw to the terminal.** `ensureBrowserInstalled()` spawned its `camoufox fetch` child with `stdio: 'inherit'`; a child with an inherited fd 1 bypasses pi's JS-level stdout redirection (pi's `takeOverStdout` rewrites `process.stdout.write` for the TUI) and interleaves the download's progress with the host's output stream — in print/JSON/RPC modes stdout is the protocol itself, so raw child output could corrupt it. The child's stdout is now captured in a temp file (its path is logged on failure, the file is removed on success) and stderr stays inherited, so real errors remain visible. Pinned by a test asserting `stdio: ['ignore', 'pipe', 'inherit']` on the fetch child.
+
+### Also shipped since 1.7.9
+
+- **`source-map-js` 1.2.2** in the production tree clears GHSA-68fv-2mgg-jv7q from the audit gate (`npm audit`: 0).
+- **The unit suite stops leaking throwaway tmpdirs.**
+- **`docs/AUDIT-GATE.md` records** that a shipped host `npm-shrinkwrap.json` does not propagate a consumer-side `sharp` override (consumer advisory note).
+
 ## [1.7.9] - 2026-10-05
 
 ### Changed

package/docs/PI-EXTENSION.md

@@ -83,6 +83,10 @@ coding agents detected on this machine so they can run web research through the
 CLI, and remove it again — with exact, manifest-tracked cleanup. See
 [AGENT-SKILL.md](AGENT-SKILL.md) for the full installation flow.
 
+### Update
+
+`pi update --extensions` moves every installed extension to its newest published version; `pi update npm:@lincoln504/pi-research` targets only this one. A versioned source (`npm:@lincoln504/pi-research@1.7.9`) is pinned and never updates — remove and reinstall it to move versions.
+
 ### Lifecycle
 
 - `activate` — registers commands, tools, the TUI controller, and initializes services.

package/docs/SDK.md

@@ -21,9 +21,11 @@ classic — the SDK cannot import them, so add the one it loads directly:
 npm install @earendil-works/pi-coding-agent
 ```
 
-On npm ≥11.19 (and npm 12), dependency install scripts are skipped by default. Nothing
+npm 12, the current npm, blocks dependency install scripts by default. Nothing
 here needs them: the only native piece on the launch path is `impit`, which ships
-prebuilt binaries, and the stealth browser self-provisions on its first use. (The
+prebuilt binaries, and the stealth browser self-provisions on its first use. On npm 10
+through 11.19 the `postinstall` fetch runs during install instead; that is the npm
+bundled with Node 24/25 (11.19.0) and with the Node 22.22.2 floor (10.9.7). (The
 `npm approve-scripts better-sqlite3` + `npm rebuild` pair documented by earlier
 releases repaired the old `camoufox-js` launcher, whose `better-sqlite3` binding came
 from an install script — the 2026-10-05 move to `@camoufox/camoufox` removed that

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lincoln504/pi-research",
-  "version": "1.7.9",
+  "version": "1.7.11",
   "description": "Web research for your agents with smart and safe tooling + knowledge store",
   "type": "module",
   "private": false,

package/scripts/setup.cjs

@@ -135,6 +135,7 @@ if (process.env.PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD === '1') {
       return true;
     };
 
+    console.log('pi-research: downloading the ~1.3 GB Camoufox browser — this can take several minutes on a slow link…');
     const pkgRoot = layout.findPackageRoot(projectRoot);
     const result = layout.provisionBrowser(cachePath, runFetch, (m) => console.log(m), pkgRoot ? layout.loadPin(pkgRoot) : null);
     if (result.status === 'failed') {

package/src/core/pi-version.ts

@@ -122,8 +122,16 @@ export const PI_MIN_VERSION: SemverParts = { major: 0, minor: 99, patch: 0 };
  * modes), the `builtin:<name>` naming for built-in extensions and tools, and
  * `--no-extensions` now also disabling the built-in extensions. None of them
  * change what this package does.
+ *
+ * 1.1.0 (2026-10-07) is additive for this package. Diffed against 1.0.4 on 2026-10-08:
+ * `@earendil-works/pi-coding-agent` adds `durationMs` on the tool render context and
+ * `tool_execution_end`, `aborted` on `agent_settled` events, and the `+name`/`-name`
+ * tool modifiers; `@earendil-works/pi-ai` adds the Decisions-API classifier surface
+ * and an optional `AuthProvider.agentName`; `@earendil-works/pi-tui` adds the OSC 7501
+ * program-status helpers and `Text.setPaddingX`. `docs/extensions.md` is unchanged,
+ * and nothing was removed or re-signed, so the 0.99.0 floor is unchanged too.
  */
-export const PI_TESTED_MAX_VERSION: SemverParts = { major: 1, minor: 0, patch: 0 };
+export const PI_TESTED_MAX_VERSION: SemverParts = { major: 1, minor: 1, patch: 0 };
 
 export type PiCompatibilityLevel = 'ok' | 'unparseable' | 'too-old' | 'untested';
 

package/src/infrastructure/browser/ensure-browser.ts

@@ -21,7 +21,7 @@
 import { spawn } from 'node:child_process';
 import { createRequire } from 'node:module';
 import { createHash } from 'node:crypto';
-import { existsSync, fstatSync, openSync, closeSync, rmSync, readFileSync } from 'node:fs';
+import { existsSync, fstatSync, openSync, closeSync, rmSync, readFileSync, createWriteStream } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { tmpdir, platform, homedir } from 'node:os';
 import { logger } from '../../logger.ts';
@@ -89,6 +89,14 @@ const delay = (ms: number): Promise<void> => new Promise((r) => setTimeout(r, ms
  * spawn error / timeout. Runs the CLI's JS entry with process.execPath and an argv array:
  * no shell, so neither a spaced Windows path nor a metacharacter in an install directory
  * can be reinterpreted.
+ *
+ * The child's stdout is captured in a temp file, not inherited: a child with an
+ * inherited fd 1 writes raw to the terminal, which inside a pi session bypasses the
+ * host's JS-level stdout redirection (pi redirects `process.stdout.write` for its TUI)
+ * and interleaves the download's progress with the host's output stream — in
+ * print/JSON/RPC modes stdout is the protocol itself, so raw child output corrupts it.
+ * The launcher's progress is noise either way; its errors go to stderr, which stays
+ * inherited and is therefore still visible.
  */
 function runFetch(): Promise<boolean> {
   return new Promise<boolean>((resolve, reject) => {
@@ -106,19 +114,35 @@ function runFetch(): Promise<boolean> {
     delete env['PLAYWRIGHT_BROWSERS_PATH'];
     logger.info(`[ensure-browser] Camoufox not found; fetching the browser (this runs once, ~1.3GB): ${process.execPath} ${cli} fetch`);
 
-    const child = spawn(process.execPath, [cli, 'fetch'], { stdio: 'inherit', env });
+    const outLogPath = join(tmpdir(), `pi-research-camoufox-fetch-${process.pid}-${Date.now()}.log`);
+    const outStream = createWriteStream(outLogPath, { mode: 0o600 });
+    const child = spawn(process.execPath, [cli, 'fetch'], { stdio: ['ignore', 'pipe', 'inherit'], env });
+    if (child.stdout) {
+      child.stdout.pipe(outStream);
+    }
     const timer = setTimeout(() => {
       child.kill('SIGKILL');
       reject(new Error(`camoufox fetch timed out after ${FETCH_TIMEOUT_MS}ms`));
     }, FETCH_TIMEOUT_MS);
 
-    child.on('error', (err) => {
+    const finish = (err: Error | null, ok: boolean): void => {
       clearTimeout(timer);
-      reject(err);
+      void outStream.close();
+      if (err) reject(err);
+      else resolve(ok);
+    };
+
+    child.on('error', (err) => {
+      const message = err instanceof Error ? err.message : String(err);
+      finish(new Error(`${message} (fetch output logged at ${outLogPath})`), false);
     });
     child.on('exit', (code) => {
-      clearTimeout(timer);
-      resolve(code === 0);
+      if (code === 0) {
+        try { rmSync(outLogPath, { force: true }); } catch { /* best-effort */ }
+        finish(null, true);
+      } else {
+        finish(new Error(`camoufox fetch exited with code ${code} (fetch output logged at ${outLogPath})`), false);
+      }
     });
   });
 }

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

@@ -20,14 +20,23 @@ export function setWorkerId(id: string): void {
 }
 
 /**
- * Handle ERR_IPC_CHANNEL_CLOSED when poolifier tries to send messages during shutdown
+ * Handle benign closed-channel IPC errors when poolifier tears down a worker's
+ * channel. Symmetric with the master-side classification (isBenignClusterIpcError):
+ * the write failed because the pipe is already gone, which is not a health signal.
+ *
+ * The old narrow check (ERR_IPC_CHANNEL_CLOSED only) re-threw EPIPE/ECONNRESET as an
+ * uncaught worker-side exception → exit code 1. A worker that dies that way during
+ * teardown churn feeds the master's consecutive-error counter and re-spawns — the
+ * self-sustaining worker storm behind the 2026-10-08 crash chain. Swallowing the
+ * same benign set here stops that feedback; genuinely non-benign errors still
+ * re-throw (the worker's uncaught handler logs and exits, as designed).
  */
 export function setupIpcErrorHandler(): void {
   if (!cluster.isWorker || !cluster.worker) {
     return;
   }
   cluster.worker.on('error', (err: any) => {
-    if (err && err.code === 'ERR_IPC_CHANNEL_CLOSED') {
+    if (isBenignClusterIpcError(err)) {
       return;
     }
     throw err;
@@ -92,6 +101,10 @@ export function setupMasterIpcErrorHandler(): void {
     const w = (cluster.workers as any)?.[id];
     if (w) guardClusterWorker(w);
   }
+
+  // Prototype-level backstop: no cluster.Worker can ever emit 'error' without
+  // a listener, whatever path wiped its per-instance listeners.
+  guardWorkerEmitReemit();
 }
 
 /** Reset for tests — re-arms the one-time install guard. */
@@ -99,6 +112,55 @@ export function __resetMasterIpcGuardForTests(): void {
   masterIpcGuardInstalled = false;
 }
 
+let workerEmitGuardPatched = false;
+let workerEmitOriginal: unknown = null;
+
+/**
+ * Last-resort defense against the crash class observed on 2026-10-08: an 'error'
+ * event emitted on a cluster.Worker with NO listeners throws inside EventEmitter
+ * (uncaughtException → the pi host exits). The per-worker guard above is re-armed
+ * after poolifier's removeAllListeners() by the re-attach patch in
+ * guardClusterWorker, but this patches the Worker PROTOTYPE so that no Worker can
+ * ever emit 'error' without a listener — whatever wipe path, re-emit timing, or
+ * pool generation is involved.
+ *
+ * The listener attached here can only be the first listener on a listener-less
+ * Worker (that is the exact state where EventEmitter would throw), so it can never
+ * shadow poolifier's own error accounting, which is always attached at fork time.
+ * Idempotent; master process only. Installed once by setupMasterIpcErrorHandler().
+ */
+export function guardWorkerEmitReemit(): void {
+  if (workerEmitGuardPatched || cluster.isWorker) return;
+  const Worker = (cluster as unknown as { Worker?: { prototype: { emit?: unknown } } }).Worker;
+  if (!Worker || !Worker.prototype) return;
+  workerEmitGuardPatched = true;
+  const origEmit = Worker.prototype.emit;
+  if (typeof origEmit !== 'function') return;
+  workerEmitOriginal = origEmit;
+  Worker.prototype.emit = function (this: any, event: string | symbol, ...args: unknown[]) {
+    if (event === 'error' && typeof this.listenerCount === 'function' && this.listenerCount('error') === 0) {
+      this.on('error', (err: any) => {
+        if (isBenignClusterIpcError(err)) {
+          logToDebugFile('DEBUG', `[Master] Last-resort guard swallowed listener-less IPC error: ${err?.code || err?.message}`);
+          return;
+        }
+        logToDebugFile('WARN', `[Master] Last-resort guard handled listener-less worker error: ${err?.stack || err?.message || err}`);
+      });
+    }
+    return origEmit.apply(this, [event, ...args]);
+  };
+}
+
+/** Reset for tests — restores the original prototype emit and re-arms the flag. */
+export function __resetWorkerEmitGuardForTests(): void {
+  if (workerEmitGuardPatched && workerEmitOriginal) {
+    const Worker = (cluster as unknown as { Worker?: { prototype: { emit?: unknown } } }).Worker;
+    if (Worker && Worker.prototype) Worker.prototype.emit = workerEmitOriginal;
+    workerEmitOriginal = null;
+  }
+  workerEmitGuardPatched = false;
+}
+
 function guardClusterWorker(worker: any): void {
   if (!worker || worker.__piIpcGuarded) return;
   worker.__piIpcGuarded = true;
@@ -137,6 +199,18 @@ function guardClusterWorker(worker: any): void {
   }
 }
 
+/**
+ * Worker bootstrap marker. WARN (always recorded; INFO/DEBUG are gated behind
+ * PI_RESEARCH_DEBUG). If a worker later exits non-zero WITHOUT this line in the
+ * log, it died during top-level module evaluation — before its error handlers
+ * were installed — and left no diagnostic behind. The 2026-10-08 churn storm
+ * had exactly that signature (a burst of code-1 exits with zero worker-side log
+ * lines); this marker makes that class visible in post-mortems.
+ */
+export function markWorkerBootstrap(id: string): void {
+  logToDebugFile('WARN', `[Worker-${id}] Bootstrap complete (pid ${process.pid})`);
+}
+
 /**
  * Handle Uncaught Exceptions in Worker
  */

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

@@ -1958,12 +1958,22 @@ function setupIpcErrorHandler() {
     return;
   }
   cluster.worker.on("error", (err) => {
-    if (err && err.code === "ERR_IPC_CHANNEL_CLOSED") {
+    if (isBenignClusterIpcError(err)) {
       return;
     }
     throw err;
   });
 }
+var BENIGN_IPC_CODES = /* @__PURE__ */ new Set(["EPIPE", "ERR_IPC_CHANNEL_CLOSED", "ECONNRESET"]);
+function isBenignClusterIpcError(err) {
+  if (!err) return false;
+  if (typeof err.code === "string" && BENIGN_IPC_CODES.has(err.code)) return true;
+  const msg = String(err.message || err);
+  return /\b(EPIPE|ECONNRESET)\b/.test(msg) || /channel closed/i.test(msg);
+}
+function markWorkerBootstrap(id) {
+  logToDebugFile("WARN", `[Worker-${id}] Bootstrap complete (pid ${process2.pid})`);
+}
 function setupUncaughtExceptionHandler() {
   process2.on("uncaughtException", (err) => {
     if (err && err.message && err.message.includes("reading 'url'") && err.stack && err.stack.includes("coreBundle.js")) {
@@ -3232,6 +3242,7 @@ setBrowserCleanup(cleanupBrowser2);
 if (process3.env["GITHUB_ACTIONS"] !== "true") {
   setupOrphanProtection();
 }
+markWorkerBootstrap(workerId4);
 var FULL_MOCK_MODE = process3.env["PI_RESEARCH_MOCK_SEARCH"] === "true" && process3.env["PI_RESEARCH_MOCK_SCRAPE"] === "true";
 async function runTask(data) {
   if (!data) {

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

@@ -19,6 +19,7 @@ import {
   setupOrphanProtection,
   createKillHandler,
   setBrowserCleanup,
+  markWorkerBootstrap,
 } from './thread-worker-lifecycle.ts';
 import {
   setWorkerId,
@@ -60,6 +61,11 @@ if (process.env['GITHUB_ACTIONS'] !== 'true') {
   setupOrphanProtection();
 }
 
+// Startup marker (always recorded). A non-zero exit with no marker in the log
+// means the worker died during top-level module evaluation, before the handlers
+// above were installed — the silent churn signature of the 2026-10-08 crash chain.
+markWorkerBootstrap(workerId);
+
 // When both search and scrape are mocked, skip Firefox entirely in task handlers
 // and in the eager warm-up below. Firefox startup in cluster workers takes 60-90s
 // on constrained CI runners; mocked tasks don't need a real browser at all.

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

@@ -7,6 +7,7 @@
 
 import { dirname, join } from 'node:path';
 import { existsSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { FixedClusterPool, WorkerChoiceStrategies } from 'poolifier';
 import { logger } from '../../logger.ts';
@@ -110,6 +111,35 @@ export class WorkerPoolManager implements IService {
     // Handle for the schedulePoolReset() destroy timer, so shutdown() can cancel a pending
     // reset instead of letting it fire after teardown and clobber a freshly-rebuilt pool.
     private _resetTimer: ReturnType<typeof setTimeout> | null = null;
+    // One in-flight destroy promise per pool instance. Both the auto-recovery timer
+    // and shutdown() can try to destroy the same pool (observed 2026-10-08 during a
+    // leader-handover storm: "Cannot destroy an already destroying pool"). A second
+    // destroy() racing the first wipes worker listeners (terminate →
+    // removeAllListeners) while the first is still sending kill messages — the fatal
+    // IPC re-emit window. Sharing one promise per pool makes that race impossible.
+    private _destroyInFlight: Map<object, Promise<void>> = new Map();
+
+    /**
+     * Serialize pool destruction: the first caller wins; later callers await the
+     * same promise instead of racing a second destroy(). Rejections that merely
+     * report a concurrent/finished destroy are treated as success — the pool is
+     * gone either way, and re-throwing them would turn a benign race into a
+     * logged (and potentially escalated) failure.
+     */
+    private destroyPoolOnce(deadPool: object): Promise<void> {
+        let p = this._destroyInFlight.get(deadPool);
+        if (!p) {
+            p = (deadPool as { destroy: () => Promise<void> }).destroy().catch((e: unknown) => {
+                if (e instanceof Error && /already (destroying|destroyed|starting)/i.test(e.message)) {
+                    return;
+                }
+                throw new Error(`Worker pool destroy failed: ${e instanceof Error ? e.message : String(e)}`, { cause: e });
+            });
+            void p.then(() => this._destroyInFlight.delete(deadPool));
+            this._destroyInFlight.set(deadPool, p);
+        }
+        return p;
+    }
 
     constructor(
         private readonly onPoolError?: (error: Error, consecutiveErrors: number) => void
@@ -169,7 +199,7 @@ export class WorkerPoolManager implements IService {
                 if (this.pool && (this.currentWorkerCount !== maxWorkers || this.currentWorkerConcurrency !== workerConcurrency)) {
                     logger.log(`[WorkerPoolManager] Pool shape changed (workers ${this.currentWorkerCount} -> ${maxWorkers}, concurrency ${this.currentWorkerConcurrency} -> ${workerConcurrency}), recreating pool...`);
                     this.poolEpoch++; // intentional destroy: silence the dying pool's exit events
-                    await this.pool.destroy();
+                    await this.destroyPoolOnce(this.pool);
                     this.pool = null;
                 }
 
@@ -237,6 +267,23 @@ export class WorkerPoolManager implements IService {
                     );
                 }
 
+                // A bundle that EXISTS but is corrupted (truncated or partially overwritten
+                // file — observed 2026-10-08: a git checkout missing files) fails with a bare
+                // SyntaxError in every forked worker — code-1 exits with no worker-side log,
+                // the same silent churn signature as a missing bundle. Parse (not execute)
+                // the source here so a corrupted bundle fails loudly at pool init instead of
+                // masking as worker churn. `node --check` parses .mjs as ESM (~40 ms).
+                try {
+                    execFileSync(process.execPath, ['--check', workerPath], { stdio: 'pipe' });
+                } catch (e) {
+                    throw new Error(
+                        `Browser worker bundle at ${workerPath} does not parse ` +
+                        `(${e instanceof Error ? e.message : String(e)}). ` +
+                        `Reinstall the extension (e.g. \`pi update --extensions\`) so the build step regenerates it.`,
+                        { cause: e },
+                    );
+                }
+
                 // Identity token for THIS pool instance. The handlers below compare it against
                 // the live `this.poolEpoch` so a superseded pool's trailing events are ignored.
                 const myEpoch = ++this.poolEpoch;
@@ -472,7 +519,7 @@ export class WorkerPoolManager implements IService {
                 // and nulling shared state would clobber a pool rebuilt after the shutdown.
                 if (this.isShuttingDown || this.generation !== myGen) return;
                 this.poolEpoch++; // intentional destroy: silence the dying pool's exit events
-                if (deadPool) await deadPool.destroy();
+                if (deadPool) await this.destroyPoolOnce(deadPool);
                 logger.info('[WorkerPoolManager] Auto-recovery: old pool destroyed.');
             } catch (err) {
                 logger.warn('[WorkerPoolManager] Auto-recovery: error destroying old pool:', err);
@@ -535,7 +582,10 @@ export class WorkerPoolManager implements IService {
                 // in their killHandler (context.close / browser.close via Playwright), so
                 // allow enough time for those to complete before the IPC channel closes.
                 this.poolEpoch++; // intentional destroy: silence the dying pool's exit events
-                const destroyPromise = this.pool.destroy();
+                // Shared promise: if the auto-recovery timer is already destroying this pool
+                // (it fired before shutdown cleared the handle), await that destroy instead of
+                // racing a second one — the double-destroy race of the 2026-10-08 crash chain.
+                const destroyPromise = this.destroyPoolOnce(this.pool);
                 destroyPromise.catch((err: Error) => logger.debug(`[WorkerPoolManager] Background pool destroy rejection: ${err.message}`));
                 await raceWithDeadline(destroyPromise, 5000);
             } catch (e) {