@lincoln504/pi-research 1.6.5 → 1.6.7

package/dist/pdf-extract-worker.mjs

@@ -0,0 +1,1289 @@
+// src/web-research/pdf-extract-worker.ts
+import { parentPort } from "node:worker_threads";
+
+// src/web-research/pdf-extraction.ts
+import { dirname as dirname2, join as join3 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/logger.ts
+import { appendFileSync, existsSync as existsSync2, mkdirSync, openSync as openSync2, closeSync as closeSync2 } from "node:fs";
+import { appendFile } from "node:fs/promises";
+import { AsyncLocalStorage as AsyncLocalStorage3 } from "node:async_hooks";
+import * as path3 from "node:path";
+
+// src/utils/error-tracker.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var trackerStorage = new AsyncLocalStorage();
+var ErrorTracker = class {
+  patterns = /* @__PURE__ */ new Map();
+  MAX_CONTEXTS_PER_PATTERN = 10;
+  // Bound total memory. The global singleton is never clear()'d, so out-of-run errors (logger,
+  // scrapers, healthcheck) would otherwise grow these maps without limit over a long-lived host.
+  MAX_PATTERNS = 500;
+  MAX_DOMAINS_PER_PATTERN = 100;
+  /**
+   * Normalize an error message to extract a stable signature.
+   * Removes UUIDs, numbers (except HTTP status codes), URLs, and normalizes whitespace.
+   *
+   * @param message - The error message to normalize
+   * @returns A normalized signature for grouping similar errors
+   */
+  extractSignature(message) {
+    return message.replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, "<UUID>").replace(/\b(?![12]\d{2}\b|[3-5]\d{2}\b)\d+\b/g, "<NUM>").replace(/https?:\/\/[^\s]+/g, "<URL>").replace(/\s+/g, " ").trim();
+  }
+  /**
+   * Track an error with optional context.
+   * Groups similar errors by normalized signature and maintains a rolling buffer of contexts.
+   *
+   * @param error - The error to track (Error object, string message, or unknown)
+   * @param context - Optional context information about where the error occurred
+   */
+  trackError(error, context = {}) {
+    let message;
+    if (error instanceof Error) {
+      message = error.message;
+    } else if (typeof error === "string") {
+      message = error;
+    } else {
+      message = String(error);
+    }
+    const signature = this.extractSignature(message);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    let pattern = this.patterns.get(signature);
+    if (!pattern) {
+      if (this.patterns.size >= this.MAX_PATTERNS) {
+        this.evictLeastFrequentPattern();
+      }
+      pattern = {
+        signature,
+        message,
+        count: 0,
+        firstSeen: now,
+        lastSeen: now,
+        contexts: [],
+        domainCounts: /* @__PURE__ */ new Map()
+      };
+      this.patterns.set(signature, pattern);
+    }
+    pattern.count++;
+    pattern.lastSeen = now;
+    if (context.domain) {
+      const existing = pattern.domainCounts.get(context.domain);
+      if (existing !== void 0) {
+        pattern.domainCounts.set(context.domain, existing + 1);
+      } else if (pattern.domainCounts.size < this.MAX_DOMAINS_PER_PATTERN) {
+        pattern.domainCounts.set(context.domain, 1);
+      }
+    }
+    pattern.contexts.push(context);
+    if (pattern.contexts.length > this.MAX_CONTEXTS_PER_PATTERN) {
+      pattern.contexts.shift();
+    }
+  }
+  /**
+   * Generate a complete error report with sorted patterns and domain/type breakdowns.
+   *
+   * @returns An ErrorReport with aggregated error information
+   */
+  getReport() {
+    const patterns = Array.from(this.patterns.values());
+    let totalErrors = 0;
+    for (const pattern of patterns) {
+      totalErrors += pattern.count;
+    }
+    patterns.sort((a, b) => b.count - a.count);
+    const byDomain = this.getErrorsByDomain();
+    const byType = this.getErrorsByType();
+    return {
+      totalErrors,
+      uniquePatterns: patterns.length,
+      patterns,
+      byDomain,
+      byType
+    };
+  }
+  /**
+   * Group errors by domain from context information.
+   *
+   * @returns A Map of domain names to error counts
+   */
+  getErrorsByDomain() {
+    const totalDomainCounts = /* @__PURE__ */ new Map();
+    for (const pattern of this.patterns.values()) {
+      for (const [domain, count] of pattern.domainCounts.entries()) {
+        totalDomainCounts.set(domain, (totalDomainCounts.get(domain) ?? 0) + count);
+      }
+    }
+    return totalDomainCounts;
+  }
+  /**
+   * Group errors by type (first part of signature before colon or first few words).
+   *
+   * @returns A Map of error types to error counts
+   */
+  getErrorsByType() {
+    const typeCounts = /* @__PURE__ */ new Map();
+    for (const pattern of this.patterns.values()) {
+      const parts = pattern.signature.split(":");
+      let type = parts[0]?.trim() ?? "Unknown";
+      if (type === pattern.signature) {
+        const words = pattern.signature.split(" ");
+        const firstWords = words.slice(0, 3).filter((w) => w.length > 0);
+        type = firstWords.length > 0 ? firstWords.join(" ") : "Unknown";
+      }
+      typeCounts.set(type, (typeCounts.get(type) ?? 0) + pattern.count);
+    }
+    return typeCounts;
+  }
+  /**
+   * Evict the least-frequent pattern to keep the map bounded (see MAX_PATTERNS). O(n) but only
+   * runs when a new signature is added while already at the cap.
+   */
+  evictLeastFrequentPattern() {
+    let victimKey;
+    let victimCount = Infinity;
+    for (const [key, p] of this.patterns) {
+      if (p.count < victimCount) {
+        victimCount = p.count;
+        victimKey = key;
+      }
+    }
+    if (victimKey !== void 0) {
+      this.patterns.delete(victimKey);
+    }
+  }
+  /**
+   * Clear all tracked errors (called between research runs).
+   */
+  clear() {
+    this.patterns.clear();
+  }
+};
+var globalInstance = new ErrorTracker();
+var errorTracker = new Proxy(globalInstance, {
+  get(target, prop, receiver) {
+    const currentTracker = trackerStorage.getStore() ?? target;
+    const value = Reflect.get(currentTracker, prop, receiver);
+    if (typeof value === "function") {
+      return value.bind(currentTracker);
+    }
+    return value;
+  }
+});
+
+// src/utils/log-utils.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+import * as os from "node:os";
+import * as path from "node:path";
+var logContextStorage = new AsyncLocalStorage2();
+function buildDefaultDebugLogPath() {
+  const override = process.env["PI_RESEARCH_LOG_PATH"];
+  if (override) return override;
+  return path.join(os.tmpdir(), "pi-research.log");
+}
+function isVerboseFromEnv() {
+  return process.env["PI_RESEARCH_DEBUG"] === "true";
+}
+function getLogContext() {
+  return logContextStorage.getStore() ?? {};
+}
+function safeJsonStringify(value) {
+  try {
+    return JSON.stringify(value, null, 0);
+  } catch {
+    return "[unserializable]";
+  }
+}
+function formatArg(arg) {
+  if (arg instanceof Error) {
+    return arg.stack ?? arg.message;
+  }
+  if (typeof arg === "object" && arg !== null) {
+    return safeJsonStringify(arg);
+  }
+  return String(arg);
+}
+var MAX_LOG_MESSAGE_LENGTH = 1e4;
+var ANSI_PATTERN = /\x1b\[[0-9;]*[A-Za-z]/g;
+var URL_CREDENTIALS_PATTERN = /([a-z][a-z0-9+.-]{0,31}:\/\/)[^/\s:@]+:[^/\s:@]+@/gi;
+var B_LEFT = "(?<![A-Za-z0-9])";
+var B_RIGHT = "(?![A-Za-z0-9])";
+var COOKIE_HEADER_PATTERN = new RegExp(
+  `${B_LEFT}(set[_-]?cookie|cookie)${B_RIGHT}(["']?\\s*[:=]\\s*["']?)([^\\r\\n]+)`,
+  "gi"
+);
+var 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"',&)]+)`,
+  "gi"
+);
+var 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}`,
+  "g"
+);
+var JWT_PATTERN = new RegExp(
+  `${B_LEFT}eyJ[A-Za-z0-9_-]{1,1024}\\.[A-Za-z0-9_-]{1,8192}\\.[A-Za-z0-9_-]{1,4096}`,
+  "g"
+);
+var BASIC_AUTH_PATTERN = new RegExp(`${B_LEFT}Basic\\s+[A-Za-z0-9+/]{16,}={0,2}`, "gi");
+var BEARER_AUTH_PATTERN = new RegExp(`${B_LEFT}Bearer\\s+[A-Za-z0-9._~+/-]+=*`, "gi");
+var PROVIDER_TOKEN_PATTERN = new RegExp(
+  `${B_LEFT}(AIza[0-9A-Za-z_-]{35}|ya29\\.[0-9A-Za-z_-]{20,}|[sp]k_(?:live|test)_[0-9A-Za-z]{16,})${B_RIGHT}`,
+  "g"
+);
+var LONG_HEX_SECRET_PATTERN = new RegExp(`${B_LEFT}[0-9a-fA-F]{32,}${B_RIGHT}`, "g");
+var CONTROL_CHARS_PATTERN = /[\x00-\x1f\x7f]/g;
+var REDACT_SCAN_LENGTH = MAX_LOG_MESSAGE_LENGTH * 4;
+var TOKEN_CHAR_PATTERN = /[A-Za-z0-9_\-./+=]/;
+var REDACT_SCAN_EXTENSION_MAX = 2048;
+function redactSecrets(message) {
+  const rawLength = message.length;
+  let scanEnd = REDACT_SCAN_LENGTH;
+  if (rawLength > scanEnd) {
+    const extensionLimit = Math.min(rawLength, scanEnd + REDACT_SCAN_EXTENSION_MAX);
+    while (scanEnd < extensionLimit && TOKEN_CHAR_PATTERN.test(message.charAt(scanEnd))) {
+      scanEnd += 1;
+    }
+  }
+  let out = rawLength > scanEnd ? message.slice(0, scanEnd) : message;
+  out = out.replace(ANSI_PATTERN, "");
+  out = out.replace(URL_CREDENTIALS_PATTERN, "$1[REDACTED]@");
+  out = out.replace(JWT_PATTERN, "[REDACTED]");
+  out = out.replace(BASIC_AUTH_PATTERN, "Basic [REDACTED]");
+  out = out.replace(BEARER_AUTH_PATTERN, "Bearer [REDACTED]");
+  out = out.replace(COOKIE_HEADER_PATTERN, (_m, key, sep) => `${key}${sep}[REDACTED]`);
+  out = out.replace(SENSITIVE_KV_PATTERN, (_m, key, sep) => `${key}${sep}[REDACTED]`);
+  out = out.replace(KNOWN_TOKEN_PATTERN, "[REDACTED]");
+  out = out.replace(PROVIDER_TOKEN_PATTERN, "[REDACTED]");
+  out = out.replace(LONG_HEX_SECRET_PATTERN, "[REDACTED]");
+  let keep = MAX_LOG_MESSAGE_LENGTH;
+  if (out.length > keep) {
+    const lastKeptUnit = out.charCodeAt(keep - 1);
+    if (lastKeptUnit >= 55296 && lastKeptUnit <= 56319) keep -= 1;
+  }
+  if (out.length > MAX_LOG_MESSAGE_LENGTH) {
+    out = `${out.slice(0, keep)}\u2026[truncated ${Math.max(rawLength, out.length) - keep} chars]`;
+  } else if (rawLength > scanEnd) {
+    out = `${out}\u2026[truncated ${rawLength - scanEnd} chars]`;
+  }
+  return out;
+}
+var TERMINAL_ESCAPE_PATTERN = new RegExp(
+  "\\x1b\\[[0-?]*[ -/]*[@-~]?|\\x1b\\][^\\x07\\x1b]*(?:\\x07|\\x1b\\\\)?|\\x1b[PX^_][^\\x1b]*(?:\\x1b\\\\)?|\\x1b.?",
+  "g"
+);
+function stripTerminalEscapes(message) {
+  return message.replace(TERMINAL_ESCAPE_PATTERN, "").replace(CONTROL_CHARS_PATTERN, " ");
+}
+
+// src/utils/log-rotation.ts
+import * as fs from "node:fs";
+import * as path2 from "node:path";
+var APPEND_CREATE_NOFOLLOW_FLAGS = fs.constants.O_WRONLY | fs.constants.O_APPEND | fs.constants.O_CREAT | (typeof fs.constants.O_NOFOLLOW === "number" ? fs.constants.O_NOFOLLOW : 0);
+function touchOwnerOnly(filePath, mode) {
+  let fd;
+  try {
+    fd = fs.openSync(filePath, APPEND_CREATE_NOFOLLOW_FLAGS, mode);
+    fs.fchmodSync(fd, mode);
+  } catch {
+  } finally {
+    if (fd !== void 0) {
+      try {
+        fs.closeSync(fd);
+      } catch {
+      }
+    }
+  }
+}
+var LogRotation = class {
+  MAX_LOG_SIZE = 10 * 1024 * 1024;
+  // 10MB max file size
+  MAX_LOG_FILES = 10;
+  // Keep last 10 archived logs
+  lastRotationCheck = 0;
+  logger;
+  constructor(logger2) {
+    this.logger = logger2;
+  }
+  /**
+   * Clear all research logs including archives.
+   */
+  clearLogs(logFile, logDir) {
+    try {
+      if (fs.existsSync(logFile)) {
+        fs.unlinkSync(logFile);
+        touchOwnerOnly(logFile, 384);
+      }
+      const files = fs.readdirSync(logDir);
+      const baseName = path2.basename(logFile);
+      const archives = files.filter((f) => f.startsWith(baseName) && f !== baseName);
+      for (const archive of archives) {
+        try {
+          fs.unlinkSync(path2.join(logDir, archive));
+        } catch {
+        }
+      }
+      this.logger.log("[Logger] All logs and archives cleared.");
+    } catch (err) {
+      this.logger.log("[Logger] Failed to clear logs:", err);
+    }
+  }
+  /**
+   * Rotate log files when they exceed MAX_LOG_SIZE.
+   * Archives are created with ISO timestamp suffix.
+   * Old archives beyond MAX_LOG_FILES are cleaned up.
+   */
+  rotateLogFile(logFile, logDir) {
+    try {
+      const stats = fs.statSync(logFile);
+      const fileSize = stats.size;
+      if (fileSize <= this.MAX_LOG_SIZE) {
+        return;
+      }
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+      const archivePath = `${logFile}.${timestamp}`;
+      try {
+        fs.renameSync(logFile, archivePath);
+      } catch (renameErr) {
+        this.logger.log("[Logger] Log rotation skipped (rename failed; file likely in use):", renameErr);
+        return;
+      }
+      touchOwnerOnly(logFile, 384);
+      try {
+        const files = fs.readdirSync(logDir);
+        const logFiles = files.filter((f) => f.startsWith(path2.basename(logFile)) && f !== path2.basename(logFile)).sort();
+        const toDelete = logFiles.slice(0, -this.MAX_LOG_FILES);
+        for (const file of toDelete) {
+          try {
+            fs.unlinkSync(path2.join(logDir, file));
+          } catch {
+          }
+        }
+      } catch {
+      }
+      this.logger.log("[Logger] Rotated log file to:", archivePath);
+    } catch (_error) {
+    }
+  }
+  /**
+   * Check if rotation is needed and perform if necessary.
+   *
+   * Throttled to one filesystem stat per 60s. We deliberately do NOT offer a
+   * `force` bypass: a previous version forced a check on every WARN/ERROR, which
+   * turned into a synchronous fs.statSync per line (thousands per heavy run) and
+   * also reset the throttle so the timer path never fired. The 60s timer
+   * preserves all log data on rotation regardless of when it lands — a file may
+   * transiently exceed MAX_LOG_SIZE by at most one check interval, which is fine.
+   * @returns true if a rotation check was performed
+   */
+  checkAndRotate(logFile, logDir) {
+    const now = Date.now();
+    if (now - this.lastRotationCheck > 6e4) {
+      this.rotateLogFile(logFile, logDir);
+      this.lastRotationCheck = now;
+      return true;
+    }
+    return false;
+  }
+};
+
+// src/utils/disk-space-checker.ts
+import * as fs2 from "node:fs";
+var DiskSpaceChecker = class {
+  MIN_DISK_SPACE_BYTES = 1048576;
+  // 1MB minimum
+  DISK_SPACE_CHECK_INTERVAL_MS = 6e4;
+  // Check every 60 seconds
+  lastDiskSpaceCheck = 0;
+  hasDiskSpace = true;
+  /**
+   * Check if there is sufficient disk space for logging.
+   * Checks are throttled to avoid excessive filesystem operations.
+   */
+  checkDiskSpace(logDir) {
+    const now = Date.now();
+    if (now - this.lastDiskSpaceCheck < this.DISK_SPACE_CHECK_INTERVAL_MS) {
+      return this.hasDiskSpace;
+    }
+    this.lastDiskSpaceCheck = now;
+    try {
+      const stats = fs2.statfsSync(logDir);
+      const availableBytes = stats.bavail * stats.bsize;
+      if (availableBytes < this.MIN_DISK_SPACE_BYTES) {
+        this.hasDiskSpace = false;
+        try {
+          process.stderr.write(
+            `[pi-research] Insufficient disk space for logging: ${Math.round(availableBytes / 1024 / 1024)}MB available, minimum ${this.MIN_DISK_SPACE_BYTES / 1024 / 1024}MB required
+`
+          );
+        } catch {
+        }
+      } else {
+        this.hasDiskSpace = true;
+      }
+    } catch (_error) {
+      this.hasDiskSpace = true;
+    }
+    return this.hasDiskSpace;
+  }
+};
+
+// src/utils/stdio-capture.ts
+import { createRequire } from "node:module";
+import { TextDecoder } from "node:util";
+var fs3 = createRequire(import.meta.url)("node:fs");
+var sessionCaptureStates = /* @__PURE__ */ new Map();
+var unkeyedCaptureDepth = 0;
+var isAnyLoggerCapturingOutput = false;
+var captureStack = [];
+function recomputeGlobalCapturing() {
+  isAnyLoggerCapturingOutput = unkeyedCaptureDepth > 0 || Array.from(sessionCaptureStates.values()).some((v) => v);
+}
+function isSessionCapturing(sessionId) {
+  if (sessionId) {
+    return sessionCaptureStates.get(sessionId) ?? false;
+  }
+  return isAnyLoggerCapturingOutput;
+}
+function setSessionCapturing(sessionId, capturing) {
+  sessionCaptureStates.set(sessionId, capturing);
+  if (capturing) {
+    isAnyLoggerCapturingOutput = true;
+  } else {
+    recomputeGlobalCapturing();
+  }
+}
+var NATIVE_LOG_PATTERNS = [
+  "Warning:",
+  "Error:",
+  "Dawn",
+  "ONNX",
+  "ort",
+  "maxDynamicStorageBuffersPerPipelineLayout",
+  "maxComputeWorkgroupStorageSize",
+  "allocation limit",
+  "artificially",
+  "reduced from",
+  "dynamic offset allocation limit"
+];
+var COMPLEX_TUI_PATTERNS = [
+  "\x1B[H",
+  // Home
+  "\x1B[2J",
+  // Clear screen
+  "\x1B[J",
+  // Clear to end
+  "\x1B[K",
+  // Clear line
+  "\x1B[?25",
+  // Cursor visibility
+  "\x1B[?1000",
+  // Mouse tracking
+  "\x1B[?1002",
+  "\x1B[?1003",
+  "\x1B[?1006",
+  "\x1B[?2004",
+  // Bracketed paste
+  "\x1B[<u",
+  // Kitty protocol
+  "\x1B[>4;0m"
+  // xterm modifyOtherKeys
+];
+var BOX_DRAWING_CHARS = /[─│┌┐└┘├┤┬┴┼═║╔╗╚╝╠╣╦╩╬╴╵╶╷╭╮╯╰╱╲╳]/;
+function isComplexTui(message) {
+  if (!message.includes("\x1B[")) {
+    return false;
+  }
+  for (const pattern of COMPLEX_TUI_PATTERNS) {
+    if (message.includes(pattern)) {
+      return true;
+    }
+  }
+  if (/\u001b\[\d+;\d+H/.test(message) || /\u001b\[\d+[ABCD]/.test(message)) {
+    return true;
+  }
+  return false;
+}
+function isNativeLog(message) {
+  return NATIVE_LOG_PATTERNS.some((pattern) => message.includes(pattern));
+}
+function isBoxDrawing(message) {
+  return BOX_DRAWING_CHARS.test(message);
+}
+function shouldRedirectStderr(stat) {
+  return !stat.isFIFO() && !stat.isSocket();
+}
+function createConsolePatch(level, logFile, hasSufficientDiskSpace) {
+  return (...args) => {
+    if (!hasSufficientDiskSpace()) {
+      return;
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const entry = {
+      timestamp,
+      level: `CONSOLE_${level.toUpperCase()}`,
+      ...getLogContext(),
+      // Redact secrets + bound size, matching Logger.emit(); captured console
+      // output can echo auth headers / tokens from dependencies.
+      message: redactSecrets(args.map(formatArg).join(" "))
+    };
+    try {
+      fs3.appendFileSync(logFile, `${safeJsonStringify(entry)}
+`);
+    } catch {
+    }
+  };
+}
+async function captureStdio(logFile, hasSufficientDiskSpace, task, sessionId) {
+  const sessionCapturing = sessionId ? isSessionCapturing(sessionId) : false;
+  if (!logFile || sessionCapturing || !sessionId && isAnyLoggerCapturingOutput) {
+    return await task();
+  }
+  if (sessionId) {
+    setSessionCapturing(sessionId, true);
+  } else {
+    unkeyedCaptureDepth++;
+    isAnyLoggerCapturingOutput = true;
+  }
+  const stderrDecoder = new TextDecoder();
+  const stdoutDecoder = new TextDecoder();
+  const fd1SyncDecoder = new TextDecoder();
+  const fd2SyncDecoder = new TextDecoder();
+  const originalStderrWrite = process.stderr.write;
+  const originalStdoutWrite = process.stdout.write;
+  const originalFsWriteSync = fs3.writeSync;
+  const originalConsole = {
+    log: console.log,
+    info: console.info,
+    warn: console.warn,
+    error: console.error,
+    debug: console.debug
+  };
+  let savedFd2 = -1;
+  let fd2Redirected = false;
+  if (process.platform !== "win32") {
+    try {
+      const stat = fs3.fstatSync(2);
+      if (shouldRedirectStderr(stat)) {
+        savedFd2 = fs3.openSync("/dev/fd/2", "a");
+        fs3.closeSync(2);
+        const newFd = fs3.openSync(logFile, "a", 384);
+        if (newFd === 2) {
+          fd2Redirected = true;
+        } else {
+          if (newFd >= 0) fs3.closeSync(newFd);
+          try {
+            const r = fs3.openSync(`/dev/fd/${savedFd2}`, "a");
+            if (r !== 2 && r >= 0) fs3.closeSync(r);
+          } catch {
+          }
+          try {
+            fs3.closeSync(savedFd2);
+          } catch {
+          }
+          savedFd2 = -1;
+        }
+      }
+    } catch {
+    }
+  }
+  console.log = createConsolePatch("log", logFile, hasSufficientDiskSpace);
+  console.info = createConsolePatch("info", logFile, hasSufficientDiskSpace);
+  console.warn = createConsolePatch("warn", logFile, hasSufficientDiskSpace);
+  console.error = createConsolePatch("error", logFile, hasSufficientDiskSpace);
+  console.debug = createConsolePatch("debug", logFile, hasSufficientDiskSpace);
+  process.stderr.write = (chunk, encodingOrCb, callback) => {
+    const cb = typeof encodingOrCb === "function" ? encodingOrCb : callback;
+    const message = typeof chunk === "string" ? chunk : stderrDecoder.decode(chunk, { stream: true });
+    if (message.length === 0) {
+      if (typeof cb === "function") cb();
+      return true;
+    }
+    if (!hasSufficientDiskSpace()) {
+      if (typeof cb === "function") cb();
+      return true;
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const entry = {
+      timestamp,
+      level: "STDERR",
+      ...getLogContext(),
+      message: redactSecrets(message.trim())
+    };
+    try {
+      fs3.appendFileSync(logFile, `${safeJsonStringify(entry)}
+`);
+    } catch {
+    }
+    if (typeof cb === "function") cb();
+    return true;
+  };
+  process.stdout.write = (chunk, encodingOrCb, callback) => {
+    const message = typeof chunk === "string" ? chunk : stdoutDecoder.decode(chunk, { stream: true });
+    const isNative = isNativeLog(message);
+    const complexTui = isComplexTui(message);
+    const boxDrawing = isBoxDrawing(message);
+    const hasAnsi = message.includes("\x1B[");
+    if (isNative && !boxDrawing) {
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      const entry = {
+        timestamp,
+        level: "STDOUT_NATIVE",
+        ...getLogContext(),
+        message: redactSecrets(message.trim())
+      };
+      try {
+        fs3.appendFileSync(logFile, `${safeJsonStringify(entry)}
+`);
+      } catch {
+      }
+      const cb = typeof encodingOrCb === "function" ? encodingOrCb : callback;
+      if (typeof cb === "function") cb();
+      return true;
+    }
+    if (complexTui || boxDrawing) {
+      return originalStdoutWrite.call(process.stdout, chunk, encodingOrCb, callback);
+    }
+    if (!hasAnsi && message.trim().length > 0) {
+      if (!hasSufficientDiskSpace()) {
+        const cb2 = typeof encodingOrCb === "function" ? encodingOrCb : callback;
+        if (typeof cb2 === "function") cb2();
+        return true;
+      }
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      const entry = {
+        timestamp,
+        level: "STDOUT_PLAIN",
+        ...getLogContext(),
+        message: redactSecrets(message.trim())
+      };
+      try {
+        fs3.appendFileSync(logFile, `${safeJsonStringify(entry)}
+`);
+      } catch {
+      }
+      const cb = typeof encodingOrCb === "function" ? encodingOrCb : callback;
+      if (typeof cb === "function") cb();
+      return true;
+    }
+    return originalStdoutWrite.call(process.stdout, chunk, encodingOrCb, callback);
+  };
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(fs3, "writeSync");
+    if (!descriptor || (descriptor.writable || descriptor.set)) {
+      fs3.writeSync = (fd, chunk, ...args) => {
+        if (fd === 1 || fd === 2) {
+          const fdDecoder = fd === 1 ? fd1SyncDecoder : fd2SyncDecoder;
+          const message = typeof chunk === "string" ? chunk : fdDecoder.decode(chunk, { stream: true });
+          if (fd === 2 && message.length === 0) {
+            return typeof chunk === "string" ? Buffer.from(chunk).length : chunk.length;
+          }
+          const isNative = isNativeLog(message);
+          const boxDrawing = isBoxDrawing(message);
+          const complexTui = isComplexTui(message);
+          const hasAnsi = message.includes("\x1B[");
+          const shouldDivert = fd === 2 || isNative && !boxDrawing && !complexTui || !hasAnsi && !boxDrawing && message.trim().length > 0;
+          if (shouldDivert) {
+            if (!hasSufficientDiskSpace()) {
+              return typeof chunk === "string" ? Buffer.from(chunk).length : chunk.length;
+            }
+            const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+            const entry = {
+              timestamp,
+              level: fd === 1 ? "FS_WRITE_SYNC_STDOUT" : "FS_WRITE_SYNC_STDERR",
+              ...getLogContext(),
+              message: redactSecrets(message.trim())
+            };
+            try {
+              fs3.appendFileSync(logFile, `${safeJsonStringify(entry)}
+`);
+            } catch {
+            }
+            return typeof chunk === "string" ? Buffer.from(chunk).length : chunk.length;
+          }
+        }
+        return originalFsWriteSync.apply(fs3, [fd, chunk, ...args]);
+      };
+    }
+  } catch (_e) {
+  }
+  const frame = {
+    retired: false,
+    restore: () => {
+      process.stderr.write = originalStderrWrite;
+      process.stdout.write = originalStdoutWrite;
+      try {
+        fs3.writeSync = originalFsWriteSync;
+      } catch {
+      }
+      console.log = originalConsole.log;
+      console.info = originalConsole.info;
+      console.warn = originalConsole.warn;
+      console.error = originalConsole.error;
+      console.debug = originalConsole.debug;
+      if (fd2Redirected && savedFd2 >= 0) {
+        try {
+          fs3.closeSync(2);
+          const r = fs3.openSync(`/dev/fd/${savedFd2}`, "a");
+          if (r !== 2 && r >= 0) {
+          }
+          try {
+            fs3.closeSync(savedFd2);
+          } catch {
+          }
+        } catch {
+        }
+      }
+    }
+  };
+  captureStack.push(frame);
+  try {
+    return await task();
+  } finally {
+    if (sessionId) {
+      setSessionCapturing(sessionId, false);
+    } else {
+      unkeyedCaptureDepth = Math.max(0, unkeyedCaptureDepth - 1);
+      recomputeGlobalCapturing();
+    }
+    frame.retired = true;
+    while (captureStack.length > 0 && captureStack[captureStack.length - 1].retired) {
+      captureStack.pop().restore();
+    }
+  }
+}
+
+// src/logger.ts
+var LogWriter = class _LogWriter {
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  filePath;
+  buffer = [];
+  bufferBytes = 0;
+  flushScheduled = false;
+  flushing = false;
+  // Flush eagerly once buffered output gets large, to bound memory and latency
+  // during sustained bursts instead of waiting for the scheduled tick.
+  static MAX_BUFFER_BYTES = 256 * 1024;
+  /** Queue a line for asynchronous, non-blocking write (INFO/DEBUG path). */
+  enqueue(line) {
+    this.buffer.push(line);
+    this.bufferBytes += line.length;
+    if (this.bufferBytes >= _LogWriter.MAX_BUFFER_BYTES) {
+      void this.flush();
+      return;
+    }
+    this.scheduleFlush();
+  }
+  scheduleFlush() {
+    if (this.flushScheduled || this.flushing) return;
+    this.flushScheduled = true;
+    setTimeout(() => {
+      void this.flush();
+    }, 0);
+  }
+  /** Asynchronously write buffered lines. Never blocks the event loop. */
+  async flush() {
+    this.flushScheduled = false;
+    if (this.flushing || this.buffer.length === 0) return;
+    this.flushing = true;
+    try {
+      while (this.buffer.length > 0) {
+        const batch = this.buffer.join("");
+        this.buffer.length = 0;
+        this.bufferBytes = 0;
+        try {
+          await appendFile(this.filePath, batch);
+        } catch {
+        }
+      }
+    } finally {
+      this.flushing = false;
+      if (this.buffer.length > 0) this.scheduleFlush();
+    }
+  }
+  /**
+   * Drain buffered lines, then write `line`, all synchronously and in order.
+   * Used for WARN/ERROR so the critical line (and all lines queued in the buffer
+   * before it) are on disk before this call returns.
+   *
+   * Ordering caveat: if a large INFO/DEBUG burst already cleared the buffer into
+   * an in-flight async appendFile, drainSync() will find the buffer empty and
+   * the WARN line will be appended before that in-flight batch completes. In
+   * practice this means WARN/ERROR lines may appear slightly before the last
+   * flush of the preceding INFO/DEBUG burst. Acceptable for a diagnostic log.
+   */
+  writeSync(line) {
+    this.drainSync();
+    try {
+      appendFileSync(this.filePath, line);
+    } catch {
+    }
+  }
+  /** Synchronously flush all buffered lines (graceful exit / tests / pre-sync-write). */
+  drainSync() {
+    if (this.buffer.length === 0) return;
+    const batch = this.buffer.join("");
+    this.buffer.length = 0;
+    this.bufferBytes = 0;
+    try {
+      appendFileSync(this.filePath, batch);
+    } catch {
+    }
+  }
+};
+var logWriters = /* @__PURE__ */ new Map();
+var exitDrainRegistered = false;
+function getLogWriter(filePath) {
+  let writer = logWriters.get(filePath);
+  if (!writer) {
+    writer = new LogWriter(filePath);
+    logWriters.set(filePath, writer);
+  }
+  if (!exitDrainRegistered) {
+    exitDrainRegistered = true;
+    process.on("exit", () => {
+      for (const w of logWriters.values()) {
+        try {
+          w.drainSync();
+        } catch {
+        }
+      }
+    });
+  }
+  return writer;
+}
+var LOGGER_BRAND = /* @__PURE__ */ Symbol.for("pi-research.Logger");
+var Logger = class {
+  verbose;
+  consoleLog;
+  logFile;
+  logDir;
+  sessionId;
+  [LOGGER_BRAND] = true;
+  rotation;
+  diskSpaceChecker;
+  constructor(options = {}) {
+    this.verbose = options.verbose ?? isVerboseFromEnv();
+    this.consoleLog = options.consoleLog ?? process.env["PI_RESEARCH_CONSOLE_LOG"] === "true";
+    this.logFile = options.logFilePath ?? buildDefaultDebugLogPath();
+    this.logDir = path3.dirname(this.logFile);
+    this.sessionId = options.researchRunId;
+    this.rotation = new LogRotation(this);
+    this.diskSpaceChecker = new DiskSpaceChecker();
+    try {
+      if (!existsSync2(this.logDir)) {
+        mkdirSync(this.logDir, { recursive: true, mode: 448 });
+      }
+      try {
+        closeSync2(openSync2(this.logFile, "wx", 384));
+      } catch {
+      }
+    } catch {
+    }
+  }
+  emit(level, ...args) {
+    if (!this.verbose && (level === "INFO" /* INFO */ || level === "DEBUG" /* DEBUG */)) {
+      return;
+    }
+    if (!this.diskSpaceChecker.checkDiskSpace(this.logDir)) {
+      return;
+    }
+    this.rotation.checkAndRotate(this.logFile, this.logDir);
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const firstError = args.find((arg) => arg instanceof Error);
+    const message = redactSecrets(args.map(formatArg).join(" "));
+    const entry = {
+      timestamp,
+      level,
+      ...getLogContext(),
+      // Every process writes to the SAME log file — up to three concurrent research
+      // runs plus the elected browser-pool leader — and until this field existed
+      // there was nothing to tell their lines apart. Reconstructing a lock
+      // contention from the log then meant inferring process boundaries from
+      // timing, which is guesswork: two runs a second apart interleave into what
+      // reads like one process contradicting itself. Twelve bytes a line buys
+      // attributable forensics.
+      //
+      // After the context spread, not before: which process wrote a line is not
+      // something a scoped context gets to claim otherwise.
+      pid: process.pid,
+      message,
+      ...firstError ? { errorMessage: redactSecrets(firstError.message), errorStack: redactSecrets(firstError.stack ?? "") } : {}
+    };
+    const line = `${safeJsonStringify(entry)}
+`;
+    const writer = getLogWriter(this.logFile);
+    if (level === "ERROR" /* ERROR */ || level === "WARN" /* WARN */) {
+      writer.writeSync(line);
+    } else {
+      writer.enqueue(line);
+    }
+    if (this.consoleLog) {
+      const color = level === "ERROR" /* ERROR */ ? "\x1B[31m" : level === "WARN" /* WARN */ ? "\x1B[33m" : level === "DEBUG" /* DEBUG */ ? "\x1B[90m" : "\x1B[36m";
+      const reset = "\x1B[0m";
+      const msg = stripTerminalEscapes(message.replace(/[\r\n]/g, ""));
+      const rawSid = this.sessionId ?? "";
+      const sid = rawSid.replace(/[\r\n]/g, "");
+      const prefix = sid ? `[${sid}] ` : "";
+      console.log(`${color}${timestamp} ${level} ${prefix}${reset}${msg}`);
+    }
+  }
+  async runCapturingStderr(task) {
+    return captureStdio(
+      this.logFile,
+      () => this.diskSpaceChecker.checkDiskSpace(this.logDir),
+      task,
+      this.sessionId
+    );
+  }
+  log(...args) {
+    this.emit("INFO" /* INFO */, ...args);
+  }
+  info(...args) {
+    this.emit("INFO" /* INFO */, ...args);
+  }
+  error(...args) {
+    const errArg = args.find((arg) => arg instanceof Error);
+    if (errArg) {
+      const context = getLogContext();
+      errorTracker.trackError(errArg, context);
+    }
+    this.emit("ERROR" /* ERROR */, ...args);
+  }
+  warn(...args) {
+    this.emit("WARN" /* WARN */, ...args);
+  }
+  debug(...args) {
+    this.emit("DEBUG" /* DEBUG */, ...args);
+  }
+  clear() {
+    this.flushSync();
+    this.rotation.clearLogs(this.logFile, this.logDir);
+  }
+  /**
+   * Synchronously flush this logger's buffered INFO/DEBUG output to disk.
+   * Use before reading the log file directly (tests) or during shutdown.
+   */
+  flushSync() {
+    getLogWriter(this.logFile).drainSync();
+  }
+  getLogFilePath() {
+    return this.logFile;
+  }
+  isVerbose() {
+    return this.verbose;
+  }
+};
+var loggerContext = new AsyncLocalStorage3();
+var sessionLoggers = /* @__PURE__ */ new Map();
+var _globalLogger = null;
+function getLogger(sessionId) {
+  const contextLogger = loggerContext.getStore();
+  if (contextLogger) return contextLogger;
+  if (sessionId) {
+    let lg = sessionLoggers.get(sessionId);
+    if (!lg) {
+      lg = new Logger({
+        verbose: isVerboseFromEnv(),
+        researchRunId: sessionId,
+        consoleLog: process.env["PI_RESEARCH_CONSOLE_LOG"] === "true"
+      });
+      sessionLoggers.set(sessionId, lg);
+    }
+    return lg;
+  }
+  if (!_globalLogger) {
+    _globalLogger = new Logger({
+      verbose: isVerboseFromEnv(),
+      consoleLog: process.env["PI_RESEARCH_CONSOLE_LOG"] === "true"
+    });
+  }
+  return _globalLogger;
+}
+var logger = {
+  log: (...args) => getLogger().log(...args),
+  info: (...args) => getLogger().info(...args),
+  error: (...args) => getLogger().error(...args),
+  warn: (...args) => getLogger().warn(...args),
+  debug: (...args) => getLogger().debug(...args),
+  clear: () => getLogger().clear(),
+  flushSync: () => getLogger().flushSync(),
+  runCapturingStderr: (task) => getLogger().runCapturingStderr(task)
+};
+
+// src/utils/metrics.ts
+import { AsyncLocalStorage as AsyncLocalStorage4 } from "node:async_hooks";
+var MetricsRegistry = class {
+  counters = /* @__PURE__ */ new Map();
+  gauges = /* @__PURE__ */ new Map();
+  histograms = /* @__PURE__ */ new Map();
+  serializeLabels(labels) {
+    if (!labels) return "";
+    const keys = Object.keys(labels).sort();
+    return keys.map((k) => `${k}="${labels[k]}"`).join(",");
+  }
+  getKey(name, labels) {
+    const labelStr = this.serializeLabels(labels);
+    return labelStr ? `${name}{${labelStr}}` : name;
+  }
+  increment(name, value = 1, labels) {
+    const key = this.getKey(name, labels);
+    this.counters.set(key, (this.counters.get(key) ?? 0) + value);
+    if (name.startsWith("llm_")) {
+      logger.debug(`[Metrics] Incremented ${name} by ${value}${labels ? ` (labels: ${JSON.stringify(labels)})` : ""}`);
+    }
+  }
+  setGauge(name, value, labels) {
+    this.gauges.set(this.getKey(name, labels), value);
+  }
+  observe(name, value, labels) {
+    if (!Number.isFinite(value)) return;
+    const key = this.getKey(name, labels);
+    let entry = this.histograms.get(key);
+    if (!entry) {
+      entry = { values: [], pointer: 0, limit: 1e4, dirty: true, cached: null };
+      this.histograms.set(key, entry);
+    }
+    entry.dirty = true;
+    if (entry.values.length < entry.limit) {
+      entry.values.push(value);
+    } else {
+      entry.values[entry.pointer] = value;
+      entry.pointer = (entry.pointer + 1) % entry.limit;
+    }
+  }
+  async measure(name, action, labels) {
+    const start = process.hrtime.bigint();
+    try {
+      const result = await action();
+      this.observe(name, Number(process.hrtime.bigint() - start) / 1e6, labels);
+      return result;
+    } catch (error) {
+      this.observe(name, Number(process.hrtime.bigint() - start) / 1e6, { ...labels, error: "true" });
+      this.increment(`${name}_errors_total`, 1, labels);
+      throw error;
+    }
+  }
+  percentile(sorted, pct) {
+    const len = sorted.length;
+    if (len === 0) return 0;
+    if (len === 1) return sorted[0] ?? 0;
+    if (pct <= 0) return sorted[0] ?? 0;
+    if (pct >= 100) return sorted[len - 1] ?? 0;
+    const rank = pct / 100 * (len - 1);
+    const lo = Math.floor(rank);
+    const hi = Math.ceil(rank);
+    const w = rank - lo;
+    return (sorted[lo] ?? 0) + ((sorted[hi] ?? 0) - (sorted[lo] ?? 0)) * w;
+  }
+  getSnapshot() {
+    const snap = { counters: {}, gauges: {}, histograms: {} };
+    for (const [k, v] of this.counters) snap.counters[k] = v;
+    for (const [k, v] of this.gauges) snap.gauges[k] = v;
+    for (const [k, entry] of this.histograms) {
+      if (entry.values.length === 0) continue;
+      if (!entry.dirty && entry.cached) {
+        snap.histograms[k] = entry.cached;
+        continue;
+      }
+      const vals = entry.values;
+      const sorted = vals.slice().sort((a, b) => a - b);
+      const sum = sorted.reduce((a, b) => a + b, 0);
+      const histogram = {
+        count: sorted.length,
+        min: sorted[0] ?? 0,
+        max: sorted[sorted.length - 1] ?? 0,
+        avg: sum / sorted.length,
+        p50: this.percentile(sorted, 50),
+        p90: this.percentile(sorted, 90),
+        p95: this.percentile(sorted, 95),
+        p99: this.percentile(sorted, 99)
+      };
+      entry.cached = histogram;
+      entry.dirty = false;
+      snap.histograms[k] = histogram;
+    }
+    return snap;
+  }
+  clear() {
+    this.counters.clear();
+    this.gauges.clear();
+    this.histograms.clear();
+  }
+};
+var runRegistryStorage = new AsyncLocalStorage4();
+var MAX_RUN_HISTORY = 10;
+var SessionMetrics = class {
+  _session = new MetricsRegistry();
+  _sessionStartedAt = Date.now();
+  _runHistory = [];
+  getActive() {
+    return runRegistryStorage.getStore() ?? this._session;
+  }
+  // ── Emit API (routes to active registry) ──────────────────────────────
+  increment(name, value = 1, labels) {
+    this.getActive().increment(name, value, labels);
+  }
+  setGauge(name, value, labels) {
+    this.getActive().setGauge(name, value, labels);
+  }
+  observe(name, value, labels) {
+    this.getActive().observe(name, value, labels);
+  }
+  async measure(name, action, labels) {
+    return this.getActive().measure(name, action, labels);
+  }
+  /**
+   * Emit API that ALWAYS targets the session registry, ignoring any active run
+   * context.
+   *
+   * For process-lifetime callbacks that happen to be *registered* during a run.
+   * AsyncLocalStorage resolves at emit time from the async resource that fired,
+   * and for a listener installed on a long-lived emitter that resource is the
+   * emitter itself — created, for every lazily-initialized subsystem here, inside
+   * whichever run first needed it. So a worker-pool error handler installed during
+   * run 1 keeps writing into run 1's registry for the rest of the process: those
+   * counts disappear from every later run's summary (the registry was discarded
+   * when the run ended) and the dead registry stays reachable through the closure.
+   *
+   * Use this only where the emission is genuinely process-scoped. Anything that
+   * describes work a run asked for belongs in the run registry, which is what the
+   * plain emit methods above give you.
+   */
+  session = {
+    increment: (name, value = 1, labels) => this._session.increment(name, value, labels),
+    setGauge: (name, value, labels) => this._session.setGauge(name, value, labels),
+    observe: (name, value, labels) => this._session.observe(name, value, labels)
+  };
+  // ── Session-level read API ─────────────────────────────────────────────
+  /** Snapshot of the session registry (infrastructure / cross-run metrics). */
+  getSessionSnapshot() {
+    return this._session.getSnapshot();
+  }
+  /** Millisecond timestamp when this session started or was last reset. */
+  getSessionStartedAt() {
+    return this._sessionStartedAt;
+  }
+  /**
+   * Ordered run summaries, oldest first. Capped at MAX_RUN_HISTORY entries.
+   * Returns a shallow copy so callers cannot mutate the internal list.
+   */
+  getRunHistory() {
+    return [...this._runHistory];
+  }
+  // ── Run lifecycle API ──────────────────────────────────────────────────
+  /**
+   * Append a completed run's snapshot to the history.
+   * Call this AFTER runWithRunRegistry returns so the write lands in session
+   * scope. Automatically evicts the oldest entry when the cap is reached.
+   */
+  recordRunSummary(summary) {
+    this._runHistory.push(summary);
+    if (this._runHistory.length > MAX_RUN_HISTORY) {
+      this._runHistory.shift();
+    }
+  }
+  // ── Reset API ──────────────────────────────────────────────────────────
+  /**
+   * Clear the session registry, run history, and session start timestamp.
+   * In-flight run registries are NOT affected.
+   */
+  clearSession() {
+    this._session.clear();
+    this._runHistory = [];
+    this._sessionStartedAt = Date.now();
+  }
+};
+var metrics = new SessionMetrics();
+
+// src/web-research/scraper-types.ts
+var MAX_HTML_SIZE = 25 * 1024 * 1024;
+var MAX_PDF_SIZE = 100 * 1024 * 1024;
+
+// src/web-research/pdf-extraction.ts
+var MODULE_DIR = dirname2(fileURLToPath(import.meta.url));
+var PdfExtractError = class extends Error {
+  kind;
+  constructor(kind, message, options) {
+    super(message, options);
+    this.name = "PdfExtractError";
+    this.kind = kind;
+  }
+};
+var pdfModulePromise = null;
+function loadPdfModule() {
+  if (pdfModulePromise === null) {
+    pdfModulePromise = import("pdf-oxide-wasm");
+  }
+  return pdfModulePromise;
+}
+async function parsePdfCore(bytes) {
+  if (bytes.length > MAX_PDF_SIZE) {
+    const sizeMB = Math.round(bytes.length / 1024 / 1024);
+    throw new PdfExtractError("size_exceeded", `PDF too large (${sizeMB}MB, max 100MB)`);
+  }
+  let WasmPdfDocument;
+  try {
+    ({ WasmPdfDocument } = await loadPdfModule());
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    throw new PdfExtractError(
+      "native_module_unavailable",
+      `PDF extraction unavailable (pdf-oxide-wasm failed to load: ${msg})`,
+      { cause: e }
+    );
+  }
+  try {
+    const doc = new WasmPdfDocument(bytes);
+    try {
+      const pageCount = doc.pageCount();
+      let markdown = `# PDF Document
+
+**Pages:** ${pageCount}
+
+`;
+      try {
+        markdown += doc.toMarkdownAll();
+      } catch {
+        for (let i = 0; i < pageCount; i++) {
+          markdown += `## Page ${i + 1}
+
+${doc.toMarkdown(i)}
+
+`;
+        }
+      }
+      return { markdown, pageCount };
+    } finally {
+      doc.free();
+    }
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    throw new PdfExtractError("extraction_failed", `Could not extract content from PDF (${msg})`, { cause: e });
+  }
+}
+
+// src/web-research/pdf-extract-worker.ts
+if (parentPort !== null) {
+  const port = parentPort;
+  port.on("message", (msg) => {
+    void (async () => {
+      try {
+        const result = await parsePdfCore(msg.bytes);
+        port.postMessage({ id: msg.id, ok: true, markdown: result.markdown, pageCount: result.pageCount });
+      } catch (e) {
+        if (e instanceof PdfExtractError) {
+          port.postMessage({ id: msg.id, ok: false, kind: e.kind, message: e.message });
+        } else {
+          port.postMessage({
+            id: msg.id,
+            ok: false,
+            kind: "extraction_failed",
+            message: e instanceof Error ? e.message : String(e)
+          });
+        }
+      }
+    })();
+  });
+}