@lincoln504/pi-research 1.7.7 → 1.7.9

package/dist/cli.mjs

@@ -230,7 +230,12 @@ function redactSecrets(message) {
   out = out.replace(BASIC_AUTH_PATTERN, "Basic [REDACTED]");
   out = out.replace(BEARER_AUTH_PATTERN, "Bearer [REDACTED]");
   out = out.replace(COOKIE_HEADER_PATTERN, (_m, key, sep3) => `${key}${sep3}[REDACTED]`);
-  out = out.replace(SENSITIVE_KV_PATTERN, (_m, key, sep3) => `${key}${sep3}[REDACTED]`);
+  out = out.replace(AUTH_SCHEME_PATTERN, (_m, key, sep3, scheme) => `${key}${sep3}${scheme} [REDACTED]`);
+  out = out.replace(SENSITIVE_KV_PATTERN, (_m, key, sep3, val) => {
+    const q = val[0] === '"' || val[0] === "'" ? val[0] : "";
+    const closed = q !== "" && val.length > 1 && val.endsWith(q);
+    return `${key}${sep3}${q}[REDACTED]${closed ? q : ""}`;
+  });
   out = out.replace(KNOWN_TOKEN_PATTERN, "[REDACTED]");
   out = out.replace(PROVIDER_TOKEN_PATTERN, "[REDACTED]");
   out = out.replace(LONG_HEX_SECRET_PATTERN, "[REDACTED]");
@@ -249,7 +254,7 @@ function redactSecrets(message) {
 function stripTerminalEscapes(message) {
   return message.replace(TERMINAL_ESCAPE_PATTERN, "").replace(CONTROL_CHARS_PATTERN, " ");
 }
-var logContextStorage, MAX_LOG_MESSAGE_LENGTH, ANSI_PATTERN, URL_CREDENTIALS_PATTERN, B_LEFT, B_RIGHT, 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 logContextStorage, MAX_LOG_MESSAGE_LENGTH, ANSI_PATTERN, URL_CREDENTIALS_PATTERN, B_LEFT, B_RIGHT, COOKIE_HEADER_PATTERN, SENSITIVE_KV_PATTERN, AUTH_SCHEME_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";
@@ -264,11 +269,15 @@ var init_log_utils = __esm({
       "gi"
     );
     SENSITIVE_KV_PATTERN = new RegExp(
-      `${B_LEFT}(api[_-]?key|apikey|access[_-]?token|auth[_-]?token|refresh[_-]?token|secret|client[_-]?secret|password|passwd|pwd|authorization|bearer|set[_-]?cookie|cookie|session[_-]?id|session|csrf[_-]?token|xsrf[_-]?token|private[_-]?key|key)${B_RIGHT}(["']?\\s*[:=]\\s*["']?)([^\\s"',&)]+)`,
+      `${B_LEFT}(api[_-]?key|apikey|access[_-]?token|auth[_-]?token|refresh[_-]?token|secret|client[_-]?secret|password|passwd|pwd|authorization|bearer|set[_-]?cookie|cookie|session[_-]?id|session|csrf[_-]?token|xsrf[_-]?token|private[_-]?key|token|key)${B_RIGHT}(["']?\\s*[:=]\\s*)("[^"\\r\\n]{0,1024}"|'[^'\\r\\n]{0,1024}'|["']?[^\\s"',&)]+)`,
+      "gi"
+    );
+    AUTH_SCHEME_PATTERN = new RegExp(
+      `${B_LEFT}(authorization)${B_RIGHT}(["']?\\s*[:=]\\s*["']?)([A-Za-z][A-Za-z0-9_-]{0,31})[ \\t]+[^\\s"',&)]+`,
       "gi"
     );
     KNOWN_TOKEN_PATTERN = new RegExp(
-      `${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}`,
+      `${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}|AIza[0-9A-Za-z_-]{35}|npm_[A-Za-z0-9]{36}|hf_[A-Za-z0-9]{30,}|xox[baprs]-[A-Za-z0-9-]{10,})${B_RIGHT}`,
       "g"
     );
     JWT_PATTERN = new RegExp(
@@ -4554,12 +4563,12 @@ async function isModelCached(model) {
     const cacheDir = env.cacheDir;
     if (!cacheDir) return false;
     const { access: access3, readdir: readdir6, readFile: readFile7, stat: stat6, rm: rm3 } = await import("node:fs/promises");
-    const path20 = await import("node:path");
-    const modelDir = path20.default.join(cacheDir, model);
-    const onnxDir = path20.default.join(modelDir, "onnx");
-    await access3(path20.default.join(onnxDir, "model.onnx"));
+    const path21 = await import("node:path");
+    const modelDir = path21.default.join(cacheDir, model);
+    const onnxDir = path21.default.join(modelDir, "onnx");
+    await access3(path21.default.join(onnxDir, "model.onnx"));
     try {
-      const cfgRaw = await readFile7(path20.default.join(modelDir, "config.json"), "utf-8");
+      const cfgRaw = await readFile7(path21.default.join(modelDir, "config.json"), "utf-8");
       JSON.parse(cfgRaw);
     } catch {
       return false;
@@ -4567,7 +4576,7 @@ async function isModelCached(model) {
     const tokenizerFiles = ["tokenizer.json", "tokenizer.model", "vocab.txt"];
     let hasTokenizer = false;
     for (const f of tokenizerFiles) {
-      const st = await stat6(path20.default.join(modelDir, f)).catch(() => null);
+      const st = await stat6(path21.default.join(modelDir, f)).catch(() => null);
       if (st && st.size > 0) {
         hasTokenizer = true;
         break;
@@ -4575,7 +4584,7 @@ async function isModelCached(model) {
     }
     if (!hasTokenizer) return false;
     const entries = await readdir6(onnxDir).catch(() => []);
-    const onnxPath = path20.default.join(onnxDir, "model.onnx");
+    const onnxPath = path21.default.join(onnxDir, "model.onnx");
     const onnxStat = await stat6(onnxPath).catch(() => null);
     if (onnxStat && onnxStat.size > 0 && onnxStat.size <= 1024 * 1024) {
       try {
@@ -4595,7 +4604,7 @@ async function isModelCached(model) {
     }
     const hasExternalWeights = entries.includes("model.onnx_data");
     if (hasExternalWeights) {
-      const dataStat = await stat6(path20.default.join(onnxDir, "model.onnx_data")).catch(() => null);
+      const dataStat = await stat6(path21.default.join(onnxDir, "model.onnx_data")).catch(() => null);
       if (!dataStat || dataStat.size === 0) return false;
     }
     const partialArtifacts = entries.filter(
@@ -4604,7 +4613,7 @@ async function isModelCached(model) {
     if (partialArtifacts.length > 0) {
       if (hasExternalWeights) {
         for (const f of partialArtifacts) {
-          await rm3(path20.default.join(onnxDir, f), { force: true }).catch(() => {
+          await rm3(path21.default.join(onnxDir, f), { force: true }).catch(() => {
           });
         }
       } else {
@@ -4630,10 +4639,10 @@ async function purgeModelCache(model) {
     const cacheDir = env.cacheDir;
     if (!cacheDir) return;
     const { rm: rm3 } = await import("node:fs/promises");
-    const path20 = await import("node:path");
-    const resolvedCache = path20.default.resolve(cacheDir);
-    const modelDir = path20.default.resolve(resolvedCache, model);
-    if (!model || path20.default.isAbsolute(model) || modelDir === resolvedCache || !modelDir.startsWith(resolvedCache + path20.default.sep)) {
+    const path21 = await import("node:path");
+    const resolvedCache = path21.default.resolve(cacheDir);
+    const modelDir = path21.default.resolve(resolvedCache, model);
+    if (!model || path21.default.isAbsolute(model) || modelDir === resolvedCache || !modelDir.startsWith(resolvedCache + path21.default.sep)) {
       logger.warn(`[embedder] Refusing to purge unsafe model-cache path for model id ${JSON.stringify(model)}`);
       return;
     }
@@ -6210,7 +6219,7 @@ var init_embedding_client = __esm({
         }
       }
       // ---- Internal HTTP helpers ----
-      getRequest(path20, timeoutMs = 12e4) {
+      getRequest(path21, timeoutMs = 12e4) {
         return new Promise((resolve9, reject) => {
           let resolved = false;
           let req;
@@ -6218,7 +6227,7 @@ var init_embedding_client = __esm({
             if (!resolved) {
               resolved = true;
               req?.destroy();
-              reject(new Error(`[EmbeddingClient] GET ${path20} timed out after ${timeoutMs}ms`));
+              reject(new Error(`[EmbeddingClient] GET ${path21} timed out after ${timeoutMs}ms`));
             }
           }, timeoutMs);
           if (timer.unref) timer.unref();
@@ -6226,7 +6235,7 @@ var init_embedding_client = __esm({
             {
               hostname: "127.0.0.1",
               port: this.port,
-              path: path20,
+              path: path21,
               method: "GET",
               headers: this.authHeaders()
             },
@@ -6242,19 +6251,19 @@ var init_embedding_client = __esm({
                 try {
                   const parsed = JSON.parse(collected.toString());
                   if (res.statusCode !== 200) {
-                    reject(new Error(`[EmbeddingClient] GET ${path20} returned HTTP ${res.statusCode}`));
+                    reject(new Error(`[EmbeddingClient] GET ${path21} returned HTTP ${res.statusCode}`));
                   } else {
                     resolve9(parsed);
                   }
                 } catch (_e) {
-                  reject(new Error(`[EmbeddingClient] Failed to parse GET ${path20} response: ${collected.toString()}`));
+                  reject(new Error(`[EmbeddingClient] Failed to parse GET ${path21} response: ${collected.toString()}`));
                 }
               });
               res.on("error", (err) => {
                 if (resolved) return;
                 resolved = true;
                 clearTimeout(timer);
-                reject(new Error(`[EmbeddingClient] GET ${path20} response error: ${err.message}`));
+                reject(new Error(`[EmbeddingClient] GET ${path21} response error: ${err.message}`));
               });
             }
           );
@@ -6262,12 +6271,12 @@ var init_embedding_client = __esm({
             if (resolved) return;
             resolved = true;
             clearTimeout(timer);
-            reject(new Error(`[EmbeddingClient] GET ${path20} request error: ${err.message}`));
+            reject(new Error(`[EmbeddingClient] GET ${path21} request error: ${err.message}`));
           });
           req.end();
         });
       }
-      request(path20, data) {
+      request(path21, data) {
         return new Promise((resolve9, reject) => {
           const timeoutMs = 12e4;
           let resolved = false;
@@ -6276,7 +6285,7 @@ var init_embedding_client = __esm({
             if (!resolved) {
               resolved = true;
               req?.destroy();
-              reject(new Error(`[EmbeddingClient] POST ${path20} timed out after ${timeoutMs}ms`));
+              reject(new Error(`[EmbeddingClient] POST ${path21} timed out after ${timeoutMs}ms`));
             }
           }, timeoutMs);
           if (timer.unref) timer.unref();
@@ -6285,7 +6294,7 @@ var init_embedding_client = __esm({
             {
               hostname: "127.0.0.1",
               port: this.port,
-              path: path20,
+              path: path21,
               method: "POST",
               headers: {
                 "Content-Type": "application/json",
@@ -6311,14 +6320,14 @@ var init_embedding_client = __esm({
                     resolve9(parsed);
                   }
                 } catch (_e) {
-                  reject(new Error(`[EmbeddingClient] Failed to parse POST ${path20} response: ${collected.toString()}`));
+                  reject(new Error(`[EmbeddingClient] Failed to parse POST ${path21} response: ${collected.toString()}`));
                 }
               });
               res.on("error", (err) => {
                 if (resolved) return;
                 resolved = true;
                 clearTimeout(timer);
-                reject(new Error(`[EmbeddingClient] POST ${path20} response error: ${err.message}`));
+                reject(new Error(`[EmbeddingClient] POST ${path21} response error: ${err.message}`));
               });
             }
           );
@@ -6326,7 +6335,7 @@ var init_embedding_client = __esm({
             if (resolved) return;
             resolved = true;
             clearTimeout(timer);
-            reject(new Error(`[EmbeddingClient] POST ${path20} request error: ${err.message}`));
+            reject(new Error(`[EmbeddingClient] POST ${path21} request error: ${err.message}`));
           });
           req.write(body);
           req.end();
@@ -7779,9 +7788,9 @@ var init_store_operations = __esm({
 });
 
 // src/knowledge/store.ts
-import * as fs13 from "node:fs";
+import * as fs14 from "node:fs";
 import * as fsPromises from "node:fs/promises";
-import * as path15 from "node:path";
+import * as path16 from "node:path";
 function isLanceCommitConflict(err) {
   const msg2 = err instanceof Error ? err.message : String(err);
   return /commit conflict/i.test(msg2) || /too many concurrent writes/i.test(msg2) || msg2.includes("Version mismatch") || msg2.includes("Lock error") || msg2.includes("Commit error");
@@ -7843,7 +7852,7 @@ var init_store = __esm({
       constructor(options) {
         this.options = options;
         this.tableName = this.retrieval === "bm25" ? BM25_TABLE_NAME : "knowledge";
-        this.manifestPath = path15.join(this.options.dbDir, "store-manifest.json");
+        this.manifestPath = path16.join(this.options.dbDir, "store-manifest.json");
       }
       /** Normalized retrieval strategy: an unset option means the historical
        *  'vector' (hybrid) behavior, not bm25. Every mode check goes through this. */
@@ -7881,7 +7890,7 @@ var init_store = __esm({
       }
       async loadManifest() {
         try {
-          if (fs13.existsSync(this.manifestPath)) {
+          if (fs14.existsSync(this.manifestPath)) {
             const content = await fsPromises.readFile(this.manifestPath, "utf-8");
             const manifest = JSON.parse(content);
             const savedVectorTable = typeof manifest.activeTableName === "string" ? manifest.activeTableName : null;
@@ -7926,7 +7935,7 @@ var init_store = __esm({
           return true;
         } catch (err) {
           logger.warn("[store] Failed to save manifest:", err);
-          if (fs13.existsSync(tempPath)) {
+          if (fs14.existsSync(tempPath)) {
             try {
               await fsPromises.unlink(tempPath);
             } catch {
@@ -7958,8 +7967,8 @@ var init_store = __esm({
       async openInternal() {
         if (this.db) return;
         try {
-          if (!fs13.existsSync(this.options.dbDir)) {
-            fs13.mkdirSync(this.options.dbDir, { recursive: true });
+          if (!fs14.existsSync(this.options.dbDir)) {
+            fs14.mkdirSync(this.options.dbDir, { recursive: true, mode: 448 });
           }
           this.db = await (await getLancedb()).connect(this.options.dbDir);
           const tableNames = await this.db.tableNames();
@@ -8082,10 +8091,10 @@ var init_store = __esm({
           logger.warn(`[store] countRows failed before backup (continuing): ${err instanceof Error ? err.message : String(err)}`);
         }
         this.table = null;
-        const oldDir = path15.join(this.options.dbDir, `${this.tableName}.lance`);
-        const backupDir = path15.join(this.options.dbDir, `${backupTableName}.lance`);
+        const oldDir = path16.join(this.options.dbDir, `${this.tableName}.lance`);
+        const backupDir = path16.join(this.options.dbDir, `${backupTableName}.lance`);
         try {
-          if (fs13.existsSync(oldDir)) {
+          if (fs14.existsSync(oldDir)) {
             await fsPromises.rename(oldDir, backupDir);
             logger.info(`[store] Successfully backed up database directory to ${backupDir}`);
           }
@@ -8175,8 +8184,8 @@ var init_store = __esm({
           await this.db.dropTable(oldTableName);
           logger.info(`[store] Renaming ${tempTableName} to ${canonicalName}...`);
           try {
-            const tempDir = path15.join(this.options.dbDir, `${tempTableName}.lance`);
-            const canonicalDir = path15.join(this.options.dbDir, `${canonicalName}.lance`);
+            const tempDir = path16.join(this.options.dbDir, `${tempTableName}.lance`);
+            const canonicalDir = path16.join(this.options.dbDir, `${canonicalName}.lance`);
             await fsPromises.rename(tempDir, canonicalDir);
             this.tableName = canonicalName;
             if (await this.saveManifest()) {
@@ -8550,9 +8559,9 @@ var init_store = __esm({
             };
           });
           try {
-            const dir = path15.dirname(outputPath);
-            await fs13.promises.mkdir(dir, { recursive: true });
-            await fs13.promises.writeFile(outputPath, JSON.stringify(exportData), "utf-8");
+            const dir = path16.dirname(outputPath);
+            await fs14.promises.mkdir(dir, { recursive: true });
+            await fs14.promises.writeFile(outputPath, JSON.stringify(exportData), "utf-8");
             logger.info(`[store] Successfully exported ${exportData.length} entries to ${outputPath}`);
           } catch (err) {
             logger.error(`[store] Failed to export knowledge store for web:`, err);
@@ -8751,7 +8760,7 @@ var init_store = __esm({
             else if (name.includes("_migration_")) migrationDirs.push(name);
           }
           for (const name of migrationDirs) {
-            const fullPath = path15.join(this.options.dbDir, name);
+            const fullPath = path16.join(this.options.dbDir, name);
             logger.info(`[store] Removing orphaned migration temp directory: ${name}`);
             await fsPromises.rm(fullPath, { recursive: true, force: true, maxRetries: 5, retryDelay: 50 });
           }
@@ -8764,7 +8773,7 @@ var init_store = __esm({
             const backupCutoff = Math.trunc(Date.now() - ttlDays * 24 * 60 * 60 * 1e3);
             for (const { name, ts } of ranked.slice(0, -1)) {
               if (ts >= backupCutoff) continue;
-              const fullPath = path15.join(this.options.dbDir, name);
+              const fullPath = path16.join(this.options.dbDir, name);
               logger.info(`[store] Removing superseded backup directory: ${name}`);
               await fsPromises.rm(fullPath, { recursive: true, force: true, maxRetries: 5, retryDelay: 50 });
             }
@@ -8787,7 +8796,7 @@ var init_store = __esm({
           if (!Number.isNaN(parsed)) return parsed;
         }
         try {
-          const stat6 = await fsPromises.stat(path15.join(this.options.dbDir, name));
+          const stat6 = await fsPromises.stat(path16.join(this.options.dbDir, name));
           return stat6.mtimeMs;
         } catch {
           return 0;
@@ -9301,8 +9310,8 @@ var init_chunker = __esm({
 });
 
 // src/knowledge/index.ts
-import * as fs14 from "node:fs";
-import * as path16 from "node:path";
+import * as fs15 from "node:fs";
+import * as path17 from "node:path";
 function getMigrationStrategy(config) {
   const strategy = config.MIGRATION_STRATEGY;
   if (!strategy) return void 0;
@@ -9369,12 +9378,12 @@ async function createKnowledgeStoreComponents(embedderFactory, reconnectFactory,
 }
 async function forceDeleteKnowledgeStore(config, workspace) {
   const dbDir = getDbDir(config, workspace);
-  if (!fs14.existsSync(dbDir)) return;
+  if (!fs15.existsSync(dbDir)) return;
   let tableName = "knowledge";
-  const manifestPath = path16.join(dbDir, "store-manifest.json");
+  const manifestPath = path17.join(dbDir, "store-manifest.json");
   try {
-    if (fs14.existsSync(manifestPath)) {
-      const manifest = JSON.parse(fs14.readFileSync(manifestPath, "utf-8"));
+    if (fs15.existsSync(manifestPath)) {
+      const manifest = JSON.parse(fs15.readFileSync(manifestPath, "utf-8"));
       const key = config?.KNOWLEDGE_STORE_RETRIEVAL === "bm25" ? "activeBm25TableName" : "activeTableName";
       const saved = key === "activeBm25TableName" ? manifest.activeBm25TableName : manifest.activeTableName;
       if (saved) tableName = saved;
@@ -9382,10 +9391,10 @@ async function forceDeleteKnowledgeStore(config, workspace) {
   } catch (err) {
     logger.warn(`[knowledge] Failed to read manifest before forced delete, defaulting to table '${tableName}':`, err);
   }
-  const tableDir = path16.join(dbDir, `${tableName}.lance`);
-  if (!fs14.existsSync(tableDir)) return;
+  const tableDir = path17.join(dbDir, `${tableName}.lance`);
+  if (!fs15.existsSync(tableDir)) return;
   try {
-    fs14.rmSync(tableDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 50 });
+    fs15.rmSync(tableDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 50 });
     logger.info(`[knowledge] Corrupted table directory ${tableDir} forcefully deleted; will be recreated on next init.`);
   } catch (err) {
     logger.error(`[knowledge] Failed to forcefully delete table directory ${tableDir}:`, err);
@@ -9415,7 +9424,7 @@ var knowledge_store_service_exports = {};
 __export(knowledge_store_service_exports, {
   KnowledgeStoreService: () => KnowledgeStoreService
 });
-import * as path17 from "node:path";
+import * as path18 from "node:path";
 var KnowledgeStoreService;
 var init_knowledge_store_service = __esm({
   "src/infrastructure/knowledge-store-service.ts"() {
@@ -9518,7 +9527,7 @@ var init_knowledge_store_service = __esm({
             };
             const container = tryGetServiceContainerFromCtx(ctx);
             const pathConfig = await getService(ServiceNames.STATE_PATH_CONFIGURATION, void 0, container);
-            const lockPath = path17.join(pathConfig.getLockDirPath(), "knowledge-store-init.lock");
+            const lockPath = path18.join(pathConfig.getLockDirPath(), "knowledge-store-init.lock");
             if (!this._initLock) {
               const processLifecycle = await getService(ServiceNames.PROCESS_LIFECYCLE, void 0, container);
               this._initLock = new FileLockService({
@@ -9529,12 +9538,12 @@ var init_knowledge_store_service = __esm({
                 // liveOwnerStaleThreshold (120s default) that actually governs when a
                 // provably-alive holder's lock may be physically reclaimed. This lock
                 // protects a post-run FTS rebuild plus optimize with no fixed duration; if
-                // that holder has a stretch of non-yielding synchronous work (a single
-                // large better-sqlite3 call blocks the event loop for its full duration,
-                // during which the heartbeat literally cannot fire) longer than 20s, a
-                // waiting caller would abandon and throw "no sign of progress from its
-                // holder" against a holder that was never actually wedged — up to 100s
-                // before the lock would even become reclaim-eligible. Raised to match
+                // that holder has a stretch of non-yielding synchronous work longer than
+                // 20s (a single large native call — the FTS rebuild or optimize — blocks the
+                // event loop for its full duration, during which the heartbeat literally
+                // cannot fire), a waiting caller would abandon and throw "no sign of
+                // progress from its holder" against a holder that was never actually
+                // wedged — up to 100s before the lock would even become reclaim-eligible. Raised to match
                 // liveOwnerStaleThreshold's own default so a live holder is given the same
                 // grace period here that the reclaim logic itself already grants it.
                 lockTimeout: 12e4,
@@ -10672,20 +10681,20 @@ __export(skill_installer_exports, {
   uninstallSkill: () => uninstallSkill
 });
 import * as crypto10 from "node:crypto";
-import * as fs16 from "node:fs";
-import * as os6 from "node:os";
-import * as path18 from "node:path";
+import * as fs17 from "node:fs";
+import * as os7 from "node:os";
+import * as path19 from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 function readSkillVersion(sourceDir) {
   try {
-    const md = fs16.readFileSync(path18.join(sourceDir, "SKILL.md"), "utf-8");
+    const md = fs17.readFileSync(path19.join(sourceDir, "SKILL.md"), "utf-8");
     return /"version"\s*:\s*"([^"]+)"/.exec(md)?.[1] ?? null;
   } catch {
     return null;
   }
 }
 function homeDir(opts) {
-  return opts?.home ?? os6.homedir();
+  return opts?.home ?? os7.homedir();
 }
 function resolveSkillSourceDir(explicit) {
   const candidates = [];
@@ -10693,7 +10702,7 @@ function resolveSkillSourceDir(explicit) {
   if (process.env["PI_RESEARCH_SKILL_DIR"]) candidates.push(process.env["PI_RESEARCH_SKILL_DIR"]);
   const fromHere = (() => {
     try {
-      return path18.dirname(fileURLToPath5(import.meta.url));
+      return path19.dirname(fileURLToPath5(import.meta.url));
     } catch {
       return void 0;
     }
@@ -10702,29 +10711,29 @@ function resolveSkillSourceDir(explicit) {
     if (!start) continue;
     let dir = start;
     for (let i = 0; i < 8; i++) {
-      candidates.push(path18.join(dir, SKILL_SOURCE_DIR, SKILL_NAME));
-      candidates.push(path18.join(dir, LEGACY_SKILL_SOURCE_DIR, SKILL_NAME));
-      const parent = path18.dirname(dir);
+      candidates.push(path19.join(dir, SKILL_SOURCE_DIR, SKILL_NAME));
+      candidates.push(path19.join(dir, LEGACY_SKILL_SOURCE_DIR, SKILL_NAME));
+      const parent = path19.dirname(dir);
       if (parent === dir) break;
       dir = parent;
     }
   }
   for (const c of candidates) {
     try {
-      if (fs16.existsSync(path18.join(c, "SKILL.md"))) return path18.resolve(c);
+      if (fs17.existsSync(path19.join(c, "SKILL.md"))) return path19.resolve(c);
     } catch {
     }
   }
   throw new Error("Could not locate the bundled research skill (agent-skill/pi-research/SKILL.md). Set PI_RESEARCH_SKILL_DIR to its path.");
 }
 function getManifestPath(opts) {
-  return path18.join(homeDir(opts), ".pi", "research", "installed-skills.json");
+  return path19.join(homeDir(opts), ".pi", "research", "installed-skills.json");
 }
 function readManifest(opts) {
   const p = getManifestPath(opts);
   try {
-    if (fs16.existsSync(p)) {
-      const parsed = JSON.parse(fs16.readFileSync(p, "utf-8"));
+    if (fs17.existsSync(p)) {
+      const parsed = JSON.parse(fs17.readFileSync(p, "utf-8"));
       if (parsed && Array.isArray(parsed.entries)) {
         return { version: 1, package: PACKAGE_NAME, entries: parsed.entries };
       }
@@ -10735,14 +10744,14 @@ function readManifest(opts) {
 }
 function writeManifest(manifest, opts) {
   const p = getManifestPath(opts);
-  fs16.mkdirSync(path18.dirname(p), { recursive: true });
+  fs17.mkdirSync(path19.dirname(p), { recursive: true });
   const tmp = `${p}.tmp.${process.pid}.${Date.now()}.${manifestTmpSeq++}`;
-  fs16.writeFileSync(tmp, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+  fs17.writeFileSync(tmp, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
   try {
-    fs16.renameSync(tmp, p);
+    fs17.renameSync(tmp, p);
   } catch (err) {
     try {
-      fs16.unlinkSync(tmp);
+      fs17.unlinkSync(tmp);
     } catch {
     }
     throw err;
@@ -10755,10 +10764,10 @@ function upsertEntry(manifest, entry) {
 }
 function isOwnedSymlink(targetPath, expectedSource) {
   try {
-    const st = fs16.lstatSync(targetPath);
+    const st = fs17.lstatSync(targetPath);
     if (!st.isSymbolicLink()) return false;
-    const dest = path18.resolve(path18.dirname(targetPath), fs16.readlinkSync(targetPath));
-    if (expectedSource && path18.resolve(expectedSource) === dest) return true;
+    const dest = path19.resolve(path19.dirname(targetPath), fs17.readlinkSync(targetPath));
+    if (expectedSource && path19.resolve(expectedSource) === dest) return true;
     return OWNED_SYMLINK_DEST.test(dest);
   } catch {
     return false;
@@ -10766,7 +10775,7 @@ function isOwnedSymlink(targetPath, expectedSource) {
 }
 function isOwnedCopy(targetPath) {
   try {
-    const md = fs16.readFileSync(path18.join(targetPath, "SKILL.md"), "utf-8");
+    const md = fs17.readFileSync(path19.join(targetPath, "SKILL.md"), "utf-8");
     return md.includes(PACKAGE_NAME);
   } catch {
     return false;
@@ -10775,16 +10784,16 @@ function isOwnedCopy(targetPath) {
 function detectHarnesses(opts) {
   const home = homeDir(opts);
   return HARNESSES.map((h) => {
-    const absSkillsDir = path18.join(home, h.skillsDir);
-    const absSkillPath = path18.join(absSkillsDir, SKILL_NAME);
+    const absSkillsDir = path19.join(home, h.skillsDir);
+    const absSkillPath = path19.join(absSkillsDir, SKILL_NAME);
     let present = false;
     try {
-      present = fs16.existsSync(path18.join(home, h.baseDir));
+      present = fs17.existsSync(path19.join(home, h.baseDir));
     } catch {
     }
     let installed = "none";
     try {
-      if (fs16.existsSync(absSkillPath) || isSymlinkPresent(absSkillPath)) {
+      if (fs17.existsSync(absSkillPath) || isSymlinkPresent(absSkillPath)) {
         if (isOwnedSymlink(absSkillPath)) installed = "owned-symlink";
         else if (isOwnedCopy(absSkillPath)) installed = "owned-copy";
         else installed = "foreign";
@@ -10797,14 +10806,14 @@ function detectHarnesses(opts) {
 }
 function isUsableSkillDir(p) {
   try {
-    return fs16.existsSync(path18.join(p, "SKILL.md")) && fs16.existsSync(path18.join(p, "scripts", "run.mjs"));
+    return fs17.existsSync(path19.join(p, "SKILL.md")) && fs17.existsSync(path19.join(p, "scripts", "run.mjs"));
   } catch {
     return false;
   }
 }
 function isSymlinkPresent(p) {
   try {
-    return fs16.lstatSync(p).isSymbolicLink();
+    return fs17.lstatSync(p).isSymbolicLink();
   } catch {
     return false;
   }
@@ -10828,22 +10837,22 @@ function installSkill(toolIds, opts = {}) {
       results.push({ tool: id, path: "", type: "symlink", status: "error", message: `unknown target "${id}"` });
       continue;
     }
-    const absSkillsDir = path18.join(home, def.skillsDir);
-    const absSkillPath = path18.join(absSkillsDir, SKILL_NAME);
+    const absSkillsDir = path19.join(home, def.skillsDir);
+    const absSkillPath = path19.join(absSkillsDir, SKILL_NAME);
     const type = opts.copy ? "copy" : "symlink";
     if (isOwnedSymlink(absSkillPath, source) || isOwnedCopy(absSkillPath)) {
       try {
-        const lst = fs16.lstatSync(absSkillPath);
+        const lst = fs17.lstatSync(absSkillPath);
         if (lst.isSymbolicLink()) {
-          const dest = path18.resolve(path18.dirname(absSkillPath), fs16.readlinkSync(absSkillPath));
-          if (dest !== path18.resolve(source)) {
+          const dest = path19.resolve(path19.dirname(absSkillPath), fs17.readlinkSync(absSkillPath));
+          if (dest !== path19.resolve(source)) {
             if (opts.dryRun) {
               results.push({ tool: id, path: absSkillPath, type: "symlink", status: "planned", message: "would re-point stale symlink to current source" });
               continue;
             }
-            fs16.unlinkSync(absSkillPath);
+            fs17.unlinkSync(absSkillPath);
             try {
-              fs16.symlinkSync(source, absSkillPath, process.platform === "win32" ? "junction" : "dir");
+              fs17.symlinkSync(source, absSkillPath, process.platform === "win32" ? "junction" : "dir");
               upsertEntry(manifest, { tool: id, path: absSkillPath, type: "symlink", source, createdAt: now, ...skillVersion ? { version: skillVersion } : {} });
               results.push({ tool: id, path: absSkillPath, type: "symlink", status: "installed", message: "re-pointed stale symlink to current source" });
             } catch (relinkErr) {
@@ -10869,7 +10878,7 @@ function installSkill(toolIds, opts = {}) {
       }
       continue;
     }
-    if (fs16.existsSync(absSkillPath) || isSymlinkPresent(absSkillPath)) {
+    if (fs17.existsSync(absSkillPath) || isSymlinkPresent(absSkillPath)) {
       results.push({ tool: id, path: absSkillPath, type, status: "skipped-foreign", message: 'a non-pi-research "research" skill already exists here; left untouched' });
       continue;
     }
@@ -10878,10 +10887,10 @@ function installSkill(toolIds, opts = {}) {
       continue;
     }
     try {
-      fs16.mkdirSync(absSkillsDir, { recursive: true });
+      fs17.mkdirSync(absSkillsDir, { recursive: true });
       if (type === "symlink") {
         try {
-          fs16.symlinkSync(source, absSkillPath, process.platform === "win32" ? "junction" : "dir");
+          fs17.symlinkSync(source, absSkillPath, process.platform === "win32" ? "junction" : "dir");
         } catch (err) {
           copyDir(source, absSkillPath);
           upsertEntry(manifest, { tool: id, path: absSkillPath, type: "copy", source, createdAt: now, ...skillVersion ? { version: skillVersion } : {} });
@@ -10918,7 +10927,7 @@ function uninstallSkill(toolIds, opts = {}) {
       continue;
     }
     const owned = isOwnedSymlink(skillPath) || isOwnedCopy(skillPath);
-    const present = fs16.existsSync(skillPath) || isSymlinkPresent(skillPath);
+    const present = fs17.existsSync(skillPath) || isSymlinkPresent(skillPath);
     if (!present) {
       results.push({ tool, path: skillPath, status: "not-present" });
       continue;
@@ -10936,8 +10945,8 @@ function uninstallSkill(toolIds, opts = {}) {
       continue;
     }
     try {
-      if (isSymlinkPresent(skillPath)) fs16.unlinkSync(skillPath);
-      else fs16.rmSync(skillPath, { recursive: true, force: true, maxRetries: 5, retryDelay: 50 });
+      if (isSymlinkPresent(skillPath)) fs17.unlinkSync(skillPath);
+      else fs17.rmSync(skillPath, { recursive: true, force: true, maxRetries: 5, retryDelay: 50 });
       results.push({ tool, path: skillPath, status: "removed" });
     } catch (err) {
       results.push({ tool, path: skillPath, status: "error", message: err?.message ?? String(err) });
@@ -10950,7 +10959,7 @@ function uninstallSkill(toolIds, opts = {}) {
       writeManifest({ version: 1, package: PACKAGE_NAME, entries: keep }, opts);
     } else {
       try {
-        fs16.rmSync(getManifestPath(opts));
+        fs17.rmSync(getManifestPath(opts));
       } catch {
       }
     }
@@ -10972,56 +10981,56 @@ function reconcileSkillInstalls(opts = {}) {
   for (const e of manifest.entries) {
     if (e.type !== "symlink") {
       const stale = currentVersion !== null && e.version !== currentVersion;
-      if (stale && source !== null && fs16.existsSync(e.path) && isOwnedCopy(e.path)) {
-        const dir2 = path18.dirname(e.path);
-        const base2 = path18.basename(e.path);
+      if (stale && source !== null && fs17.existsSync(e.path) && isOwnedCopy(e.path)) {
+        const dir2 = path19.dirname(e.path);
+        const base2 = path19.basename(e.path);
         try {
-          for (const name of fs16.readdirSync(dir2)) {
+          for (const name of fs17.readdirSync(dir2)) {
             if (name.startsWith(`.${base2}.new-`) || name.startsWith(`.${base2}.old-`)) {
-              fs16.rmSync(path18.join(dir2, name), { recursive: true, force: true });
+              fs17.rmSync(path19.join(dir2, name), { recursive: true, force: true });
             }
           }
         } catch {
         }
         const suffix = crypto10.randomBytes(4).toString("hex");
-        const fresh = path18.join(dir2, `.${base2}.new-${suffix}`);
-        const retired = path18.join(dir2, `.${base2}.old-${suffix}`);
+        const fresh = path19.join(dir2, `.${base2}.new-${suffix}`);
+        const retired = path19.join(dir2, `.${base2}.old-${suffix}`);
         try {
           copyDir(source, fresh);
         } catch {
           try {
-            fs16.rmSync(fresh, { recursive: true, force: true });
+            fs17.rmSync(fresh, { recursive: true, force: true });
           } catch {
           }
           keep.push(e);
           continue;
         }
         try {
-          fs16.renameSync(e.path, retired);
+          fs17.renameSync(e.path, retired);
         } catch {
           try {
-            fs16.rmSync(fresh, { recursive: true, force: true });
+            fs17.rmSync(fresh, { recursive: true, force: true });
           } catch {
           }
           keep.push(e);
           continue;
         }
         try {
-          fs16.renameSync(fresh, e.path);
+          fs17.renameSync(fresh, e.path);
         } catch {
           try {
-            fs16.renameSync(retired, e.path);
+            fs17.renameSync(retired, e.path);
           } catch {
           }
           try {
-            fs16.rmSync(fresh, { recursive: true, force: true });
+            fs17.rmSync(fresh, { recursive: true, force: true });
           } catch {
           }
           keep.push(e);
           continue;
         }
         try {
-          fs16.rmSync(retired, { recursive: true, force: true, maxRetries: 5, retryDelay: 50 });
+          fs17.rmSync(retired, { recursive: true, force: true, maxRetries: 5, retryDelay: 50 });
         } catch {
         }
         keep.push({ ...e, source, version: currentVersion });
@@ -11031,12 +11040,12 @@ function reconcileSkillInstalls(opts = {}) {
       }
       continue;
     }
-    const dir = path18.dirname(e.path);
-    const base = path18.basename(e.path);
+    const dir = path19.dirname(e.path);
+    const base = path19.basename(e.path);
     try {
-      for (const name of fs16.readdirSync(dir)) {
+      for (const name of fs17.readdirSync(dir)) {
         if (name.startsWith(`.${base}.new-`)) {
-          fs16.rmSync(path18.join(dir, name), { recursive: true, force: true });
+          fs17.rmSync(path19.join(dir, name), { recursive: true, force: true });
         }
       }
     } catch {
@@ -11049,30 +11058,30 @@ function reconcileSkillInstalls(opts = {}) {
       keep.push(e);
       continue;
     }
-    const targetLive = fs16.existsSync(e.path) && isUsableSkillDir(e.path);
+    const targetLive = fs17.existsSync(e.path) && isUsableSkillDir(e.path);
     if (!targetLive) {
       if (source !== null) {
         try {
-          fs16.unlinkSync(e.path);
+          fs17.unlinkSync(e.path);
         } catch {
           keep.push(e);
           continue;
         }
         try {
-          fs16.symlinkSync(source, e.path, process.platform === "win32" ? "junction" : "dir");
+          fs17.symlinkSync(source, e.path, process.platform === "win32" ? "junction" : "dir");
           keep.push({ ...e, type: "symlink", source });
           result.repointed.push(e.path);
         } catch {
           const suffix = crypto10.randomBytes(4).toString("hex");
-          const fresh = path18.join(dir, `.${base}.new-${suffix}`);
+          const fresh = path19.join(dir, `.${base}.new-${suffix}`);
           try {
             copyDir(source, fresh);
-            fs16.renameSync(fresh, e.path);
+            fs17.renameSync(fresh, e.path);
             keep.push({ ...e, type: "copy", source });
             result.repointed.push(e.path);
           } catch {
             try {
-              fs16.rmSync(fresh, { recursive: true, force: true });
+              fs17.rmSync(fresh, { recursive: true, force: true });
             } catch {
             }
             result.pruned.push(e.path);
@@ -11080,7 +11089,7 @@ function reconcileSkillInstalls(opts = {}) {
         }
       } else if (!targetLive) {
         try {
-          fs16.unlinkSync(e.path);
+          fs17.unlinkSync(e.path);
           result.pruned.push(e.path);
         } catch {
           keep.push(e);
@@ -11095,21 +11104,21 @@ function reconcileSkillInstalls(opts = {}) {
   if (keep.length > 0) writeManifest({ version: 1, package: PACKAGE_NAME, entries: keep }, opts);
   else {
     try {
-      fs16.rmSync(getManifestPath(opts));
+      fs17.rmSync(getManifestPath(opts));
     } catch {
     }
   }
   return result;
 }
 function copyDir(src, dest) {
-  const st = fs16.statSync(src);
+  const st = fs17.statSync(src);
   if (st.isDirectory()) {
-    fs16.mkdirSync(dest, { recursive: true });
-    for (const name of fs16.readdirSync(src)) {
-      copyDir(path18.join(src, name), path18.join(dest, name));
+    fs17.mkdirSync(dest, { recursive: true });
+    for (const name of fs17.readdirSync(src)) {
+      copyDir(path19.join(src, name), path19.join(dest, name));
     }
   } else {
-    fs16.copyFileSync(src, dest);
+    fs17.copyFileSync(src, dest);
   }
 }
 var HARNESSES, SKILL_NAME, PACKAGE_NAME, SKILL_SOURCE_DIR, LEGACY_SKILL_SOURCE_DIR, OWNED_SYMLINK_DEST, SKILL_AGENT_TARGETS, manifestTmpSeq, isTarget;
@@ -11117,15 +11126,15 @@ var init_skill_installer = __esm({
   "src/skill-install/skill-installer.ts"() {
     "use strict";
     HARNESSES = [
-      { id: "claude", label: "Claude", baseDir: ".claude", skillsDir: path18.join(".claude", "skills"), confidence: "confirmed" },
-      { id: "openclaw", label: "OpenClaw", baseDir: ".openclaw", skillsDir: path18.join(".openclaw", "skills"), confidence: "confirmed", note: "OpenClaw reads ~/.openclaw/skills as a managed skill root and accepts symlinked skill folders (docs.openclaw.ai/tools/skills)." },
+      { id: "claude", label: "Claude", baseDir: ".claude", skillsDir: path19.join(".claude", "skills"), confidence: "confirmed" },
+      { id: "openclaw", label: "OpenClaw", baseDir: ".openclaw", skillsDir: path19.join(".openclaw", "skills"), confidence: "confirmed", note: "OpenClaw reads ~/.openclaw/skills as a managed skill root and accepts symlinked skill folders (docs.openclaw.ai/tools/skills)." },
       // pi's own skill root is under its agent dir (~/.pi/agent/skills), NOT ~/.pi/skills.
       // Listed for DETECTION only — pi is never an install target (see SKILL_AGENT_TARGETS):
       // the host already exposes research as a native tool, so a skill there would just
       // duplicate it through a slower subprocess.
-      { id: "pi", label: "pi", baseDir: ".pi", skillsDir: path18.join(".pi", "agent", "skills"), confidence: "confirmed" },
-      { id: "codex", label: "OpenAI Codex CLI", baseDir: ".codex", skillsDir: path18.join(".codex", "skills"), confidence: "unverified", note: "Codex skills support is emerging; path not confirmed by official docs." },
-      { id: "agents", label: "Cross-tool (~/.agents/skills)", baseDir: ".agents", skillsDir: path18.join(".agents", "skills"), confidence: "unverified", note: "Proposed Universal Agents convention; not yet a ratified standard." }
+      { id: "pi", label: "pi", baseDir: ".pi", skillsDir: path19.join(".pi", "agent", "skills"), confidence: "confirmed" },
+      { id: "codex", label: "OpenAI Codex CLI", baseDir: ".codex", skillsDir: path19.join(".codex", "skills"), confidence: "unverified", note: "Codex skills support is emerging; path not confirmed by official docs." },
+      { id: "agents", label: "Cross-tool (~/.agents/skills)", baseDir: ".agents", skillsDir: path19.join(".agents", "skills"), confidence: "unverified", note: "Proposed Universal Agents convention; not yet a ratified standard." }
     ];
     SKILL_NAME = "pi-research";
     PACKAGE_NAME = "@lincoln504/pi-research";
@@ -11141,9 +11150,9 @@ var init_skill_installer = __esm({
 });
 
 // src/cli.ts
-import * as fs17 from "node:fs";
-import * as os7 from "node:os";
-import * as path19 from "node:path";
+import * as fs18 from "node:fs";
+import * as os8 from "node:os";
+import * as path20 from "node:path";
 import { spawnSync } from "node:child_process";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 
@@ -12902,47 +12911,315 @@ init_service_interfaces();
 init_file_lock_service();
 import * as crypto6 from "node:crypto";
 import * as net2 from "node:net";
-import * as path10 from "node:path";
+import * as path11 from "node:path";
 
 // src/infrastructure/browser/config.ts
-init_config();
-init_logger();
 import * as crypto4 from "node:crypto";
-import { join as join8 } from "node:path";
-import { existsSync as existsSync6, mkdirSync as mkdirSync3 } from "node:fs";
-import { platform, homedir as homedir3 } from "node:os";
+import { join as join9 } from "node:path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync3 } from "node:fs";
+import { platform, homedir as homedir4 } from "node:os";
+
+// src/infrastructure/browser/camoufox-layout.ts
+import * as fs8 from "node:fs";
+import * as os4 from "node:os";
+import * as path10 from "node:path";
 import { createRequire as createRequire4 } from "node:module";
-function getWindowsCamoufoxDir() {
-  return join8(homedir3(), "AppData", "Local", "camoufox", "camoufox", "Cache");
+var COMPAT_FLAG = ".0.5_FLAG";
+var LEGACY_MARKERS = ["camoufox-bin", "camoufox", "camoufox.exe", "application.ini", "Camoufox.app", "properties.json"];
+function isDir(p) {
+  try {
+    return fs8.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
 }
-function getCustomCamoufoxDir() {
-  return process.env["CAMOUFOX_INSTALL_DIR"] || process.env["PLAYWRIGHT_BROWSERS_PATH"] || void 0;
+function isFile(p) {
+  try {
+    return fs8.statSync(p).isFile();
+  } catch {
+    return false;
+  }
 }
-function getBrowserCacheDir() {
-  const custom = getCustomCamoufoxDir();
-  if (custom) {
-    return custom;
+function customDir(env = process.env) {
+  return env["CAMOUFOX_INSTALL_DIR"] || env["PLAYWRIGHT_BROWSERS_PATH"] || null;
+}
+function defaultInstallDir(env = process.env, platform5 = process.platform, home = os4.homedir()) {
+  if (platform5 === "win32") {
+    const base = env["LOCALAPPDATA"] && path10.win32.isAbsolute(env["LOCALAPPDATA"]) ? env["LOCALAPPDATA"] : path10.join(home, "AppData", "Local");
+    return path10.join(base, "camoufox", "camoufox", "Cache");
   }
-  const osPlatform = platform();
-  if (osPlatform === "win32") {
-    return getWindowsCamoufoxDir();
-  } else if (osPlatform === "darwin") {
-    return join8(homedir3(), "Library", "Caches", "camoufox");
+  if (platform5 === "darwin") return path10.join(home, "Library", "Caches", "camoufox");
+  const xdg = (env["XDG_CACHE_HOME"] || "").trim();
+  return path10.join(xdg ? xdg : path10.join(home, ".cache"), "camoufox");
+}
+function resolveInstall(env = process.env, platform5 = process.platform, home = os4.homedir()) {
+  const custom = customDir(env);
+  if (!custom) return { dir: defaultInstallDir(env, platform5, home), overrides: {}, custom: null, ignoredCustom: false };
+  if (platform5 === "darwin") {
+    return { dir: defaultInstallDir(env, platform5, home), overrides: {}, custom, ignoredCustom: true };
+  }
+  const resolved = (platform5 === "win32" ? path10.win32 : path10).resolve(custom);
+  if (platform5 === "win32") {
+    const overrides2 = { LOCALAPPDATA: resolved };
+    return { dir: defaultInstallDir({ ...env, ...overrides2 }, platform5, home), overrides: overrides2, custom, ignoredCustom: false };
+  }
+  const endsInCamoufox = path10.basename(resolved).toLowerCase() === "camoufox";
+  const cacheHome = endsInCamoufox ? path10.dirname(resolved) : resolved;
+  const overrides = { XDG_CACHE_HOME: cacheHome };
+  return { dir: defaultInstallDir({ ...env, ...overrides }, platform5, home), overrides, custom, ignoredCustom: false };
+}
+function listInstalls(dir) {
+  const out = [];
+  const browsers = path10.join(dir, "browsers");
+  let repos;
+  try {
+    repos = fs8.readdirSync(browsers, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const repo of repos) {
+    if (!repo.isDirectory() || repo.name.startsWith(".")) continue;
+    const repoDir = path10.join(browsers, repo.name);
+    let versions;
+    try {
+      versions = fs8.readdirSync(repoDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const v of versions) {
+      if (!v.isDirectory()) continue;
+      const vdir = path10.join(repoDir, v.name);
+      let meta;
+      try {
+        meta = JSON.parse(fs8.readFileSync(path10.join(vdir, "version.json"), "utf8"));
+      } catch {
+        continue;
+      }
+      out.push({
+        repo: repo.name,
+        name: v.name,
+        path: vdir,
+        rel: `browsers/${repo.name}/${v.name}`,
+        version: meta && typeof meta.version === "string" ? meta.version : "",
+        build: meta && typeof meta.build === "string" ? meta.build : ""
+      });
+    }
+  }
+  return out;
+}
+function hasInstall(dir) {
+  return listInstalls(dir).length > 0;
+}
+function isLegacyFlat(dir) {
+  if (!isDir(dir) || isFile(path10.join(dir, COMPAT_FLAG))) return false;
+  let meta;
+  try {
+    meta = JSON.parse(fs8.readFileSync(path10.join(dir, "version.json"), "utf8"));
+  } catch {
+    return false;
+  }
+  if (!meta || typeof meta.version !== "string" || typeof meta.release !== "string") return false;
+  return LEGACY_MARKERS.some((m) => fs8.existsSync(path10.join(dir, m)));
+}
+function hasExplicitChoice(dir) {
+  try {
+    const cfg = JSON.parse(fs8.readFileSync(path10.join(dir, "config.json"), "utf8"));
+    return Boolean(cfg && (cfg.pinned || cfg.channel));
+  } catch {
+    return false;
+  }
+}
+function loadPin(packageRoot) {
+  try {
+    const data = JSON.parse(fs8.readFileSync(path10.join(packageRoot, "dist", "data-files", "browser-pin.json"), "utf8"));
+    if (!data || !data.tag) return null;
+    return { repoName: String(data.repo_name).toLowerCase(), version: String(data.version), build: String(data.build) };
+  } catch {
+    return null;
+  }
+}
+function findPackageRoot(fromUrl) {
+  try {
+    const require2 = createRequire4(fromUrl);
+    return path10.dirname(require2.resolve("@camoufox/camoufox/package.json"));
+  } catch {
+    return null;
+  }
+}
+function matchesPin(build, pin) {
+  return build.repo.toLowerCase() === pin.repoName && build.version === pin.version && build.build === pin.build;
+}
+function pruneSuperseded(dir, log = () => {
+}, pin = null) {
+  if (hasExplicitChoice(dir)) return [];
+  const installs = listInstalls(dir);
+  let keep = null;
+  if (pin) {
+    const paired = installs.find((i) => matchesPin(i, pin));
+    keep = paired ? paired.rel : null;
   } else {
-    const cacheHome = process.env["XDG_CACHE_HOME"] || join8(homedir3(), ".cache");
-    return join8(cacheHome, "camoufox");
+    try {
+      keep = JSON.parse(fs8.readFileSync(path10.join(dir, "config.json"), "utf8")).active_version || null;
+    } catch {
+      return [];
+    }
+  }
+  if (!keep || !installs.some((i) => i.rel === keep)) return [];
+  const removed = [];
+  for (const i of installs) {
+    if (i.rel === keep) continue;
+    try {
+      fs8.rmSync(i.path, { recursive: true, force: true });
+      removed.push(i.rel);
+      log(`pi-research: removed superseded Camoufox build ${i.rel}`);
+    } catch (e) {
+      log(`pi-research: could not remove superseded Camoufox build ${i.rel}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+  try {
+    for (const r of fs8.readdirSync(path10.join(dir, "browsers"))) {
+      const rd = path10.join(dir, "browsers", r);
+      if (isDir(rd) && fs8.readdirSync(rd).length === 0) fs8.rmdirSync(rd);
+    }
+  } catch {
+  }
+  return removed;
+}
+function stashLegacy(dir) {
+  if (!isLegacyFlat(dir)) return null;
+  const stash = `${dir}.legacy-${process.pid}-${Date.now()}`;
+  fs8.renameSync(dir, stash);
+  return stash;
+}
+function restoreLegacy(dir, stash) {
+  if (!stash || !fs8.existsSync(stash)) return;
+  try {
+    fs8.rmSync(dir, { recursive: true, force: true });
+  } catch {
+  }
+  fs8.renameSync(stash, dir);
+}
+function discardLegacy(stash) {
+  if (!stash) return;
+  fs8.rmSync(stash, { recursive: true, force: true });
+}
+function sweepStaleStashes(dir, log = () => {
+}) {
+  if (!hasInstall(dir)) return [];
+  const parent = path10.dirname(dir);
+  const prefix = `${path10.basename(dir)}.legacy-`;
+  const removed = [];
+  let entries;
+  try {
+    entries = fs8.readdirSync(parent);
+  } catch {
+    return removed;
+  }
+  for (const e of entries) {
+    if (!e.startsWith(prefix)) continue;
+    const p = path10.join(parent, e);
+    if (!isLegacyFlat(p)) continue;
+    try {
+      fs8.rmSync(p, { recursive: true, force: true });
+      removed.push(p);
+      log(`pi-research: removed leftover legacy Camoufox stash ${p}`);
+    } catch {
+    }
+  }
+  return removed;
+}
+function isUsable(dir, pin = null) {
+  if (!isFile(path10.join(dir, COMPAT_FLAG))) return false;
+  const installs = listInstalls(dir);
+  if (installs.length === 0) return false;
+  if (pin && !hasExplicitChoice(dir)) return installs.some((i) => matchesPin(i, pin));
+  return true;
+}
+function listStashes(dir) {
+  const parent = path10.dirname(dir);
+  const prefix = `${path10.basename(dir)}.legacy-`;
+  let entries;
+  try {
+    entries = fs8.readdirSync(parent);
+  } catch {
+    return [];
+  }
+  return entries.filter((e) => e.startsWith(prefix)).map((e) => path10.join(parent, e)).filter((p) => isLegacyFlat(p)).sort().reverse();
+}
+function recoverStash(dir, log = () => {
+}) {
+  let empty = !fs8.existsSync(dir);
+  if (!empty) {
+    try {
+      empty = isDir(dir) && fs8.readdirSync(dir).length === 0;
+    } catch {
+      return null;
+    }
+  }
+  if (!empty) return null;
+  const stash = listStashes(dir)[0];
+  if (!stash) return null;
+  try {
+    if (fs8.existsSync(dir)) fs8.rmdirSync(dir);
+    fs8.renameSync(stash, dir);
+    log(`pi-research: restored the previous Camoufox install from ${stash}`);
+    return stash;
+  } catch {
+    return null;
+  }
+}
+async function provisionBrowser(dir, fetch2, log = () => {
+}, pin = null) {
+  recoverStash(dir, log);
+  if (isUsable(dir, pin)) {
+    sweepStaleStashes(dir, log);
+    return { status: "present", pruned: pruneSuperseded(dir, log, pin) };
+  }
+  let stash;
+  try {
+    stash = stashLegacy(dir);
+  } catch (e) {
+    return { status: "failed", pruned: [], reason: `could not move the existing legacy install aside (${e instanceof Error ? e.message : String(e)}); left untouched` };
+  }
+  if (stash) log(`pi-research: legacy Camoufox install moved aside to ${stash} until the new browser is verified`);
+  let ok = false;
+  let reason;
+  try {
+    ok = await fetch2() === true;
+    if (!ok) reason = "camoufox fetch did not exit 0";
+  } catch (e) {
+    reason = e instanceof Error ? e.message : String(e);
+  }
+  if (isUsable(dir, pin)) {
+    discardLegacy(stash);
+    if (stash) log("pi-research: removed the legacy Camoufox install (replaced by the new build)");
+    if (!ok) log(`pi-research: camoufox fetch reported a failure after the browser was installed (${reason}); keeping it. Run "npx camoufox fetch" to retry the companion download (e.g. the geoip database).`);
+    sweepStaleStashes(dir, log);
+    return { status: "installed", pruned: pruneSuperseded(dir, log, pin) };
   }
+  if (ok) reason = "camoufox fetch exited 0 but no usable build was found";
+  restoreLegacy(dir, stash);
+  if (stash) log("pi-research: restored the previous Camoufox install after a failed upgrade");
+  return { status: "failed", pruned: [], reason };
+}
+
+// src/infrastructure/browser/config.ts
+init_config();
+init_logger();
+import { createRequire as createRequire5 } from "node:module";
+function getBrowserCacheDir() {
+  return resolveInstall(process.env, platform(), homedir4()).dir;
 }
 function getBrowserProfileDir(config) {
   const configured = (config || getConfig()).TMP_DIR;
   let dir;
   if (configured && configured.trim().length > 0) {
-    dir = join8(configured, "pi-research", "profiles");
+    dir = join9(configured, "pi-research", "profiles");
   } else {
-    const cacheHome = process.env["XDG_CACHE_HOME"] || join8(homedir3(), ".cache");
-    dir = join8(cacheHome, "pi-research", "profiles");
+    const cacheHome = process.env["XDG_CACHE_HOME"] || join9(homedir4(), ".cache");
+    dir = join9(cacheHome, "pi-research", "profiles");
   }
-  if (!existsSync6(dir)) {
+  if (!existsSync7(dir)) {
     try {
       mkdirSync3(dir, { recursive: true });
     } catch (_e) {
@@ -12952,14 +13229,10 @@ function getBrowserProfileDir(config) {
 }
 function getBrowserEnv(config) {
   const env = { ...process.env };
-  const customPath = getCustomCamoufoxDir();
-  if (customPath) {
-    env["PLAYWRIGHT_BROWSERS_PATH"] = customPath;
-    env["CAMOUFOX_INSTALL_DIR"] = customPath;
-  } else {
-    delete env["PLAYWRIGHT_BROWSERS_PATH"];
-    delete env["CAMOUFOX_INSTALL_DIR"];
-  }
+  const install = resolveInstall(process.env, platform(), homedir4());
+  Object.assign(env, install.overrides);
+  delete env["PLAYWRIGHT_BROWSERS_PATH"];
+  delete env["CAMOUFOX_INSTALL_DIR"];
   if (!env["PI_RESEARCH_LOG_FILE"]) {
     const logFilePath = getLogger().getLogFilePath();
     if (logFilePath) {
@@ -12979,7 +13252,7 @@ function getBrowserEnv(config) {
 }
 function ensureBrowserCacheDir() {
   const cacheDir = getBrowserCacheDir();
-  if (!existsSync6(cacheDir)) {
+  if (!existsSync7(cacheDir)) {
     try {
       mkdirSync3(cacheDir, { recursive: true });
     } catch (_e) {
@@ -12988,19 +13261,7 @@ function ensureBrowserCacheDir() {
   return cacheDir;
 }
 function getCamoufoxBinaryPath() {
-  const customPath = getCustomCamoufoxDir();
-  if (customPath) {
-    return customPath;
-  }
-  const osPlatform = platform();
-  if (osPlatform === "win32") {
-    return getWindowsCamoufoxDir();
-  } else if (osPlatform === "darwin") {
-    return join8(homedir3(), "Library", "Caches", "camoufox");
-  } else {
-    const cacheHome = process.env["XDG_CACHE_HOME"] || join8(homedir3(), ".cache");
-    return join8(cacheHome, "camoufox");
-  }
+  return getBrowserCacheDir();
 }
 function generateSchedulerVersion(config) {
   const c = config || getConfig();
@@ -13030,16 +13291,15 @@ function probeBrowserNativeDeps(load = defaultNativeDepLoad) {
   }
 }
 function defaultNativeDepLoad() {
-  const require2 = createRequire4(import.meta.url);
-  const Database = require2("better-sqlite3");
-  const db = new Database(":memory:");
-  db.close();
+  const require2 = createRequire5(import.meta.url);
+  require2("impit");
 }
 function isBrowserAvailable() {
   if (isFullMockMode()) return false;
   try {
-    import.meta.resolve("camoufox-js");
-    return existsSync6(getCamoufoxBinaryPath());
+    import.meta.resolve("@camoufox/camoufox");
+    const root = findPackageRoot(import.meta.url);
+    return isUsable(getCamoufoxBinaryPath(), root ? loadPin(root) : null);
   } catch {
     return false;
   }
@@ -13211,9 +13471,9 @@ var BrowserClient = class {
   get targetPort() {
     return this.port;
   }
-  async request(path20, data, signal, config) {
+  async request(path21, data, signal, config) {
     const start = Date.now();
-    const operation = path20.includes("/search") ? "search" : path20.includes("/scrape") ? "browser-task" : path20.includes("/healthcheck") ? "healthcheck" : "network";
+    const operation = path21.includes("/search") ? "search" : path21.includes("/scrape") ? "browser-task" : path21.includes("/healthcheck") ? "healthcheck" : "network";
     return new Promise((resolve9, reject) => {
       const agent = getClientAgent();
       const timeoutMs = resolveClientRequestTimeoutMs(operation, config);
@@ -13238,7 +13498,7 @@ var BrowserClient = class {
           resolved = true;
           abortCleanup?.();
           controller.abort();
-          const error = new Error(`[BrowserClient] Request to ${path20} timed out after ${timeoutMs}ms (Shared queue may be deep)`);
+          const error = new Error(`[BrowserClient] Request to ${path21} timed out after ${timeoutMs}ms (Shared queue may be deep)`);
           errorTracker.trackError(error, {
             component: "browser-manager",
             operation,
@@ -13251,7 +13511,7 @@ var BrowserClient = class {
       const req = http4.request({
         hostname: "127.0.0.1",
         port: this.port,
-        path: path20,
+        path: path21,
         method: "POST",
         agent,
         signal: controller.signal,
@@ -13275,7 +13535,7 @@ var BrowserClient = class {
               const error = new Error(
                 `Browser pool leader is draining (${parsed.reason || "leadership-lost"}) \u2014 re-elect and retry`
               );
-              logger.debug(`[BrowserClient] Leader draining on ${path20}; re-election required.`);
+              logger.debug(`[BrowserClient] Leader draining on ${path21}; re-election required.`);
               errorTracker.trackError(error, {
                 component: "browser-manager",
                 operation,
@@ -13291,7 +13551,7 @@ var BrowserClient = class {
               });
               reject(error);
             } else {
-              logger.debug(`[BrowserClient] Request ${path20} completed in ${duration}ms`);
+              logger.debug(`[BrowserClient] Request ${path21} completed in ${duration}ms`);
               resolve9(parsed);
             }
           } catch (_e) {
@@ -13311,7 +13571,7 @@ var BrowserClient = class {
           resolved = true;
           clearTimeout(timer);
           abortCleanup?.();
-          const error = new Error(`[BrowserClient] Response stream error on ${path20}: ${err.message}`);
+          const error = new Error(`[BrowserClient] Response stream error on ${path21}: ${err.message}`);
           errorTracker.trackError(error, {
             component: "browser-manager",
             operation,
@@ -13330,23 +13590,23 @@ var BrowserClient = class {
         let errorMsg;
         let errorType;
         if (nodeErr.code === "ECONNRESET" || nodeErr.code === "EPIPE") {
-          errorMsg = `Browser pool socket ${path20} closed (pool likely busy or restarting) - ${err.message}`;
+          errorMsg = `Browser pool socket ${path21} closed (pool likely busy or restarting) - ${err.message}`;
           errorType = "connection_reset";
         } else if (nodeErr.code === "ECONNREFUSED") {
-          errorMsg = `Browser pool ${path20} unreachable (server restarting or torn down) - ${err.message}`;
+          errorMsg = `Browser pool ${path21} unreachable (server restarting or torn down) - ${err.message}`;
           errorType = "connection_refused";
         } else if (nodeErr.code === "ETIMEDOUT") {
-          errorMsg = `Browser pool ${path20} timed out (slow browser response) - ${err.message}`;
+          errorMsg = `Browser pool ${path21} timed out (slow browser response) - ${err.message}`;
           errorType = "timeout";
         } else {
-          errorMsg = `Browser pool ${path20} error: ${err.message}`;
+          errorMsg = `Browser pool ${path21} error: ${err.message}`;
           errorType = "unknown";
         }
         const error = new Error(errorMsg);
         if (isTransientSocketError(error)) {
-          logger.debug(`[BrowserClient] Transient failure talking to http://127.0.0.1:${this.port}${path20} (caller will retry): ${errorMsg}`);
+          logger.debug(`[BrowserClient] Transient failure talking to http://127.0.0.1:${this.port}${path21} (caller will retry): ${errorMsg}`);
         } else {
-          logger.error(`[BrowserClient] Request to http://127.0.0.1:${this.port}${path20} failed:`, errorMsg);
+          logger.error(`[BrowserClient] Request to http://127.0.0.1:${this.port}${path21} failed:`, errorMsg);
           errorTracker.trackError(error, {
             component: "browser-manager",
             operation,
@@ -13598,17 +13858,17 @@ var BrowserServer = class {
 init_logger();
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
-import * as os4 from "node:os";
+import * as os5 from "node:os";
 var execAsync = promisify(exec);
 async function cleanupOrphanedCamoufoxProcesses() {
-  const platform4 = os4.platform();
+  const platform5 = os5.platform();
   try {
-    if (platform4 === "darwin" || platform4 === "linux") {
+    if (platform5 === "darwin" || platform5 === "linux") {
       await cleanupOrphanedProcessesUnix();
-    } else if (platform4 === "win32") {
+    } else if (platform5 === "win32") {
       await cleanupOrphanedProcessesWindows();
     } else {
-      logger.warn(`[BrowserCleanup] Platform ${platform4} not supported for orphan cleanup`);
+      logger.warn(`[BrowserCleanup] Platform ${platform5} not supported for orphan cleanup`);
     }
   } catch (error) {
     const msg2 = error instanceof Error ? error.message : String(error);
@@ -13735,11 +13995,11 @@ async function cleanupOrphanedProcessesWindows() {
   }
 }
 async function getBrowserPidsForWorkers(workerPids) {
-  const platform4 = os4.platform();
+  const platform5 = os5.platform();
   const pids = [];
   if (!workerPids || workerPids.length === 0) return pids;
   try {
-    if (platform4 === "darwin" || platform4 === "linux") {
+    if (platform5 === "darwin" || platform5 === "linux") {
       const { stdout } = await execAsync('ps -eo pid,ppid,comm | grep -E "(firefox|camoufox)" | grep -v grep').catch(() => ({ stdout: "" }));
       const lines = stdout.trim().split("\n");
       for (const line of lines) {
@@ -13750,7 +14010,7 @@ async function getBrowserPidsForWorkers(workerPids) {
           if (workerPids.includes(ppid)) pids.push(pid);
         }
       }
-    } else if (platform4 === "win32") {
+    } else if (platform5 === "win32") {
       const procs = await queryWindowsProcesses();
       for (const proc of procs) {
         if (!PI_BROWSER_MARKER.test(proc.commandLine)) continue;
@@ -13765,10 +14025,10 @@ async function getBrowserPidsForWorkers(workerPids) {
 }
 async function killBrowserProcesses(pids) {
   if (!pids || pids.length === 0) return;
-  const platform4 = os4.platform();
+  const platform5 = os5.platform();
   await Promise.all(pids.map(async (pid) => {
     try {
-      if (platform4 === "win32") {
+      if (platform5 === "win32") {
         await execAsync(`taskkill /PID ${pid} /F /T`);
         logger.debug(`[BrowserCleanup] Terminated worker browser process: PID ${pid}`);
       } else {
@@ -14499,7 +14759,7 @@ async function getBrowserInitLock(container) {
   if (lock) return lock;
   const pathConfig = await getService(ServiceNames.STATE_PATH_CONFIGURATION, void 0, container);
   const processLifecycle = await getService(ServiceNames.PROCESS_LIFECYCLE, void 0, container);
-  const lockFilePath = path10.join(pathConfig.getLockDirPath(), "browser-init.lock");
+  const lockFilePath = path11.join(pathConfig.getLockDirPath(), "browser-init.lock");
   lock = new FileLockService({
     lockFilePath,
     lockTimeout: 6e4,
@@ -14800,8 +15060,8 @@ init_config();
 init_logger();
 init_atomic_replace();
 init_metrics();
-import * as fs8 from "node:fs/promises";
-import * as path11 from "node:path";
+import * as fs9 from "node:fs/promises";
+import * as path12 from "node:path";
 import * as crypto7 from "node:crypto";
 import process2 from "node:process";
 
@@ -15039,12 +15299,12 @@ var StateManager = class {
     } = options;
     let stateDir = providedStateDir;
     if (!stateDir) {
-      stateDir = path11.join(getGlobalConfigDir(), "state");
+      stateDir = path12.join(getGlobalConfigDir(), "state");
     }
-    this.stateFilePath = path11.join(stateDir, "research-state.json");
-    this.lockDirPath = path11.join(stateDir, ".locks");
-    this.backupDirPath = path11.join(stateDir, "backups");
-    this.lockFilePath = path11.join(this.lockDirPath, "research-state.lock");
+    this.stateFilePath = path12.join(stateDir, "research-state.json");
+    this.lockDirPath = path12.join(stateDir, ".locks");
+    this.backupDirPath = path12.join(stateDir, "backups");
+    this.lockFilePath = path12.join(this.lockDirPath, "research-state.lock");
     this.fileLockService = fileLockService;
     this.processLifecycle = processLifecycle;
     this.gpuResourceService = gpuResourceService;
@@ -15059,13 +15319,13 @@ var StateManager = class {
    */
   async ensureDirectories() {
     const dirs = [
-      path11.dirname(this.stateFilePath),
+      path12.dirname(this.stateFilePath),
       this.lockDirPath,
       this.backupDirPath
     ];
     for (const dir of dirs) {
       try {
-        await fs8.mkdir(dir, { recursive: true, mode: 448 });
+        await fs9.mkdir(dir, { recursive: true, mode: 448 });
       } catch (err) {
         logger.error(`[StateManager] Failed to create directory ${dir}:`, err);
         throw err;
@@ -15092,17 +15352,17 @@ var StateManager = class {
     if (this.orphanTmpSwept) return;
     this.orphanTmpSwept = true;
     const STALE_TMP_MS = 5 * 60 * 1e3;
-    const stateDir = path11.dirname(this.stateFilePath);
+    const stateDir = path12.dirname(this.stateFilePath);
     const cutoff = Date.now() - STALE_TMP_MS;
     try {
-      const entries = await fs8.readdir(stateDir);
+      const entries = await fs9.readdir(stateDir);
       for (const entry of entries) {
         if (!entry.startsWith("research-state-") || !entry.endsWith(".tmp")) continue;
-        const filePath = path11.join(stateDir, entry);
+        const filePath = path12.join(stateDir, entry);
         try {
-          const stats = await fs8.stat(filePath);
+          const stats = await fs9.stat(filePath);
           if (!stats.isFile() || stats.mtimeMs >= cutoff) continue;
-          await fs8.unlink(filePath);
+          await fs9.unlink(filePath);
           logger.debug(`[StateManager] Removed orphaned state temp file: ${entry}`);
         } catch {
         }
@@ -15147,7 +15407,7 @@ var StateManager = class {
       return this.getDefaultState();
     }
     try {
-      const content = await fs8.readFile(this.stateFilePath, "utf-8");
+      const content = await fs9.readFile(this.stateFilePath, "utf-8");
       const state = JSON.parse(content);
       return this.validator.migrateAndValidate(state);
     } catch (error) {
@@ -15176,7 +15436,7 @@ var StateManager = class {
         );
         try {
           await this.recoverFromCorruptionDirect();
-          const recovered = await fs8.readFile(this.stateFilePath, "utf-8");
+          const recovered = await fs9.readFile(this.stateFilePath, "utf-8");
           return this.validator.migrateAndValidate(JSON.parse(recovered));
         } catch (recoveryError) {
           logger.error(
@@ -15235,9 +15495,9 @@ var StateManager = class {
         logger.warn(`[StateManager] Backup before write failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
       });
       const tempFileName = `research-state-${crypto7.randomBytes(16).toString("hex")}.tmp`;
-      tempFilePath = path11.join(path11.dirname(this.stateFilePath), tempFileName);
+      tempFilePath = path12.join(path12.dirname(this.stateFilePath), tempFileName);
       const content = JSON.stringify(state, null, 2);
-      const fh = await fs8.open(tempFilePath, "w", 384);
+      const fh = await fs9.open(tempFilePath, "w", 384);
       try {
         await fh.writeFile(content, { encoding: "utf-8" });
         await fh.sync();
@@ -15252,7 +15512,7 @@ var StateManager = class {
         metrics.increment("state_write_non_atomic_total", 1);
         const tmp = tempFilePath;
         tempFilePath = null;
-        await fs8.unlink(tmp).catch((err) => {
+        await fs9.unlink(tmp).catch((err) => {
           logger.warn("[StateManager] Failed to remove temp file after copy fallback (write succeeded):", err);
         });
       }
@@ -15262,7 +15522,7 @@ var StateManager = class {
       throw new Error(`Failed to write state: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
     } finally {
       if (tempFilePath) {
-        await fs8.unlink(tempFilePath).catch((err) => {
+        await fs9.unlink(tempFilePath).catch((err) => {
           logger.warn("[StateManager] Failed to clean up temp file:", err);
         });
       }
@@ -15681,7 +15941,7 @@ var MetricsService = class {
 // src/infrastructure/process-lifecycle-service.ts
 init_service_registry();
 init_service_names();
-import * as fs9 from "node:fs/promises";
+import * as fs10 from "node:fs/promises";
 import { execFile } from "node:child_process";
 function parseEtime(value) {
   const m = /^(?:(\d+)-)?(?:(\d+):)?(\d+):(\d+)$/.exec(value.trim());
@@ -15728,7 +15988,7 @@ var ProcessLifecycleService = class _ProcessLifecycleService {
   async getProcessStartTime(pid) {
     if (process.platform === "linux") {
       try {
-        const stat6 = await fs9.readFile(`/proc/${pid}/stat`, "utf8");
+        const stat6 = await fs10.readFile(`/proc/${pid}/stat`, "utf8");
         const lastParenIndex = stat6.lastIndexOf(")");
         if (lastParenIndex === -1) return null;
         const partsAfterName = stat6.substring(lastParenIndex + 2).trim().split(/\s+/);
@@ -16307,8 +16567,8 @@ var StateValidator = class {
     if (!Value4.Check(SingletonStateSchema, coerced)) {
       const errors = [...Value4.Errors(SingletonStateSchema, coerced)];
       const errorMsg = errors.map((e) => {
-        const path20 = String(e.path || "root");
-        return `${path20}: ${e.message} (${JSON.stringify(e.value)})`;
+        const path21 = String(e.path || "root");
+        return `${path21}: ${e.message} (${JSON.stringify(e.value)})`;
       }).join(", ");
       throw new Error(`Invalid state: ${errorMsg}`);
     }
@@ -16355,45 +16615,45 @@ var StateValidator = class {
 init_logger();
 init_metrics();
 init_config();
-import { dirname as dirname9, join as join13 } from "node:path";
-import { existsSync as existsSync8 } from "node:fs";
+import { dirname as dirname10, join as join14 } from "node:path";
+import { existsSync as existsSync9 } from "node:fs";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { FixedClusterPool, WorkerChoiceStrategies } from "poolifier";
 
 // src/infrastructure/browser/ensure-browser.ts
 init_logger();
 import { spawn as spawn2 } from "node:child_process";
-import { createRequire as createRequire5 } from "node:module";
+import { createRequire as createRequire6 } from "node:module";
 import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync7, readdirSync as readdirSync3, statSync as statSync3, fstatSync, openSync as openSync4, closeSync as closeSync4, rmSync } from "node:fs";
-import { join as join11, dirname as dirname8 } from "node:path";
-import { tmpdir as tmpdir2 } from "node:os";
+import { existsSync as existsSync8, fstatSync, openSync as openSync4, closeSync as closeSync4, rmSync as rmSync2, readFileSync as readFileSync5 } 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;
 var STALE_LOCK_MS = 55 * 60 * 1e3;
 var WAIT_FOR_PEER_MS = 50 * 60 * 1e3;
 var POLL_INTERVAL_MS = 2e3;
 var inFlight = null;
+function currentPin() {
+  const root = findPackageRoot(import.meta.url);
+  return root ? loadPin(root) : null;
+}
 function isBrowserBinaryPresent() {
   try {
-    const cacheDir = getCamoufoxBinaryPath();
-    if (!existsSync7(cacheDir)) return false;
-    return readdirSync3(cacheDir).some((entry) => {
-      try {
-        return statSync3(join11(cacheDir, entry)).isDirectory();
-      } catch {
-        return false;
-      }
-    });
+    return isUsable(getCamoufoxBinaryPath(), currentPin());
   } catch {
     return false;
   }
 }
-function resolveCamoufoxBin() {
+function resolveCamoufoxCli() {
   try {
-    const require2 = createRequire5(import.meta.url);
-    const pkgJson = require2.resolve("camoufox-js/package.json");
-    const bin = join11(dirname8(pkgJson), "..", ".bin", process.platform === "win32" ? "camoufox-js.cmd" : "camoufox-js");
-    if (existsSync7(bin)) return bin;
+    const require2 = createRequire6(import.meta.url);
+    const pkgJson = require2.resolve("@camoufox/camoufox/package.json");
+    const pkg = JSON.parse(readFileSync5(pkgJson, "utf8"));
+    const rel = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.["camoufox"];
+    if (rel) {
+      const entry = join12(dirname9(pkgJson), rel);
+      if (existsSync8(entry)) return entry;
+    }
   } catch {
   }
   return null;
@@ -16401,11 +16661,17 @@ function resolveCamoufoxBin() {
 var delay = (ms) => new Promise((r) => setTimeout(r, ms));
 function runFetch() {
   return new Promise((resolve9, reject) => {
-    const bin = resolveCamoufoxBin();
-    const [cmd, args] = bin ? [bin, ["fetch"]] : ["npx", ["camoufox-js", "fetch"]];
-    logger.info(`[ensure-browser] Camoufox not found; fetching the browser (this runs once, ~500MB): ${cmd} ${args.join(" ")}`);
-    const useShell = process.platform === "win32";
-    const child = spawn2(useShell ? `"${cmd}"` : cmd, args, { stdio: "inherit", shell: useShell });
+    const cli = resolveCamoufoxCli();
+    if (!cli) {
+      reject(new Error("@camoufox/camoufox is not installed (cannot find its CLI); run npm install"));
+      return;
+    }
+    const install = resolveInstall(process.env, platform3(), homedir5());
+    const env = { ...process.env, ...install.overrides };
+    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 timer = setTimeout(() => {
       child.kill("SIGKILL");
       reject(new Error(`camoufox fetch timed out after ${FETCH_TIMEOUT_MS}ms`));
@@ -16416,8 +16682,7 @@ function runFetch() {
     });
     child.on("exit", (code) => {
       clearTimeout(timer);
-      if (code === 0) resolve9();
-      else reject(new Error(`camoufox fetch exited with code ${code}`));
+      resolve9(code === 0);
     });
   });
 }
@@ -16436,7 +16701,7 @@ async function provision() {
     return;
   }
   const cacheKey = createHash2("sha256").update(getCamoufoxBinaryPath()).digest("hex").slice(0, 16);
-  const lockPath = join11(tmpdir2(), `pi-research-camoufox-fetch-${cacheKey}.lock`);
+  const lockPath = join12(tmpdir2(), `pi-research-camoufox-fetch-${cacheKey}.lock`);
   let haveLock = false;
   try {
     closeSync4(openSync4(lockPath, "wx", 384));
@@ -16451,7 +16716,7 @@ async function provision() {
         closeSync4(fd);
       }
       if (Date.now() - mtimeMs > STALE_LOCK_MS) {
-        rmSync(lockPath, { force: true });
+        rmSync2(lockPath, { force: true });
         closeSync4(openSync4(lockPath, "wx", 384));
         haveLock = true;
       }
@@ -16464,16 +16729,15 @@ async function provision() {
   }
   try {
     if (isBrowserBinaryPresent()) return;
-    await runFetch();
-    if (isBrowserBinaryPresent()) {
-      logger.info("[ensure-browser] Camoufox browser is ready.");
-    } else {
-      logger.warn("[ensure-browser] camoufox fetch reported success but no binary was found.");
+    const result = await provisionBrowser(getCamoufoxBinaryPath(), runFetch, (m) => logger.info(`[ensure-browser] ${m}`), currentPin());
+    if (result.status === "failed") {
+      throw new Error(result.reason ?? "camoufox fetch failed");
     }
+    logger.info("[ensure-browser] Camoufox browser is ready.");
   } finally {
     if (haveLock) {
       try {
-        rmSync(lockPath, { force: true });
+        rmSync2(lockPath, { force: true });
       } catch {
       }
     }
@@ -16491,16 +16755,16 @@ function ensureBrowserInstalled() {
 
 // src/infrastructure/browser/cleanup-utils.ts
 init_logger();
-import * as fs10 from "node:fs/promises";
-import * as path12 from "node:path";
-import * as os5 from "node:os";
+import * as fs11 from "node:fs/promises";
+import * as path13 from "node:path";
+import * as os6 from "node:os";
 var DEFAULT_STALE_MS = 30 * 24 * 60 * 60 * 1e3;
 var LOCK_FILE_NAMES = ["lock", ".parentlock", "parent.lock"];
 var LOCK_FRESHNESS_MS = 2 * 60 * 1e3;
 async function isWindowsParentLockHeld(lockPath) {
   let handle;
   try {
-    handle = await fs10.open(lockPath, "r");
+    handle = await fs11.open(lockPath, "r");
   } catch (e) {
     const code = e?.code;
     if (code === "ENOENT") return false;
@@ -16527,16 +16791,16 @@ function isPidAlive(pid) {
 }
 async function isProfileLive(profileDir) {
   for (const name of LOCK_FILE_NAMES) {
-    const lockPath = path12.join(profileDir, name);
+    const lockPath = path13.join(profileDir, name);
     let lst;
     try {
-      lst = await fs10.lstat(lockPath);
+      lst = await fs11.lstat(lockPath);
     } catch {
       continue;
     }
     if (lst.isSymbolicLink()) {
       try {
-        const pid = parsePidFromLockTarget(await fs10.readlink(lockPath));
+        const pid = parsePidFromLockTarget(await fs11.readlink(lockPath));
         if (pid !== null) return isPidAlive(pid);
       } catch {
       }
@@ -16553,42 +16817,42 @@ async function isProfileLive(profileDir) {
 async function canonicalizeForCompare(p) {
   let resolved;
   try {
-    resolved = await fs10.realpath(p);
+    resolved = await fs11.realpath(p);
   } catch {
-    resolved = path12.resolve(p);
+    resolved = path13.resolve(p);
   }
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 async function isPiOwnedSweepDir(dir) {
   const [realDir, realTmp] = await Promise.all([
     canonicalizeForCompare(dir),
-    canonicalizeForCompare(os5.tmpdir())
+    canonicalizeForCompare(os6.tmpdir())
   ]);
   if (realDir === realTmp) return false;
   const hasPiSegment = (p) => p.split(/[\\/]+/).some((segment) => segment.toLowerCase().startsWith("pi-research"));
   return hasPiSegment(realDir);
 }
 async function cleanupStaleProfiles(baseDir, staleMs = DEFAULT_STALE_MS) {
-  const scanDir = baseDir ?? os5.tmpdir();
+  const scanDir = baseDir ?? os6.tmpdir();
   const usePrefix = baseDir === void 0;
   const prefix = "playwright_firefoxdev_profile-";
   let removed = 0;
   let errors = 0;
   const sweepUnrecognized = usePrefix ? false : await isPiOwnedSweepDir(scanDir);
   try {
-    const entries = await fs10.readdir(scanDir);
+    const entries = await fs11.readdir(scanDir);
     const now = Date.now();
     for (const entry of entries) {
       if (usePrefix && !entry.startsWith(prefix)) continue;
-      const fullPath = path12.join(scanDir, entry);
+      const fullPath = path13.join(scanDir, entry);
       try {
-        const stats = await fs10.stat(fullPath);
+        const stats = await fs11.stat(fullPath);
         if (!stats.isDirectory()) continue;
         const isProfileLike = entry.startsWith(prefix) || entry.startsWith("playwright-artifacts-");
         if (isProfileLike) {
-          const inner = await fs10.readdir(fullPath);
+          const inner = await fs11.readdir(fullPath);
           if (inner.length === 0) {
-            await fs10.rmdir(fullPath);
+            await fs11.rmdir(fullPath);
             removed++;
             continue;
           }
@@ -16596,12 +16860,12 @@ async function cleanupStaleProfiles(baseDir, staleMs = DEFAULT_STALE_MS) {
             logger.debug(`[Cleanup] Skipping profile ${entry} \u2014 owned by a live browser`);
             continue;
           }
-          await fs10.rm(fullPath, { recursive: true, force: true, maxRetries: 5, retryDelay: 50 });
+          await fs11.rm(fullPath, { recursive: true, force: true, maxRetries: 5, retryDelay: 50 });
           removed++;
           continue;
         }
         if (sweepUnrecognized && now - stats.mtimeMs > staleMs && !await isProfileLive(fullPath)) {
-          await fs10.rm(fullPath, { recursive: true, force: true, maxRetries: 5, retryDelay: 50 });
+          await fs11.rm(fullPath, { recursive: true, force: true, maxRetries: 5, retryDelay: 50 });
           removed++;
         }
       } catch (_e) {
@@ -16621,7 +16885,7 @@ async function cleanupStaleProfiles(baseDir, staleMs = DEFAULT_STALE_MS) {
 init_log_utils();
 import process3 from "node:process";
 import cluster from "node:cluster";
-import * as fs11 from "node:fs/promises";
+import * as fs12 from "node:fs/promises";
 var workerId = "";
 var BENIGN_IPC_CODES = /* @__PURE__ */ new Set(["EPIPE", "ERR_IPC_CHANNEL_CLOSED", "ECONNRESET"]);
 function isBenignClusterIpcError(err) {
@@ -16682,7 +16946,7 @@ function logToDebugFile(level, ...args) {
         return String(arg);
       }).join(" "))
     };
-    fs11.appendFile(logFile, `${JSON.stringify(entry)}
+    fs12.appendFile(logFile, `${JSON.stringify(entry)}
 `).catch(() => {
     });
   } catch {
@@ -16694,7 +16958,7 @@ init_service_registry();
 init_safe_unref();
 init_service_names();
 var __filename2 = fileURLToPath3(import.meta.url);
-var __dirname = dirname9(__filename2);
+var __dirname = dirname10(__filename2);
 function buildWorkerPoolOptions(config) {
   return {
     workerChoiceStrategy: WorkerChoiceStrategies.LEAST_USED,
@@ -16786,8 +17050,8 @@ var WorkerPoolManager = class {
         void cleanupStaleProfiles(getBrowserProfileDir(config), STALE_PROFILE_MS).catch((e) => logger.debug("[WorkerPoolManager] Profile sweep (profile dir) failed:", e));
         void cleanupStaleProfiles(void 0, STALE_PROFILE_MS).catch((e) => logger.debug("[WorkerPoolManager] Profile sweep (legacy tmp) failed:", e));
         void cleanupOrphanedCamoufoxProcesses().catch((e) => logger.debug("[WorkerPoolManager] Startup orphan sweep failed:", e));
-        const workerPath = join13(__dirname, "./thread-worker.mjs");
-        if (!existsSync8(workerPath)) {
+        const workerPath = join14(__dirname, "./thread-worker.mjs");
+        if (!existsSync9(workerPath)) {
           throw new Error(
             `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.`
           );
@@ -17035,7 +17299,7 @@ var WorkerPoolManager = class {
 init_config();
 init_service_registry();
 init_service_names();
-import * as path13 from "node:path";
+import * as path14 from "node:path";
 var StatePathConfiguration = class {
   name = ServiceNames.STATE_PATH_CONFIGURATION;
   lifecycle = "uninitialized" /* UNINITIALIZED */;
@@ -17047,13 +17311,13 @@ var StatePathConfiguration = class {
   lockFilePath;
   projectSettingsPath;
   constructor(stateDir) {
-    const resolvedStateDir = stateDir && path13.isAbsolute(stateDir) ? stateDir : getStateDir();
+    const resolvedStateDir = stateDir && path14.isAbsolute(stateDir) ? stateDir : getStateDir();
     this.stateDir = resolvedStateDir;
-    this.stateFilePath = path13.join(resolvedStateDir, "research-state.json");
-    this.lockDirPath = path13.join(resolvedStateDir, ".locks");
-    this.backupDirPath = path13.join(resolvedStateDir, "backups");
-    this.lockFilePath = path13.join(this.lockDirPath, "research-state.lock");
-    this.projectSettingsPath = path13.join(resolvedStateDir, "project-settings.json");
+    this.stateFilePath = path14.join(resolvedStateDir, "research-state.json");
+    this.lockDirPath = path14.join(resolvedStateDir, ".locks");
+    this.backupDirPath = path14.join(resolvedStateDir, "backups");
+    this.lockFilePath = path14.join(this.lockDirPath, "research-state.lock");
+    this.projectSettingsPath = path14.join(resolvedStateDir, "project-settings.json");
   }
   async initialize() {
     if (this._initialized) {
@@ -17172,7 +17436,7 @@ var ResearchRunSemaphore = class {
     if (this._initialized) return;
     this.lifecycle = "initializing" /* INITIALIZING */;
     try {
-      await import("node:fs/promises").then((fs18) => fs18.mkdir(this.slotDir, { recursive: true, mode: 448 }));
+      await import("node:fs/promises").then((fs19) => fs19.mkdir(this.slotDir, { recursive: true, mode: 448 }));
     } catch (err) {
       logger.warn(`[ResearchRunSemaphore] Could not create slot dir ${this.slotDir}: ${err instanceof Error ? err.message : String(err)}`);
     }
@@ -17325,9 +17589,9 @@ init_logger();
 init_atomic_replace();
 init_service_registry();
 init_service_names();
-import * as fs12 from "node:fs/promises";
+import * as fs13 from "node:fs/promises";
 import * as crypto8 from "node:crypto";
-import * as path14 from "node:path";
+import * as path15 from "node:path";
 var QUARANTINE_KEEP = 5;
 var StateBackupManager = class {
   name = ServiceNames.STATE_BACKUP_MANAGER;
@@ -17349,7 +17613,7 @@ var StateBackupManager = class {
       return;
     }
     this.lifecycle = "initializing" /* INITIALIZING */;
-    await fs12.mkdir(this.backupDirPath, { recursive: true, mode: 448 });
+    await fs13.mkdir(this.backupDirPath, { recursive: true, mode: 448 });
     this._initialized = true;
     this.lifecycle = "initialized" /* INITIALIZED */;
   }
@@ -17363,15 +17627,15 @@ var StateBackupManager = class {
   async createBackup() {
     try {
       try {
-        await fs12.access(this.stateFilePath);
+        await fs13.access(this.stateFilePath);
       } catch {
         return;
       }
-      await fs12.mkdir(this.backupDirPath, { recursive: true, mode: 448 });
+      await fs13.mkdir(this.backupDirPath, { recursive: true, mode: 448 });
       const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
       const backupFileName = `research-state-${timestamp}-${crypto8.randomBytes(4).toString("hex")}.json`;
-      const backupFilePath = path14.join(this.backupDirPath, backupFileName);
-      await fs12.copyFile(this.stateFilePath, backupFilePath);
+      const backupFilePath = path15.join(this.backupDirPath, backupFileName);
+      await fs13.copyFile(this.stateFilePath, backupFilePath);
     } catch (error) {
       throw new Error(`Failed to create backup: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
     }
@@ -17381,14 +17645,14 @@ var StateBackupManager = class {
    */
   async cleanupOldBackups() {
     try {
-      const entries = await fs12.readdir(this.backupDirPath);
+      const entries = await fs13.readdir(this.backupDirPath);
       if (entries.length <= this.maxBackups) {
         return;
       }
       const backupFiles = [];
       for (const entry of entries) {
-        const filePath = path14.join(this.backupDirPath, entry);
-        const stats = await fs12.stat(filePath);
+        const filePath = path15.join(this.backupDirPath, entry);
+        const stats = await fs13.stat(filePath);
         if (stats.isFile() && entry.startsWith("research-state-") && entry.endsWith(".json")) {
           backupFiles.push({ name: entry, mtime: stats.mtime });
         }
@@ -17396,8 +17660,8 @@ var StateBackupManager = class {
       backupFiles.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
       const backupsToRemove = backupFiles.slice(this.maxBackups);
       for (const backupFile of backupsToRemove) {
-        const filePath = path14.join(this.backupDirPath, backupFile.name);
-        await fs12.unlink(filePath);
+        const filePath = path15.join(this.backupDirPath, backupFile.name);
+        await fs13.unlink(filePath);
       }
     } catch (error) {
       logger.error(`Failed to cleanup old backups: ${error instanceof Error ? error.message : String(error)}`);
@@ -17410,10 +17674,10 @@ var StateBackupManager = class {
     try {
       let backups = [];
       try {
-        const entries = await fs12.readdir(this.backupDirPath);
+        const entries = await fs13.readdir(this.backupDirPath);
         for (const entry of entries) {
-          const filePath = path14.join(this.backupDirPath, entry);
-          const stats = await fs12.stat(filePath);
+          const filePath = path15.join(this.backupDirPath, entry);
+          const stats = await fs13.stat(filePath);
           if (stats.isFile() && entry.startsWith("research-state-") && entry.endsWith(".json")) {
             backups.push({ name: entry, mtime: stats.mtime });
           }
@@ -17422,10 +17686,10 @@ var StateBackupManager = class {
       }
       backups.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
       for (const backup of backups) {
-        const backupPath = path14.join(this.backupDirPath, backup.name);
+        const backupPath = path15.join(this.backupDirPath, backup.name);
         let restoreContent;
         try {
-          const content = await fs12.readFile(backupPath, "utf-8");
+          const content = await fs13.readFile(backupPath, "utf-8");
           const validated = this.validator.migrateAndValidate(JSON.parse(content));
           restoreContent = JSON.stringify(validated, null, 2);
         } catch (err) {
@@ -17453,27 +17717,27 @@ var StateBackupManager = class {
    */
   async quarantineFutureState(fileVersion) {
     try {
-      await fs12.access(this.stateFilePath);
+      await fs13.access(this.stateFilePath);
     } catch {
       return;
     }
-    await fs12.mkdir(this.backupDirPath, { recursive: true, mode: 448 });
+    await fs13.mkdir(this.backupDirPath, { recursive: true, mode: 448 });
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     const name = `research-state-future-v${fileVersion}-${timestamp}.quarantine`;
-    const dest = path14.join(this.backupDirPath, name);
-    await fs12.copyFile(this.stateFilePath, dest);
+    const dest = path15.join(this.backupDirPath, name);
+    await fs13.copyFile(this.stateFilePath, dest);
     logger.warn(`[StateManager] Quarantined newer-build state (v${fileVersion}) copy at ${dest}`);
     await this.pruneQuarantineFiles(QUARANTINE_KEEP);
   }
   /** Keep only the newest `keep` *.quarantine files; delete the rest. Best-effort. */
   async pruneQuarantineFiles(keep) {
     try {
-      const entries = await fs12.readdir(this.backupDirPath);
+      const entries = await fs13.readdir(this.backupDirPath);
       const quarantines = [];
       for (const entry of entries) {
         if (!entry.endsWith(".quarantine")) continue;
         try {
-          const stats = await fs12.stat(path14.join(this.backupDirPath, entry));
+          const stats = await fs13.stat(path15.join(this.backupDirPath, entry));
           if (stats.isFile()) quarantines.push({ name: entry, mtime: stats.mtimeMs });
         } catch {
         }
@@ -17482,7 +17746,7 @@ var StateBackupManager = class {
       quarantines.sort((a, b) => b.mtime - a.mtime);
       for (const stale of quarantines.slice(keep)) {
         try {
-          await fs12.unlink(path14.join(this.backupDirPath, stale.name));
+          await fs13.unlink(path15.join(this.backupDirPath, stale.name));
         } catch {
         }
       }
@@ -17494,11 +17758,11 @@ var StateBackupManager = class {
    * a Windows copy+delete fallback since rename fails on NTFS when the target exists).
    */
   async atomicWriteStateFile(content) {
-    const stateDir = path14.dirname(this.stateFilePath);
-    await fs12.mkdir(stateDir, { recursive: true, mode: 448 });
+    const stateDir = path15.dirname(this.stateFilePath);
+    await fs13.mkdir(stateDir, { recursive: true, mode: 448 });
     const tempFile = `research-state-${crypto8.randomBytes(16).toString("hex")}.tmp`;
-    const tempPath = path14.join(stateDir, tempFile);
-    const fh = await fs12.open(tempPath, "w", 384);
+    const tempPath = path15.join(stateDir, tempFile);
+    const fh = await fs13.open(tempPath, "w", 384);
     try {
       await fh.writeFile(content, { encoding: "utf-8" });
       await fh.sync();
@@ -17507,11 +17771,11 @@ var StateBackupManager = class {
     }
     try {
       if (await replaceFile(tempPath, this.stateFilePath) === "copied") {
-        await fs12.unlink(tempPath).catch(() => {
+        await fs13.unlink(tempPath).catch(() => {
         });
       }
     } catch (renameErr) {
-      await fs12.unlink(tempPath).catch(() => {
+      await fs13.unlink(tempPath).catch(() => {
       });
       throw renameErr;
     }
@@ -18149,7 +18413,7 @@ async function performSearch(queries, config, signal, onProgress, container = ge
     if (isNativeBindingError(sampleWorkerError)) {
       metrics.increment("browser_search_total_failures_total", 1, { cause: "native_binding" });
       throw new Error(
-        `Search completely failed: ${reason}, all with a missing native module. This is an incomplete install, not a network problem: better-sqlite3 13 ships prebuilt bindings for every supported platform and loads them at runtime, so a missing binding means an old or broken npm install. Upgrade npm to \u226512 (npm install -g npm@12) and reinstall this package \u2014 modern npm skips the needless recompile that fails on toolchain-less machines, and the prebuilt binding then loads as-is.` + (sampleWorkerError ? ` Last worker error: ${sampleWorkerError}` : "")
+        `Search completely failed: ${reason}, all with a missing native module. This is an incomplete install, not a network problem: the browser launcher's native dependency (impit) ships a prebuilt binding per platform as a separate package, and npm sometimes drops it (npm/cli#4828). Reinstall this package (npm install, or pi install again) to restore it.` + (sampleWorkerError ? ` Last worker error: ${sampleWorkerError}` : "")
       );
     }
     throw new Error(
@@ -18330,7 +18594,7 @@ async function checkBrowserCapability() {
     }
     return { healthy: true, diagnostic: { status: mockMode ? "mocked" : "available" } };
   } else {
-    return { healthy: false, error: 'Camoufox (browser) not found. Run "npx camoufox-js fetch" to install the browser.' };
+    return { healthy: false, error: 'Camoufox (browser) not found. Run "npx camoufox fetch" to install the browser.' };
   }
 }
 function knowledgeStoreDisabledStatus() {
@@ -18922,9 +19186,9 @@ function formatErrorWithCause(err) {
 function isPrivateIp(ip) {
   const parts = ip.split(".").map(Number);
   if (parts.length !== 4 || parts.some((p) => isNaN(p))) return false;
-  const [a, b] = parts;
+  const [a, b, c] = parts;
   if (a === void 0 || b === void 0) return false;
-  return a === 0 || a === 10 || a === 127 || a === 100 && b >= 64 && b <= 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a >= 224;
+  return a === 0 || a === 10 || a === 127 || a === 100 && b >= 64 && b <= 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 198 && (b === 18 || b === 19) || a === 192 && b === 0 && (c === 0 || c === 2) || a === 198 && b === 51 && c === 100 || a === 203 && b === 0 && c === 113 || a >= 224;
 }
 function isPrivateIpv6(ip) {
   const normalized = ip.toLowerCase().replace(/^\[|\]$/g, "");
@@ -19003,10 +19267,29 @@ ${kept.join("\n")}
 ${rest}` : rest;
 }
 function cleanConvertedMarkdown(markdown) {
-  return stripEmptyFragmentLinks(stripImageLinks(trimFrontMatter(markdown))).replace(/\n{3,}/g, "\n\n").trim();
+  return collapseBlankLines(stripEmptyFragmentLinks(stripImageLinks(trimFrontMatter(markdown)))).trim();
+}
+var CODE_FENCE = /^ {0,3}(`{3,}|~{3,})/;
+function collapseBlankLines(markdown) {
+  if (!markdown.includes("\n\n\n")) return markdown;
+  const out = [];
+  let fence = null;
+  for (const line of markdown.split("\n")) {
+    const m = CODE_FENCE.exec(line);
+    if (fence === null) {
+      if (m) fence = m[1];
+    } else if (m && m[1][0] === fence[0] && m[1].length >= fence.length && line.slice(m[0].length).trim() === "") {
+      fence = null;
+    }
+    if (fence === null && line === "" && out.length > 0 && out[out.length - 1] === "") continue;
+    out.push(line);
+  }
+  return out.join("\n");
 }
 function stripImageLinks(markdown) {
-  return markdown.replace(MARKDOWN_IMAGE_PATTERN, "").replace(IMAGE_LINK_PATTERN, "$1").replace(/\n{3,}/g, "\n\n").trim();
+  return collapseBlankLines(
+    markdown.replace(MARKDOWN_IMAGE_PATTERN, "").replace(IMAGE_LINK_PATTERN, "$1")
+  ).trim();
 }
 function createNativeMarkdownConverter(nativeModule) {
   return async (html) => {
@@ -19079,11 +19362,11 @@ init_service_registry();
 init_logger();
 init_metrics();
 init_error_tracker();
-import { existsSync as existsSync11 } from "node:fs";
-import { dirname as dirname12, join as join20 } from "node:path";
+import { existsSync as existsSync12 } from "node:fs";
+import { dirname as dirname13, join as join21 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { Worker } from "node:worker_threads";
-var MODULE_DIR = dirname12(fileURLToPath4(import.meta.url));
+var MODULE_DIR = dirname13(fileURLToPath4(import.meta.url));
 var PdfExtractError = class extends Error {
   kind;
   constructor(kind, message, options) {
@@ -19151,8 +19434,8 @@ var nextRequestId = 1;
 var pendingRequests = /* @__PURE__ */ new Map();
 var warnedWorkerUnavailable = false;
 function resolveWorkerPath() {
-  const candidate = join20(MODULE_DIR, WORKER_FILENAME);
-  return existsSync11(candidate) ? candidate : null;
+  const candidate = join21(MODULE_DIR, WORKER_FILENAME);
+  return existsSync12(candidate) ? candidate : null;
 }
 function pdfWorkerEnabled() {
   if (process.env["PI_RESEARCH_PDF_WORKER"] === "off") return false;
@@ -19316,7 +19599,7 @@ var FETCH_RETRY_DELAY_MS = 250;
 var playwrightAvailable = false;
 var markdownConverterPromise = null;
 function initScraperDependencies() {
-  playwrightAvailable = checkModule("playwright-core") && checkModule("camoufox-js");
+  playwrightAvailable = checkModule("playwright-core") && checkModule("@camoufox/camoufox");
 }
 initScraperDependencies();
 async function getMarkdownConverter() {
@@ -24052,6 +24335,18 @@ function isUnretriableResearcherError(error) {
   const message = (error instanceof Error ? error.message : String(error)).toLowerCase();
   return message.includes("requires more credits") || message.includes("insufficient credits") || message.includes("insufficient_quota");
 }
+function isInFlightBudgetError(error) {
+  const lower = (error instanceof Error ? error.message : String(error)).toLowerCase();
+  return lower.includes("in_flight_budget_exhausted") || lower.includes("would exceed your available credits given your current in-flight requests");
+}
+function parseRetryAfterMs(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const m = /["']?retry-after["']?\s*[:=]\s*["']?(\d{1,4})/i.exec(message);
+  if (!m) return null;
+  const seconds = Number(m[1]);
+  if (!Number.isFinite(seconds) || seconds <= 0) return null;
+  return Math.min(Math.max(seconds, 5), 60) * 1e3;
+}
 async function runResearcher(options) {
   const {
     config: researcherConfig,
@@ -24144,6 +24439,7 @@ ${effectiveInitialLinks.map((l) => `- ${l}`).join("\n")}`;
   const researcherExecutionStartMs = Date.now();
   const deliveredSteeringIds = /* @__PURE__ */ new Set();
   const researcherSystemPrompt = injectCurrentDate(researcherPromptTemplate, "researcher").replace("{{extra_tool_guidelines}}", "").replaceAll("{{max_scrape_urls}}", String(config.MAX_SCRAPE_URLS)).replace("{{digest_section}}", () => RESEARCHER_DIGEST_SECTION).trim();
+  let inFlightBackoffMs = null;
   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
     if (signal?.aborted) throw new Error("Aborted");
     if (stopRequested()) {
@@ -24151,7 +24447,8 @@ ${effectiveInitialLinks.map((l) => `- ${l}`).join("\n")}`;
       return;
     }
     if (attempt > 1) {
-      const delay2 = Math.min(1e3 * Math.pow(2, attempt - 2), config.RESEARCHER_MAX_RETRY_DELAY_MS);
+      const delay2 = inFlightBackoffMs ?? Math.min(1e3 * Math.pow(2, attempt - 2), config.RESEARCHER_MAX_RETRY_DELAY_MS);
+      inFlightBackoffMs = null;
       logger.warn(`[ResearcherExecutor] Researcher ${id} retry ${attempt - 1}/${config.RESEARCHER_MAX_RETRIES} after ${delay2}ms`);
       observer?.onResearcherProgress?.(id, "retry");
       await new Promise((resolve9) => {
@@ -24394,6 +24691,11 @@ ${responseText}`);
         metrics.increment("researcher_unretriable_total", 1, { mode: "deep", complexity: String(complexity) });
         break;
       }
+      if (isInFlightBudgetError(err) && attempt < maxAttempts) {
+        inFlightBackoffMs = parseRetryAfterMs(err) ?? 15e3;
+        metrics.increment("researcher_inflight_budget_backoff_total", 1, { mode: "deep", complexity: String(complexity) });
+        logger.warn(`[ResearcherExecutor] Researcher ${id} hit the provider's in-flight budget; backing off ${inFlightBackoffMs}ms (provider Retry-After, else 15s) before attempt ${attempt + 1}`);
+      }
       if (attempt < maxAttempts) {
         logger.warn(`[ResearcherExecutor] Researcher ${id} attempt ${attempt} failed: ${errMsg}; will retry`);
       } else {
@@ -27074,9 +27376,9 @@ init_url_utils();
 // src/utils/research-export.ts
 init_logger();
 init_constants();
-import { promises as fs15 } from "node:fs";
-import { homedir as homedir4, tmpdir as tmpdir4, platform as platform3 } from "node:os";
-import { join as join21, resolve as resolve5, normalize, sep as sep2 } from "node:path";
+import { promises as fs16 } from "node:fs";
+import { homedir as homedir6, tmpdir as tmpdir4, platform as platform4 } from "node:os";
+import { join as join22, resolve as resolve5, normalize, sep as sep2 } from "node:path";
 import { randomBytes as randomBytes6 } from "node:crypto";
 var PREFERRED_SUBDIRS = [
   "research",
@@ -27118,9 +27420,9 @@ var WIN_SYSTEM_PREFIXES_LC = [
 ];
 function isSafeToWriteDirectly(dir) {
   const normalized = normalize(resolve5(dir));
-  const home = normalize(resolve5(homedir4()));
+  const home = normalize(resolve5(homedir6()));
   if (normalized === home) return false;
-  if (platform3() === "win32") {
+  if (platform4() === "win32") {
     if (/^[a-zA-Z]:\\?$/.test(normalized)) return false;
     const lc = normalized.toLowerCase();
     for (const prefix of WIN_SYSTEM_PREFIXES_LC) {
@@ -27140,16 +27442,16 @@ function isSafeToWriteDirectly(dir) {
 async function findPreferredSubdir(cwd) {
   let entries;
   try {
-    entries = await fs15.readdir(cwd);
+    entries = await fs16.readdir(cwd);
   } catch {
     return null;
   }
   for (const target of PREFERRED_SUBDIRS) {
     const match = entries.find((e) => e.toLowerCase() === target);
     if (match === void 0) continue;
-    const candidate = join21(cwd, match);
+    const candidate = join22(cwd, match);
     try {
-      const stat6 = await fs15.stat(candidate);
+      const stat6 = await fs16.stat(candidate);
       if (stat6.isDirectory()) return candidate;
     } catch {
     }
@@ -27181,7 +27483,7 @@ async function exportResearchReport(query, result, _mode, cwd, explicitDir) {
   if (explicitDir && explicitDir.trim()) {
     targetDir = resolve5(explicitDir.trim());
     try {
-      await fs15.mkdir(targetDir, { recursive: true });
+      await fs16.mkdir(targetDir, { recursive: true });
     } catch (error) {
       logger.error(`[export] Could not create export dir "${targetDir}":`, error);
       return null;
@@ -27192,9 +27494,9 @@ async function exportResearchReport(query, result, _mode, cwd, explicitDir) {
   for (let attempt = 0; attempt < MAX_EXPORT_RETRIES; attempt++) {
     const hash = generateHash();
     const filename = `${baseFilename}-${hash}.md`;
-    const filepath = join21(targetDir, filename);
+    const filepath = join22(targetDir, filename);
     try {
-      await fs15.writeFile(filepath, result, { flag: "wx" });
+      await fs16.writeFile(filepath, result, { flag: "wx", mode: 384 });
       logger.log(`[export] Research report saved to: ${filepath}`);
       return filepath;
     } catch (error) {
@@ -27228,7 +27530,7 @@ import { getAgentDir as getAgentDir2 } from "@earendil-works/pi-coding-agent";
 function readPkgVersion() {
   try {
     const pkgPath = fileURLToPath6(new URL("../package.json", import.meta.url));
-    const pkg = JSON.parse(fs17.readFileSync(pkgPath, "utf-8"));
+    const pkg = JSON.parse(fs18.readFileSync(pkgPath, "utf-8"));
     return typeof pkg.version === "string" && pkg.version ? pkg.version : "0.0.0";
   } catch {
     return "0.0.0";
@@ -27270,7 +27572,7 @@ var EXIT = {
   CANCELLED: 130
 };
 function exitCodeForSignal(sig) {
-  const signum = os7.constants.signals[sig];
+  const signum = os8.constants.signals[sig];
   return typeof signum === "number" ? 128 + signum : EXIT.CANCELLED;
 }
 function toStderr(s) {
@@ -27361,11 +27663,11 @@ function bridgeConfigEnv(explicitConfigPath) {
   for (const filePath of layers) {
     const isExplicit = explicitConfigPath !== void 0 && filePath === explicitConfigPath;
     try {
-      if (!fs17.existsSync(filePath)) {
+      if (!fs18.existsSync(filePath)) {
         if (isExplicit) throw new ConfigFileError(`--config file not found: ${filePath}`);
         continue;
       }
-      const parsed = parseDotEnv(fs17.readFileSync(filePath, "utf-8"));
+      const parsed = parseDotEnv(fs18.readFileSync(filePath, "utf-8"));
       Object.assign(merged, parsed);
       if (isExplicit) {
         for (const k of Object.keys(parsed)) fromExplicitBase.add(k);
@@ -27396,14 +27698,14 @@ function resolvedConfigPaths() {
     configDir,
     cliIfaceEnv: getInterfaceEnvFilePath("cli"),
     piIfaceEnv: getInterfaceEnvFilePath("pi"),
-    piAuth: path19.join(agentDir, "auth.json"),
-    piModels: path19.join(agentDir, "models.json"),
+    piAuth: path20.join(agentDir, "auth.json"),
+    piModels: path20.join(agentDir, "models.json"),
     piState: getStateDir()
   };
 }
 function fileExists(p) {
   try {
-    return fs17.existsSync(p);
+    return fs18.existsSync(p);
   } catch {
     return false;
   }
@@ -27523,6 +27825,10 @@ function configBlock(det, extraNote) {
   if (extraNote) lines.push(`  \u2022 note:               ${extraNote}`);
   return lines.join("\n");
 }
+function resolveCliDepth(explicit, cfg) {
+  const d = explicit ?? (cfg.QUICK_RESEARCH ? cfg.DEFAULT_RESEARCH_DEPTH : Math.max(1, cfg.DEFAULT_RESEARCH_DEPTH));
+  return d;
+}
 async function cmdResearch(args) {
   const det = await detectCredentials(args.model);
   if (det.problem) {
@@ -27545,7 +27851,7 @@ Error: ${vmsg}
 `);
     return EXIT.USAGE;
   }
-  const depth = args.depth ?? getConfig(process.cwd(), "cli").DEFAULT_RESEARCH_DEPTH;
+  const depth = resolveCliDepth(args.depth, getConfig(process.cwd(), "cli"));
   const runModel = det.model;
   toStderr(`[pi-research] starting research (depth ${depth})${runModel ? ` with ${runModel}` : ""}\u2026
 `);
@@ -27695,15 +28001,12 @@ async function cmdStatus(json) {
       installed: browserInstalled,
       nativeDepsOk: nativeDeps.ok,
       nativeDepsError: nativeDeps.ok ? null : nativeDeps.error,
-      // better-sqlite3 13 ships prebuilds/ for all eight platform/arch pairs and
-      // loads them at runtime via node-gyp-build — no install script involved.
-      // On modern npm (≥11.19) the injected `node-gyp rebuild` that a
-      // binding.gyp-without-install-script triggers is skipped, so a missing
-      // binding here means an old/broken install, not an approval problem:
-      // point at the upgrade that fixes it.
-      nativeDepsFix: nativeDeps.ok ? null : "Upgrade npm and reinstall: npm install -g npm@12, then reinstall @lincoln504/pi-research. better-sqlite3 13 ships prebuilt bindings (no script needed); older npm needlessly recompiles it and fails on machines without a C++ toolchain.",
+      // impit ships its binding as a per-platform optional package, no install script
+      // involved: a missing binding means npm dropped that package, and a reinstall
+      // restores it.
+      nativeDepsFix: nativeDeps.ok ? null : "Reinstall @lincoln504/pi-research (npm install). The browser launcher's native module (impit) ships as a separate platform package that npm sometimes drops (npm/cli#4828); a fresh install restores it.",
       // Same remedy the health check prints, so both surfaces name one command.
-      fix: browserInstalled ? null : "npx camoufox-js fetch",
+      fix: browserInstalled ? null : "npx camoufox fetch",
       note: browserInstalled ? null : "Stealth browser not installed \u2014 scraping falls back to plain fetch, which some sites block. npm 12 blocks install scripts by default, which skips this package's postinstall; the engine is fetched on first use instead."
     },
     knowledgeStoreMode: cfg.KNOWLEDGE_STORE_MODE,
@@ -27815,7 +28118,7 @@ change the machine-wide defaults: set PI_RESEARCH_KNOWLEDGE_STORE_MODE=<mode> an
 }
 function cmdCleanup(c) {
   const script = fileURLToPath6(new URL("../scripts/cleanup.cjs", import.meta.url));
-  if (!fs17.existsSync(script)) {
+  if (!fs18.existsSync(script)) {
     toStderr(
       `
 Error: cleanup script not found at ${script}.
@@ -28094,7 +28397,8 @@ COMMANDS
                                  state tree (<config dir>/research/state) and the cache, including
                                  downloaded embedding models. Keeps config.env and the knowledge
                                  store database. --purge-browsers also deletes the shared
-                                 stealth-browser cache (~/.cache/camoufox) other tools use.
+                                 stealth-browser cache (~/.cache/camoufox, every installed
+                                 browser build) other tools use.
 
   help, --help, -h               Show this help.
   --version, -v                  Print the pi-research version.
@@ -28488,8 +28792,8 @@ Error: ${err.message}
 var _isMain = (() => {
   try {
     if (!process.argv[1]) return false;
-    const modulePath = fs17.realpathSync(path19.resolve(fileURLToPath6(import.meta.url)));
-    const invokedPath = fs17.realpathSync(path19.resolve(process.argv[1]));
+    const modulePath = fs18.realpathSync(path20.resolve(fileURLToPath6(import.meta.url)));
+    const invokedPath = fs18.realpathSync(path20.resolve(process.argv[1]));
     return modulePath === invokedPath;
   } catch {
     return false;
@@ -28518,5 +28822,6 @@ export {
   exitCodeForSignal,
   makeProgressObserver,
   parseArgs,
-  reportError
+  reportError,
+  resolveCliDepth
 };