@lincoln504/pi-research 1.3.11 → 1.3.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lincoln504/pi-research",
-  "version": "1.3.11",
+  "version": "1.3.12",
   "description": "Free unlimited web search and deep research for the Pi coding agent. Local knowledge store. Also works from Claude Code, Codex, and OpenClaw.",
   "type": "module",
   "private": false,
@@ -53,19 +53,27 @@
     "pi-package",
     "pi-extension",
     "pi-coding-agent",
+    "claude-code",
     "openclaw",
+    "codex",
+    "agent-skills",
     "agent-skill",
     "skills",
-    "research",
+    "web-search",
     "web-research",
     "deep-research",
-    "agent",
-    "web-search",
+    "ai-research",
+    "research",
+    "web-scraping",
     "scraping",
-    "knowledge-store",
-    "duckduckgo",
+    "browser-automation",
     "stealth-browser",
-    "camoufox"
+    "camoufox",
+    "duckduckgo",
+    "knowledge-store",
+    "llm-tools",
+    "web-access",
+    "agent"
   ],
   "author": "Lincoln Deen",
   "contributors": [
@@ -120,7 +128,7 @@
     "@earendil-works/pi-tui": ">=0.84.0 <1",
     "@huggingface/transformers": "4.2.0",
     "@kreuzberg/html-to-markdown-node": "^3.5.5",
-    "@lancedb/lancedb": "0.29.0",
+    "@lancedb/lancedb": "0.37.1",
     "apache-arrow": "21.1.0",
     "bgutils-js": "^3.2.0",
     "camoufox-js": "^0.10.2",
@@ -133,7 +141,7 @@
     "poolifier": "^5.3.2",
     "typebox": "1.3.7",
     "undici": "^8.9.0",
-    "youtubei.js": "^17.2.0"
+    "youtubei.js": "^18.0.0"
   },
   "optionalDependencies": {
     "webgpu": "^0.4.0"
@@ -154,7 +162,7 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "@types/jsdom": "^28.0.3",
+    "@types/jsdom": "^30.0.0",
     "@typescript-eslint/eslint-plugin": "^8.65.0",
     "@typescript-eslint/parser": "^8.65.0",
     "@vitest/coverage-v8": "^4.1.10",

package/scripts/cleanup.cjs

@@ -197,13 +197,34 @@ const dirName = rawDirName && !rawDirName.includes('/') && !rawDirName.includes(
  * several tools' state by name); a substring match would treat that shared
  * folder as exclusively ours and wholesale-delete it. Only the exact default
  * layout is something WE constructed and can therefore prove is ours.
+ *
+ * Segment-adjacency is NOT that proof either, and used to be what this did:
+ * it tested whether `<dirName>/research` appeared ANYWHERE in the path, with no
+ * constraint on what followed. That also matched:
+ *   - the research ROOT itself (`~/.pi/research`) — which holds config.env and
+ *     knowledge_db/, the two things this script's header promises to preserve;
+ *   - any unrelated directory beneath it (`/mnt/backup/.pi/research/mystate`);
+ *   - traversal forms (`~/.pi/research/../../..`) that resolve far outside our
+ *     tree entirely.
+ *
+ * The real proof is the full default *shape*: the runtime only ever builds
+ * `<root>/<dirName>/research/state`. Requiring those three trailing segments on
+ * the RESOLVED path keeps a relocated-but-default layout reclaimable while
+ * refusing the research root, sibling directories, and traversal escapes.
  */
+const DEFAULT_STATE_TAIL = [dirName, 'research', 'state'];
+
 function isPiResearchNamespaced(p) {
-  const segs = p.split(/[\\/]+/).filter(Boolean);
-  for (let i = 0; i < segs.length - 1; i++) {
-    if (segs[i] === dirName && segs[i + 1] === 'research') return true;
-  }
-  return false;
+  // Resolve first so `..` cannot smuggle the tail past this check.
+  const resolved = path.resolve(p);
+  // Windows and macOS default to case-insensitive filesystems, so a path
+  // differing only in case still names the directory we built.
+  const fold = (s) =>
+    process.platform === 'win32' || process.platform === 'darwin' ? s.toLowerCase() : s;
+  const segs = resolved.split(/[\\/]+/).filter(Boolean);
+  if (segs.length < DEFAULT_STATE_TAIL.length) return false;
+  const tail = segs.slice(-DEFAULT_STATE_TAIL.length);
+  return DEFAULT_STATE_TAIL.every((want, i) => fold(tail[i]) === fold(want));
 }
 
 /**

package/scripts/setup.cjs

@@ -47,8 +47,25 @@ function resolveCamoufoxBin() {
   return null;
 }
 
+/**
+ * The custom camoufox location, if the user set one. Mirrors
+ * getCustomCamoufoxDir() in src/infrastructure/browser/config.ts — the two must
+ * agree or install and lookup land in different directories.
+ *
+ * CAMOUFOX_INSTALL_DIR first: it is camoufox-js's own variable and the only one
+ * that can relocate the install (camoufox-js <0.12.0 hardcodes
+ * userCacheDir("camoufox") and honours nothing). PLAYWRIGHT_BROWSERS_PATH is
+ * kept as the documented alias and is exported BELOW as CAMOUFOX_INSTALL_DIR.
+ * NOTE: inert on the pinned camoufox-js 0.10.x, which reads neither — this is
+ * forward-compatible plumbing, not a live fix. See src/infrastructure/browser/
+ * config.ts and thread-worker-browser.ts.
+ */
+function customCamoufoxDir() {
+  return process.env.CAMOUFOX_INSTALL_DIR || process.env.PLAYWRIGHT_BROWSERS_PATH || null;
+}
+
 function camoufoxCachePath() {
-  const customPath = process.env.PLAYWRIGHT_BROWSERS_PATH;
+  const customPath = customCamoufoxDir();
   if (customPath) return customPath;
 
   if (isWindows) {
@@ -68,6 +85,13 @@ if (process.env.PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD === '1') {
   console.log('pi-research: skipping browser download (PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD=1)');
 } else {
   const env = { ...process.env };
+  // Make the fetch honour the custom location. Without this the download always
+  // went to camoufox's default cache while camoufoxCachePath() reported the
+  // custom one: the "already installed" probe never matched, every install
+  // re-fetched, and at runtime the browser was reported missing despite having
+  // downloaded successfully.
+  const customDir = customCamoufoxDir();
+  if (customDir) env.CAMOUFOX_INSTALL_DIR = customDir;
 
   const installDeps = process.argv.includes('--system-deps') || process.env.PLAYWRIGHT_INSTALL_DEPS === 'true';
   if (installDeps && isLinux) {

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

package/src/cli.ts

@@ -45,6 +45,7 @@ import { getConfig, getGlobalConfigDir, getGlobalEnvFilePath, getInterfaceEnvFil
 import { getAgentDir } from '@earendil-works/pi-coding-agent';
 import { buildModelRegistry, safeGetAvailable } from './core/llm/model-registry-factory.ts';
 import { RESEARCH_TOOL_NAMES } from './constants.ts';
+import { isBrowserAvailable } from './infrastructure/browser/config.ts';
 
 // ---------------------------------------------------------------------------
 // Constants
@@ -770,6 +771,18 @@ async function cmdStatus(json?: boolean): Promise<number> {
   const det = await detectCredentials();
   const paths = resolvedConfigPaths();
   const cfg = getConfig(process.cwd(), 'cli');
+  // The stealth browser is installed by this package's `postinstall`
+  // (scripts/setup.cjs), which npm 11.19+ BLOCKS BY DEFAULT — it now warns
+  // "packages have install scripts not yet covered by allowScripts" and carries
+  // on, so the browser is simply absent on an otherwise successful install.
+  // Every other native artifact survives that (onnxruntime, sharp, esbuild and
+  // webgpu all ship prebuilt platform packages), which is exactly what makes
+  // this one worth reporting: nothing else fails, and without this the first
+  // symptom is a scrape falling back mid-run. A missing browser degrades
+  // capability rather than breaking the tool — the fetch path still serves most
+  // pages — so it is reported alongside `ready` rather than folded into it.
+  // isBrowserAvailable() is a resolve + existsSync; it never launches anything.
+  const browserInstalled = isBrowserAvailable();
   const summary = {
     package: '@lincoln504/pi-research',
     version: PKG_VERSION,
@@ -783,6 +796,14 @@ async function cmdStatus(json?: boolean): Promise<number> {
       modelFrom: det.modelFrom,
       problem: det.problem ?? null,
     },
+    browser: {
+      installed: browserInstalled,
+      // Same remedy the health check prints, so both surfaces name one command.
+      fix: browserInstalled ? null : 'npx camoufox-js fetch',
+      note: browserInstalled
+        ? null
+        : 'Stealth browser not installed — scraping falls back to plain fetch, which some sites block. npm 11.19+ blocks install scripts by default, which skips this package\'s postinstall.',
+    },
     knowledgeStoreMode: cfg.KNOWLEDGE_STORE_MODE,
     defaultDepth: cfg.DEFAULT_RESEARCH_DEPTH,
     paths,
@@ -796,6 +817,10 @@ async function cmdStatus(json?: boolean): Promise<number> {
   toStdout(`pi-research ${PKG_VERSION}\n`);
   toStdout(`ready: ${summary.ready ? 'yes' : 'no'}\n\n`);
   toStdout(configBlock(det, summary.ready ? undefined : '— fix the problem above, then re-run.') + '\n');
+  if (!summary.browser.installed) {
+    toStdout(`\nstealth browser: NOT INSTALLED — run: ${summary.browser.fix}\n`);
+    toStdout(`  ${summary.browser.note}\n`);
+  }
   toStdout(`\nknowledge store mode: ${cfg.KNOWLEDGE_STORE_MODE}   (default depth: ${cfg.DEFAULT_RESEARCH_DEPTH})\n`);
   return EXIT.OK;
 }
@@ -1064,7 +1089,17 @@ export async function reportError(err: unknown, what: string, json?: boolean): P
   // --json: emit a structured error on stdout so a machine consumer never has to
   // special-case plain-text stderr. Mirrors the { ok: true, ... } success shape.
   if (json) {
-    const payload: Record<string, unknown> = { ok: false, error: msg, exitCode };
+    // A cancellation reports itself as a cancellation, not as whatever component
+    // happened to notice the abort first. The internal message is genuinely
+    // misleading here — a Ctrl-C unwinding through the planner surfaces as
+    // "Coordinator failed: Request was aborted", so a consumer relaying `error`
+    // verbatim (which SKILL.md instructs agents to do) tells the user a component
+    // broke when they simply stopped the run. The plain-text branch below already
+    // refuses to say "failed" for a cancel; JSON said it anyway. The original
+    // wording is preserved under `cause` so nothing diagnostic is lost.
+    const payload: Record<string, unknown> = isCancellation
+      ? { ok: false, error: `pi-research ${what} cancelled.`, cause: msg, exitCode }
+      : { ok: false, error: msg, exitCode };
     // Machine-readable "this will succeed later" flag, so a consumer can back off
     // and retry without string-matching the human message. Gated on cancellation:
     // a Ctrl-C landing in the same window a queue-wait expires must never emit

package/src/core/service-registry.ts

@@ -178,10 +178,26 @@ export class ServiceContainer {
     options: ServiceContainerOptions = {}
   ): Promise<void> {
     const mergedOptions = { ...this.defaultOptions, ...options, allowOverwrite: true };
-    
+
     // Dispose existing service if present
-    if (this.services.has(name)) {
-      const registration = this.services.get(name)!;
+    const registration = this.services.get(name);
+    if (registration) {
+      // Join an already-in-flight clear()/replace()/disposeAll() on this
+      // registration before touching its instance — the same guard those paths
+      // use on each other. Without it, a concurrent teardown and this call both
+      // dispose the SAME instance, and register() below then swaps the whole
+      // registration object out from under the in-flight one, orphaning any
+      // instance it constructs.
+      // while(), not if(): a newer disposal can begin while we are awaiting this
+      // one, exactly as get() documents for the same field.
+      while (registration.disposalPromise) {
+        await registration.disposalPromise.catch(() => { /* disposal errors are logged by clear()/replace() */ });
+      }
+      // Settle an in-flight initialization too, so we never discard a service
+      // that is still being built — mirrors replace().
+      if (registration.initializationPromise) {
+        await registration.initializationPromise.catch(() => { /* failed init cleaned up after itself */ });
+      }
       if (registration.instance && registration.instance.dispose) {
         try {
           await registration.instance.dispose();

package/src/infrastructure/browser/config.ts

@@ -31,15 +31,40 @@ function getWindowsCamoufoxDir(): string {
     return join(homedir(), 'AppData', 'Local', 'camoufox', 'camoufox', 'Cache');
 }
 
+/**
+ * The custom camoufox location, if the user set one.
+ *
+ * CAMOUFOX_INSTALL_DIR takes precedence because it is camoufox-js's OWN
+ * variable and the only one that can ever move the install: camoufox-js ≥0.12.0
+ * resolves INSTALL_DIR from it. PLAYWRIGHT_BROWSERS_PATH is kept as a documented
+ * alias, but on its own it only ever moved where we LOOK — camoufox went on
+ * installing to the default cache, so setting it made the browser permanently
+ * "not found" right after a successful download. Both are exported onward to
+ * camoufox-js (getBrowserEnv, scripts/setup.cjs) so that install and lookup
+ * cannot disagree.
+ *
+ * CAVEAT, deliberate: the pinned camoufox-js (0.10.x — see
+ * thread-worker-browser.ts for why it cannot move yet) hardcodes
+ * `userCacheDir("camoufox")` and honours NEITHER variable, so on the shipped
+ * pin a custom location still only relocates lookup and the underlying bug
+ * remains. This plumbing is correct and inert rather than wrong: it starts
+ * working the moment the pin can advance, and costs nothing until then. Until
+ * that happens, treat a custom browser directory as unsupported.
+ */
+function getCustomCamoufoxDir(): string | undefined {
+    return process.env['CAMOUFOX_INSTALL_DIR'] || process.env['PLAYWRIGHT_BROWSERS_PATH'] || undefined;
+}
+
 /**
  * Get the camoufox binary cache directory.
- * Uses PLAYWRIGHT_BROWSERS_PATH if set, otherwise the standard user cache location
+ * Uses the custom location above if set, otherwise the standard user cache location
  * that camoufox uses by default (~/.cache/camoufox on Linux).
  * We do NOT override HOME — that trick was unreliable and caused install/runtime mismatches.
  */
 export function getBrowserCacheDir(): string {
-    if (process.env['PLAYWRIGHT_BROWSERS_PATH']) {
-        return process.env['PLAYWRIGHT_BROWSERS_PATH'];
+    const custom = getCustomCamoufoxDir();
+    if (custom) {
+        return custom;
     }
     // Mirror getCamoufoxBinaryPath() so both functions agree on the cache location
     const osPlatform = platform();
@@ -109,11 +134,17 @@ export function getBrowserProfileDir(config?: Config): string {
  */
 export function getBrowserEnv(config?: Config): NodeJS.ProcessEnv {
     const env: NodeJS.ProcessEnv = { ...process.env };
-    const customPath = process.env['PLAYWRIGHT_BROWSERS_PATH'];
+    const customPath = getCustomCamoufoxDir();
     if (customPath) {
         env['PLAYWRIGHT_BROWSERS_PATH'] = customPath;
+        // The one that camoufox-js actually reads. Without it the worker's
+        // camoufox launches from the DEFAULT cache while everything on this side
+        // resolves the custom path — the install/runtime mismatch this file's
+        // header warns about, just arriving through a different door.
+        env['CAMOUFOX_INSTALL_DIR'] = customPath;
     } else {
         delete env['PLAYWRIGHT_BROWSERS_PATH'];
+        delete env['CAMOUFOX_INSTALL_DIR'];
     }
     // Tell thread-workers where to write their lifecycle/error log. Precedence:
     //   1. A user-set PI_RESEARCH_LOG_FILE (already copied from process.env above) wins —
@@ -164,7 +195,7 @@ export function ensureBrowserCacheDir(): string {
  * Matches camoufox-js's own resolution logic.
  */
 export function getCamoufoxBinaryPath(): string {
-    const customPath = process.env['PLAYWRIGHT_BROWSERS_PATH'];
+    const customPath = getCustomCamoufoxDir();
     if (customPath) {
         return customPath;
     }

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

@@ -136,9 +136,19 @@ async function isRegisteredLeaderAlive(container: ServiceContainer): Promise<boo
     return result;
 }
 
-/** Test seam: drop the coalesced liveness probe. */
-export function _resetLeaderLivenessProbeForTests(): void {
+/**
+ * Test seam: drop BOTH module-level globals that survive between tests — the
+ * coalesced liveness probe (1s window) and the restart cooldown (10s window).
+ *
+ * Both are far longer than a test file's runtime, so a test that reaches
+ * restartSchedulerWithHerdGuard leaves state that silently short-circuits the
+ * next one: isRegisteredLeaderAliveUncached / forceSchedulerRestart simply are
+ * not re-invoked. Today nothing observes that only because the one test that
+ * reaches this path happens to run last — ordering, not a guarantee.
+ */
+export function _resetTaskExecutionGlobalsForTests(): void {
     leaderLivenessProbe = null;
+    lastRestartTime = 0;
 }
 
 /**

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

@@ -134,29 +134,45 @@ export async function initBrowser(): Promise<void> {
         // (consumers install without our lockfile, so a floating range resolves
         // to a newer, broken version):
         //
-        //   • camoufox-js  ^0.10.2  → fetches camoufox Firefox 135 / beta.24, the
-        //     NEWEST camoufox with binaries for every OS we support (Linux x64/
-        //     arm64, macOS x64/arm64, Windows x64). FF146/FF150 dropped the
-        //     Windows build entirely, so the 0.11.x line breaks Windows installs.
+        //   • camoufox-js  ^0.10.2  → the two ORIGINAL reasons for this pin have
+        //     both lapsed (camoufox restored Windows assets in v152.0.4-beta.26,
+        //     2026-07-16; and impit's `only-allow pnpm` guard existed only in
+        //     0.13.1/0.14.0), but a THIRD, worse one replaced them. 0.12.0
+        //     requires `better-sqlite3 ^13.0.1`, and better-sqlite3 13 DROPPED
+        //     PREBUILT BINARIES: 12.x installs via `prebuild-install || node-gyp
+        //     rebuild`, 13.x has no install script at all, so npm falls back to
+        //     auto-running `node-gyp rebuild` for its binding.gyp and every
+        //     install needs a full C++ toolchain. Measured: `npm ci` fails
+        //     outright on the Windows CI runner ("could not find a version of
+        //     Visual Studio 2017 or newer"), which is most Windows consumers.
+        //     Upgrading again means checking better-sqlite3 first, not camoufox.
         //   • playwright-core  1.60.0 (exact) → playwright-core and the camoufox
         //     binary are one matched Juggler-protocol pair. 1.61 added a
-        //     viewport.isMobile field the FF135 build REJECTS ("property
+        //     viewport.isMobile field the build REJECTS ("property
         //     viewport.isMobile not described in this scheme"), failing every
-        //     launch below. 1.60.0 is the newest playwright the FF135 Juggler
-        //     accepts.
+        //     launch below. Corroborated upstream: camoufox-js 0.12.0 declares
+        //     `peerDependencies: playwright-core "<1.61.0"`, the same bound this
+        //     pin has held by hand.
         //   • impit  0.13.0 (exact, a direct dep though only camoufox-js uses it)
-        //     → impit 0.13.1/0.14.0 shipped a `preinstall: npx only-allow pnpm`
-        //     guard (an upstream mistake, fixed in 0.14.1+) that hard-fails
-        //     `npm install -g`. Within camoufox-js's ^0.13.0 range 0.13.0 is the
-        //     only guard-free version; a direct-dep pin is the ONLY way to force
-        //     it for consumers (npm `overrides` don't propagate to installers of
-        //     a published package).
+        //     → camoufox-js 0.10.2 requires `impit ^0.13.0`, and within that range
+        //     0.13.0 is the only version free of the `preinstall: npx only-allow
+        //     pnpm` guard (an upstream mistake in 0.13.1/0.14.0, dropped again in
+        //     0.14.1) that hard-fails `npm install -g`. The exact pin is also the
+        //     ONLY way to force a version for consumers, since npm `overrides`
+        //     don't propagate to installers of a published package.
         //
-        // Removal: upgrade all three together when camoufox ships stable
-        // cross-platform (incl. Windows) FF150 binaries — bumping camoufox-js to
-        // ≥0.11.1 also drops the impit pin (0.11.1 requires the fixed impit
-        // ^0.14.1) and needs playwright re-pinned to the new build's Juggler.
-        // Always re-verify a real headless run on Linux/macOS/Windows after.
+        // What is NOT pinned: the browser BINARY. `camoufox-js fetch` takes no
+        // version argument — it walks the GitHub releases newest-first and takes
+        // the first non-prerelease one with an asset for this OS/arch. A consumer
+        // therefore gets whatever camoufox published most recently, whichever
+        // camoufox-js they have, and a future release could break launches with no
+        // change on our side. Both the current newest (v152.0.4-beta.28, Firefox
+        // 152) and the older v135.0.1-beta.24 an existing cache may hold were
+        // verified launching and driving under playwright-core 1.60.0.
+        //
+        // Always re-verify a REAL headless run after touching any of this: the
+        // unit and integration suites mock the browser, so a Juggler mismatch
+        // reaches production with a fully green suite.
         let CamoufoxModule: any;
         try {
           CamoufoxModule = await import('camoufox-js');

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

@@ -99,7 +99,10 @@ var init_log_utils = __esm({
       `${B_LEFT}(sk-[A-Za-z0-9_-]{16,}|gh[posru]_[A-Za-z0-9]{16,}|github_pat_[A-Za-z0-9_]{20,}|AKIA[0-9A-Z]{16}|xox[baprs]-[A-Za-z0-9-]{10,})${B_RIGHT}`,
       "g"
     );
-    JWT_PATTERN = new RegExp(`${B_LEFT}eyJ[A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+`, "g");
+    JWT_PATTERN = new RegExp(
+      `${B_LEFT}eyJ[A-Za-z0-9_-]{1,1024}\\.[A-Za-z0-9_-]{1,8192}\\.[A-Za-z0-9_-]{1,4096}`,
+      "g"
+    );
     BASIC_AUTH_PATTERN = new RegExp(`${B_LEFT}Basic\\s+[A-Za-z0-9+/]{16,}={0,2}`, "gi");
     BEARER_AUTH_PATTERN = new RegExp(`${B_LEFT}Bearer\\s+[A-Za-z0-9._~+/-]+=*`, "gi");
     PROVIDER_TOKEN_PATTERN = new RegExp(
@@ -1509,6 +1512,7 @@ var scraper_utils_exports = {};
 __export(scraper_utils_exports, {
   createJsMarkdownConverter: () => createJsMarkdownConverter,
   createNativeMarkdownConverter: () => createNativeMarkdownConverter,
+  disposeSsrfSafeFetcher: () => disposeSsrfSafeFetcher,
   extractDomain: () => extractDomain,
   formatErrorWithCause: () => formatErrorWithCause,
   getRandomUserAgent: () => getRandomUserAgent,
@@ -1644,19 +1648,33 @@ function isSsrfBlockError(error) {
   }
   return false;
 }
-async function getSsrfSafeFetcher() {
-  if (cachedSsrfFetcher !== void 0) return cachedSsrfFetcher;
+function getSsrfSafeFetcher() {
+  cachedSsrfFetcher ??= (async () => {
+    try {
+      const { Agent, fetch: undiciFetch } = await import("undici");
+      return {
+        fetch: undiciFetch,
+        dispatcher: new Agent({ connect: { lookup: ssrfSafeLookup } })
+      };
+    } catch (e) {
+      logger.warn(`[Scrapers] undici unavailable; connect-time SSRF pinning disabled (request-time validation still active): ${e instanceof Error ? e.message : String(e)}`);
+      return null;
+    }
+  })();
+  return cachedSsrfFetcher;
+}
+async function disposeSsrfSafeFetcher() {
+  const pending = cachedSsrfFetcher;
+  cachedSsrfFetcher = void 0;
+  if (pending === void 0) return;
+  const cached = await pending.catch(() => null);
+  const closable = cached?.dispatcher;
+  if (!closable?.close) return;
   try {
-    const { Agent, fetch: undiciFetch } = await import("undici");
-    cachedSsrfFetcher = {
-      fetch: undiciFetch,
-      dispatcher: new Agent({ connect: { lookup: ssrfSafeLookup } })
-    };
+    await closable.close();
   } catch (e) {
-    logger.warn(`[Scrapers] undici unavailable; connect-time SSRF pinning disabled (request-time validation still active): ${e instanceof Error ? e.message : String(e)}`);
-    cachedSsrfFetcher = null;
+    logger.debug(`[Scrapers] Error closing SSRF dispatcher: ${e instanceof Error ? e.message : String(e)}`);
   }
-  return cachedSsrfFetcher;
 }
 function formatErrorWithCause(err) {
   try {

package/src/infrastructure/gpu-resource-service.ts

@@ -27,7 +27,21 @@ export class GPUResourceService implements IGPUResourceService {
   lifecycle = ServiceLifecycle.UNINITIALIZED;
 
   private processLifecycle: IProcessLifecycle | null = null;
-  private gpuLockStaleThresholdMs: number = 1000 * 60 * 5; // 5 minutes default
+  /**
+   * Backstop for a holder that is alive but wedged. Step 3 already reclaims from
+   * *dead* owners via PID+startTime liveness, so this only ever fires against a
+   * process we just proved is running — which makes it a lock STEAL, and the
+   * threshold must therefore exceed the longest legitimate hold.
+   *
+   * It previously did not: at 5 minutes it exactly equalled the default
+   * EMBEDDING_MODEL_INIT_TIMEOUT_MS (300000, schema max 600000), and the
+   * embedder holds this lock across the whole model download + pipeline load.
+   * A first-time HuggingFace fetch running near its own permitted budget would
+   * have the GPU lock taken out from under it, admitting exactly the concurrent
+   * WebGPU/Dawn init this lock exists to prevent. Keep this strictly above that
+   * schema maximum.
+   */
+  private gpuLockStaleThresholdMs: number = 1000 * 60 * 15; // 15 min > EMBEDDING_MODEL_INIT_TIMEOUT_MS max (10 min)
 
   constructor(options?: GPUResourceServiceOptions) {
     if (options) {

package/src/knowledge/embedder-init.ts

@@ -295,7 +295,23 @@ export async function loadModelOnCPU(
         interOpNumThreads: 1,
       },
     });
-    return await withTimeout(pipelinePromise, initializationTimeoutMs, 'CPU fallback model load timed out');
+    // Same late-arrival disposal as loadPipelineWithTimeout: withTimeout races
+    // but cannot cancel, so on timeout the CPU load keeps running and its
+    // eventual ONNX session would leak. This path runs *after* a WebGPU
+    // failure — i.e. on a host already under memory pressure — and can be
+    // re-entered per retry, so each orphaned session compounds.
+    let timedOut = true;
+    try {
+      const p = await withTimeout(pipelinePromise, initializationTimeoutMs, 'CPU fallback model load timed out');
+      timedOut = false;
+      return p;
+    } finally {
+      if (timedOut) {
+        pipelinePromise
+          .then((late) => (late as unknown as { dispose?: () => Promise<void> }).dispose?.())
+          .catch(() => { /* load failed after the timeout — nothing to dispose */ });
+      }
+    }
   });
   
   return loadedPipeline;

package/src/knowledge/store.ts

@@ -30,11 +30,15 @@ import { normalizeWorkspacePath } from '../utils/text-utils.ts';
 
 /**
  * Detect a LanceDB concurrent-write conflict — the class of error worth retrying
- * with backoff. LanceDB 0.29 surfaces these as "Commit conflict for version N",
+ * with backoff. LanceDB surfaces these as "Commit conflict for version N",
  * "Retryable commit conflict for version N" and "Too many concurrent writes,
- * please retry later:" (strings confirmed in the 0.29.0 native binary). The three
- * legacy strings ("Version mismatch" / "Lock error" / "Commit error") no longer
- * appear in 0.29 but are kept as a safety net for other/older Lance versions.
+ * please retry later:" — all three re-confirmed present in the 0.37.1 native
+ * binary (`@lancedb/lancedb-<platform>`, NOT the `@lancedb/lancedb` JS package;
+ * grepping the latter finds nothing and looks like a regression), as they were
+ * in 0.29.0. The three legacy strings ("Version mismatch" / "Lock error" /
+ * "Commit error") appear in neither and are kept as a safety net for other/older
+ * Lance versions. Re-check these against the native binary on every upgrade: a
+ * changed message silently turns a retryable conflict into a hard failure.
  */
 export function isLanceCommitConflict(err: unknown): boolean {
   const msg = err instanceof Error ? err.message : String(err);
@@ -1065,7 +1069,9 @@ export class KnowledgeStore implements IKnowledgeStore {
       // no lock, so rows committed DURING the rebuild were absorbed into the
       // baseline as already-indexed and stayed out of the BM25 leg until an
       // unrelated later commit. Each createIndex commits exactly one version
-      // (measured on lancedb 0.29, fresh and replace alike); anything beyond
+      // (measured on lancedb 0.29 and re-measured on 0.37.1 — vector index, FTS
+      // index and a `replace: true` rebuild each advance version() by exactly
+      // 1); anything beyond
       // version+2 means a concurrent commit rebased beneath our index commits, so
       // fall back to the conservative pre-rebuild baseline — the next cleanup
       // sees version > baseline and rebuilds over the missed rows.

package/src/orchestration/research-orchestration-service.ts

@@ -14,7 +14,7 @@ import type { Model } from '@earendil-works/pi-ai';
 import { resolveResearchModel } from '../core/llm/research-model-resolver.ts';
 import type { QueryResultWithError } from '../web-research/types.ts';
 import type { RunResearchersOptions } from './orchestration-types.ts';
-import { RESEARCHER_LAUNCH_DELAY_MS, resolveExcludedTools } from '../constants.ts';
+import { RESEARCHER_LAUNCH_DELAY_MS, RESEARCH_TOOL_NAMES, resolveExcludedTools } from '../constants.ts';
 import { search } from '../web-research/search.ts';
 import { parseCitations } from '../utils/text-utils.ts';
 import { logger, resetLogger } from '../logger.ts';
@@ -98,6 +98,27 @@ export class ResearchOrchestrationService implements IResearchOrchestration {
     const configDisabledTools = researchConfig.DISABLED_TOOLS
       ? researchConfig.DISABLED_TOOLS.split(',').map((s) => s.trim()).filter(Boolean)
       : [];
+    // Unknown names are a SILENT no-op downstream (the merge is a blind Set union),
+    // so a typo leaves the tool enabled for a whole billed run while the user
+    // believes it is off. `--exclude-tools` fails fast on this in the CLI parser;
+    // its two siblings — the SDK's `excludeTools` option and
+    // PI_RESEARCH_DISABLED_TOOLS — reach the same union with no check at all, and
+    // RESEARCH_TOOL_NAMES already documents itself as the vocabulary all THREE
+    // accept. Warn rather than throw here: this chokepoint is mid-run and serves a
+    // library API and an ambient env var, where aborting a legitimate request over
+    // one unrecognized name is the wrong trade — the CLI keeps its fail-fast.
+    for (const [surface, names] of [
+      ['excludeTools', excludeTools ?? []],
+      ['PI_RESEARCH_DISABLED_TOOLS', configDisabledTools],
+    ] as const) {
+      const unknown = names.filter((t) => !RESEARCH_TOOL_NAMES.includes(t));
+      if (unknown.length > 0) {
+        logger.warn(
+          `[ResearchOrchestrationService] ${surface}: ignoring unknown tool name${unknown.length === 1 ? '' : 's'} ` +
+          `${unknown.map((t) => `"${t}"`).join(', ')} — these exclude nothing. Valid names: ${RESEARCH_TOOL_NAMES.join(', ')}.`
+        );
+      }
+    }
     const mergedExcludeTools = resolveExcludedTools(excludeTools, configDisabledTools);
 
     // Resolve model using centralized priority logic

package/src/prompts/system-coordinator.md

@@ -36,7 +36,7 @@ Before splitting the query into researchers, pin down its scope — exactly what
 
 1. **Plan ONLY Round 1**: Split the query into distinct sub-topics, all inside the scope above, each assigned to a researcher. **Do NOT plan multiple rounds in advance** — additional rounds are only delegated reactively when Round 1 findings reveal gaps.
 2. **Assign Goals**: Each researcher gets a focused goal covering a specific angle or time period.
-3. **Temporal Awareness**: Lead with the current month and year shown above. Generate time-sensitive queries using that exact month and year (e.g., append the current year and, where relevant, the current month; "latest", "current status"). Never anchor queries to an older year (e.g. 2024 or 2025) unless the user explicitly asks about the past. Research MUST be grounded in the present month and year.
+3. **Temporal Awareness**: Lead with the current month and year shown above. Generate time-sensitive queries using that exact month and year (e.g., append the current year and, where relevant, the current month; "latest", "current status"). Never anchor queries to an older year than the one shown above unless the user explicitly asks about the past. Research MUST be grounded in the present month and year.
 4. **Query Planning**: For EACH researcher, generate targeted, specific queries within the budget. Fill the budget when the topic is broad enough to warrant it, but don't pad queries for a narrow topic. Each round is planned independently — make Round 1 count.
 5. **YouTube Discovery**: For roughly **one in {{youtube_query_every_n}}** of each researcher's queries, append the word `youtube` to the query text (e.g. `"<topic> explained youtube"`). DuckDuckGo rarely surfaces YouTube on its own, and YouTube links let researchers read video transcripts. Skip this only when the topic is clearly unsuited to video (e.g. a single numeric lookup).
 6. **Seed Search Burst**: All queries across all researchers are combined into a single pre-search pass that seeds the global link pool.

package/src/prompts/system-lead-evaluator.md

@@ -74,7 +74,7 @@ Use unique, targeted queries for any new researchers.
 - **CRITICAL — Queries are mandatory**: Every researcher MUST have at least one query. Never plan a researcher without queries. Researchers receive ONLY the search results you delegate to them.
 - **Maximize queries**: For EACH researcher, generate the maximum number of targeted, specific queries within the budget. Do not plan fewer than needed — fill the budget. Queries should target primary sources and authoritative evidence.
 - **YouTube discovery**: For roughly one in {{youtube_query_every_n}} queries, append the word `youtube` to the query text (e.g. `"<topic> analysis youtube"`). DuckDuckGo rarely surfaces YouTube on its own, and YouTube links let researchers read video transcripts. Skip only when the gap is clearly unsuited to video.
-- **Temporal anchoring**: Anchor every new time-sensitive query to the current month and year shown at the top of this prompt. Use that exact year (and month where relevant); never default to an older year such as 2024 or 2025 unless the user explicitly asks about the past.
+- **Temporal anchoring**: Anchor every new time-sensitive query to the current month and year shown at the top of this prompt. Use that exact year (and month where relevant); never default to an older year than the one shown there unless the user explicitly asks about the past.
 - **Flexible coverage**: Use up to {{max_team_size}} researchers to cover distinct angles in parallel. Scale based on research gaps — a single well-targeted researcher is often sufficient for focused gaps.
 - **Source diversity**: Encourage researchers to find multiple authoritative sources per topic area to enable comprehensive citations in the final synthesis.