mcp-researchpowerpack 7.0.11 → 7.0.13

package/dist/src/tools/scrape.js

@@ -1,50 +1,2580 @@
-import { Effect, Either } from "effect";
-import {
-  SCRAPER,
-  CONCURRENCY,
-  getCapabilities,
-  getMissingEnvMessage,
-  parseEnv
-} from "../config/index.js";
-import {
-  rawScrapeLinksParamsSchema,
-  smartScrapeLinksParamsSchema
-} from "../schemas/scrape-links.js";
-import { buildScrapeDoProxyUrl, isTerminalReaderError } from "../clients/jina.js";
-import { MarkdownCleaner } from "../services/markdown-cleaner.js";
-import { createLLMProcessor } from "../services/llm-processor.js";
-import { removeMetaTags } from "../utils/markdown-formatter.js";
-import { extractReadableContent } from "../utils/content-extractor.js";
-import { classifyError, ErrorCode } from "../utils/errors.js";
-import { isDocumentUrl } from "../utils/source-type.js";
-import { assessMarkdownQuality } from "../utils/content-quality.js";
-import { runExternalEffect } from "../effect/runtime.js";
-import {
-  JinaService,
+// src/tools/scrape.ts
+import { Effect as Effect3, Either } from "effect";
+
+// src/config/index.ts
+import { Logger } from "mcp-use";
+
+// src/version.ts
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+var DEFAULT_PACKAGE_INFO = {
+  version: "3.9.5",
+  name: "mcp-researchpowerpack-http",
+  description: "Research Powerpack MCP Server"
+};
+var packageJson = { ...DEFAULT_PACKAGE_INFO };
+try {
+  if (typeof import.meta.url === "string" && import.meta.url.startsWith("file:")) {
+    const _require = createRequire(import.meta.url);
+    const _dirname = dirname(fileURLToPath(import.meta.url));
+    try {
+      packageJson = _require(join(_dirname, "..", "package.json"));
+    } catch {
+      packageJson = _require(join(_dirname, "..", "..", "package.json"));
+    }
+  }
+} catch {
+}
+var VERSION = packageJson.version;
+var PACKAGE_NAME = packageJson.name;
+var PACKAGE_DESCRIPTION = packageJson.description;
+var USER_AGENT_VERSION = `${PACKAGE_NAME}/${VERSION}`;
+
+// src/config/index.ts
+function safeParseInt(value, defaultVal, min, max) {
+  const logger2 = Logger.get("config");
+  if (!value) {
+    return defaultVal;
+  }
+  const parsed = parseInt(value, 10);
+  if (isNaN(parsed)) {
+    logger2.warn(`Invalid number "${value}", using default ${defaultVal}`);
+    return defaultVal;
+  }
+  if (parsed < min) {
+    logger2.warn(`Value ${parsed} below minimum ${min}, clamping to ${min}`);
+    return min;
+  }
+  if (parsed > max) {
+    logger2.warn(`Value ${parsed} above maximum ${max}, clamping to ${max}`);
+    return max;
+  }
+  return parsed;
+}
+var cachedEnv = null;
+function parseEnv() {
+  if (cachedEnv) return cachedEnv;
+  cachedEnv = {
+    SCRAPER_API_KEY: process.env.SCRAPEDO_API_KEY || "",
+    SEARCH_API_KEY: process.env.SERPER_API_KEY || void 0,
+    REDDIT_CLIENT_ID: process.env.REDDIT_CLIENT_ID || void 0,
+    REDDIT_CLIENT_SECRET: process.env.REDDIT_CLIENT_SECRET || void 0,
+    JINA_API_KEY: process.env.JINA_API_KEY || void 0,
+    KERNEL_API_KEY: process.env.KERNEL_API_KEY || void 0,
+    KERNEL_PROJECT: process.env.KERNEL_PROJECT || void 0
+  };
+  return cachedEnv;
+}
+function getCapabilities() {
+  const env = parseEnv();
+  return {
+    reddit: !!(env.REDDIT_CLIENT_ID && env.REDDIT_CLIENT_SECRET),
+    search: !!(env.SEARCH_API_KEY || env.JINA_API_KEY),
+    serperSearch: !!env.SEARCH_API_KEY,
+    jina: !!env.JINA_API_KEY,
+    scraping: !!env.SCRAPER_API_KEY,
+    kernel: !!env.KERNEL_API_KEY,
+    llmExtraction: getLLMConfigStatus().configured
+  };
+}
+function getMissingEnvMessage(capability) {
+  const messages = {
+    reddit: '\u274C **Reddit scraping unavailable.** Set `REDDIT_CLIENT_ID` and `REDDIT_CLIENT_SECRET` to enable threaded Reddit post fetching in `raw-scrape-links` and `smart-scrape-links`.\n\n\u{1F449} Create a Reddit app at: https://www.reddit.com/prefs/apps (select "script" type)',
+    search: "\u274C **Search unavailable.** Set `SERPER_API_KEY` or `JINA_API_KEY` to enable `raw-web-search` and `smart-web-search`.\n\n\u{1F449} Serper provides Google SERPs; Jina Search is used as a fallback/search-only provider.",
+    serperSearch: "\u274C **Serper search unavailable.** Set `SERPER_API_KEY` to enable Google-backed primary search.",
+    jina: "\u274C **Jina unavailable.** Set `JINA_API_KEY` to enable Jina Search and authenticated Jina Reader requests.",
+    scraping: "\u26A0\uFE0F **Scrape.do proxy fallback unavailable.** Set `SCRAPEDO_API_KEY` to enable Jina Reader retries through Scrape.do proxy mode.\n\n\u{1F449} Sign up at: https://scrape.do (1,000 free credits)",
+    kernel: "\u274C **Kernel browser rendering unavailable.** Set `KERNEL_API_KEY` to enable optional browser-render fallback for raw/smart scraping.",
+    llmExtraction: "\u26A0\uFE0F **AI extraction disabled.** Set `LLM_API_KEY`, `LLM_BASE_URL`, and `LLM_MODEL` to enable `smart-web-search` and `smart-scrape-links`.\n\nUse the raw tools when you need markdown without LLM processing."
+  };
+  return messages[capability];
+}
+var CONCURRENCY = {
+  SEARCH: safeParseInt(process.env.CONCURRENCY_SEARCH, 50, 1, 200),
+  SCRAPER: safeParseInt(process.env.CONCURRENCY_SCRAPER, 50, 1, 200),
+  JINA_READER: safeParseInt(process.env.CONCURRENCY_JINA_READER, 50, 1, 200),
+  REDDIT: safeParseInt(process.env.CONCURRENCY_REDDIT, 50, 1, 200),
+  LLM_EXTRACTION: safeParseInt(process.env.LLM_CONCURRENCY, 50, 1, 200),
+  KERNEL: safeParseInt(process.env.CONCURRENCY_KERNEL, 3, 1, 20)
+};
+var SCRAPER = {
+  BATCH_SIZE: 30,
+  EXTRACTION_PREFIX: "Extract from document only \u2014 never hallucinate or add external knowledge.",
+  EXTRACTION_SUFFIX: "First line = content, not preamble. No confirmation messages."
+};
+var REDDIT = {
+  BATCH_SIZE: 10,
+  MAX_WORDS_PER_POST: 5e4,
+  MAX_WORDS_TOTAL: 5e5,
+  MIN_POSTS: 1,
+  MAX_POSTS: 50,
+  RETRY_COUNT: 5,
+  RETRY_DELAYS: [2e3, 4e3, 8e3, 16e3, 32e3]
+};
+var cachedLlmConfigStatus = null;
+function getLLMConfigStatus() {
+  if (cachedLlmConfigStatus) return cachedLlmConfigStatus;
+  const apiKeyPresent = !!process.env.LLM_API_KEY?.trim();
+  const baseUrlPresent = !!process.env.LLM_BASE_URL?.trim();
+  const modelPresent = !!process.env.LLM_MODEL?.trim();
+  const missingVars = [];
+  if (!apiKeyPresent) missingVars.push("LLM_API_KEY");
+  if (!baseUrlPresent) missingVars.push("LLM_BASE_URL");
+  if (!modelPresent) missingVars.push("LLM_MODEL");
+  const configured = missingVars.length === 0;
+  cachedLlmConfigStatus = {
+    configured,
+    apiKeyPresent,
+    baseUrlPresent,
+    modelPresent,
+    missingVars,
+    error: configured ? null : `LLM disabled: missing ${missingVars.join(", ")}`
+  };
+  return cachedLlmConfigStatus;
+}
+var cachedLlmExtraction = null;
+function getLlmExtraction() {
+  if (cachedLlmExtraction) return cachedLlmExtraction;
+  const apiKey = process.env.LLM_API_KEY?.trim() || "";
+  const baseUrl = process.env.LLM_BASE_URL?.trim();
+  const model = process.env.LLM_MODEL?.trim();
+  const fallbackModel = process.env.LLM_FALLBACK_MODEL?.trim() || "";
+  if (apiKey && !baseUrl) {
+    throw new Error(
+      "LLM_BASE_URL is required when LLM_API_KEY is set. Set LLM_BASE_URL to your OpenAI-compatible endpoint."
+    );
+  }
+  if (apiKey && !model) {
+    throw new Error(
+      "LLM_MODEL is required when LLM_API_KEY is set."
+    );
+  }
+  cachedLlmExtraction = {
+    API_KEY: apiKey,
+    BASE_URL: baseUrl || "",
+    MODEL: model || "",
+    FALLBACK_MODEL: fallbackModel
+  };
+  return cachedLlmExtraction;
+}
+var LLM_EXTRACTION = new Proxy({}, {
+  get(_target, prop) {
+    return getLlmExtraction()[prop];
+  }
+});
+
+// src/schemas/scrape-links.ts
+import { z } from "zod";
+var urlSchema = z.string().url({ message: "scrape: Invalid URL format" }).refine(
+  (url) => url.startsWith("http://") || url.startsWith("https://"),
+  { message: "scrape: URL must use http:// or https://" }
+).describe("A fully-qualified HTTP or HTTPS URL to scrape.");
+var urlsSchema = z.array(urlSchema).min(1, { message: "scrape: At least 1 URL required" }).max(50, { message: "scrape: At most 50 URLs allowed per call" }).describe("URLs to fetch in parallel. Reddit post permalinks (`reddit.com/r/<sub>/comments/<id>/...`) are auto-detected and routed through the Reddit API (threaded post + comments). Non-Reddit URLs use Jina Reader first, then Jina Reader through Scrape.do proxy when configured, then optional Kernel browser rendering for web pages.");
+var rawScrapeLinksParamsSchema = z.object({
+  urls: urlsSchema,
+  extract: z.never().optional()
+}).strict();
+var smartScrapeLinksParamsSchema = z.object({
+  urls: z.array(urlSchema).min(1, { message: "scrape: At least 1 URL required" }).max(50, { message: "scrape: At most 50 URLs allowed per call" }).describe("URLs to fetch and extract in parallel. Reddit post permalinks (`reddit.com/r/<sub>/comments/<id>/...`) are auto-detected and routed through the Reddit API (threaded post + comments). Non-Reddit URLs use Jina Reader first, then Jina Reader through Scrape.do proxy when configured, then optional Kernel browser rendering for web pages. Mix reddit + non-reddit URLs freely; branches run concurrently. Prefer contextually grouped batches \u2014 call this tool multiple times in parallel when URL sets are unrelated."),
+  extract: z.string().min(1, { message: "smart-scrape-links: extract cannot be empty" }).describe(
+    'Required semantic extraction instruction. Describe the SHAPE of what you want, separated by `|`. The extractor classifies each page (docs / github-thread / reddit / marketing / cve / paper / announcement / qa / blog / changelog / release-notes) and adjusts emphasis per type: preserves numbers/versions/stacktraces verbatim from docs and CVE pages, quotes Reddit/HN with attribution plus sentiment distribution, flags what the page did NOT answer in a "Not found" section, and surfaces referenced-but-unscraped URLs in a "Follow-up signals" section. Good examples: "root cause | affected versions | fix | workarounds | timeline"; "pricing tiers | rate limits | enterprise contact | free-tier quotas"; "maintainer decisions | accepted fix commits | stacktraces | resolved version".'
+  )
+}).strict();
+
+// src/utils/logger.ts
+import { Logger as Logger2 } from "mcp-use";
+function getLogger(name) {
+  return Logger2.get(name);
+}
+function mcpLog(level, message, loggerName) {
+  const logger2 = getLogger(loggerName ?? "research-powerpack");
+  switch (level) {
+    case "debug":
+      logger2.debug(message);
+      break;
+    case "info":
+      logger2.info(message);
+      break;
+    case "warning":
+      logger2.warn(message);
+      break;
+    case "error":
+      logger2.error(message);
+      break;
+  }
+}
+
+// src/utils/errors.ts
+var ErrorCode = {
+  // Retryable errors
+  RATE_LIMITED: "RATE_LIMITED",
+  TIMEOUT: "TIMEOUT",
+  NETWORK_ERROR: "NETWORK_ERROR",
+  SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE",
+  // Non-retryable errors
+  AUTH_ERROR: "AUTH_ERROR",
+  INVALID_INPUT: "INVALID_INPUT",
+  NOT_FOUND: "NOT_FOUND",
+  QUOTA_EXCEEDED: "QUOTA_EXCEEDED",
+  UNSUPPORTED_BINARY_CONTENT: "UNSUPPORTED_BINARY_CONTENT",
+  // Internal errors
+  INTERNAL_ERROR: "INTERNAL_ERROR",
+  PARSE_ERROR: "PARSE_ERROR",
+  UNKNOWN_ERROR: "UNKNOWN_ERROR"
+};
+var DEFAULT_RETRY_OPTIONS = {
+  maxRetries: 3,
+  baseDelayMs: 1e3,
+  maxDelayMs: 3e4,
+  retryableStatuses: [408, 429, 500, 502, 503, 504, 510]
+};
+function classifyDomException(error2) {
+  if (error2.name === "AbortError") {
+    return { code: ErrorCode.TIMEOUT, message: "Request timed out", retryable: true };
+  }
+  return { code: ErrorCode.UNKNOWN_ERROR, message: error2.message, retryable: false };
+}
+function classifyByErrorCode(error2) {
+  const errCode = error2.code;
+  if (!errCode) return null;
+  const networkErrorMessages = {
+    ECONNREFUSED: "Connection refused \u2014 service may be down",
+    ECONNRESET: "Connection was reset \u2014 please retry",
+    ECONNABORTED: "Connection aborted \u2014 please retry",
+    ENOTFOUND: "Service not reachable \u2014 check your network",
+    EPIPE: "Connection lost \u2014 please retry",
+    EAI_AGAIN: "DNS lookup failed \u2014 check your network"
+  };
+  if (errCode === "ECONNREFUSED" || errCode === "ENOTFOUND" || errCode === "ECONNRESET") {
+    return { code: ErrorCode.NETWORK_ERROR, message: networkErrorMessages[errCode] || "Network connection failed", retryable: true, cause: error2.message };
+  }
+  if (errCode === "ECONNABORTED" || errCode === "ETIMEDOUT") {
+    return { code: ErrorCode.TIMEOUT, message: networkErrorMessages[errCode] || "Request timed out", retryable: true, cause: error2.message };
+  }
+  return null;
+}
+function classifyByStatusCode(error2) {
+  const status = error2.response?.status || error2.status || error2.statusCode;
+  if (!status) return null;
+  return classifyHttpError(status, error2.message || String(error2));
+}
+function classifyByMessage(message) {
+  const lower = message.toLowerCase();
+  if (lower.includes("timeout") || lower.includes("timed out") || lower.includes("aborterror")) {
+    return { code: ErrorCode.TIMEOUT, message: "Request timed out", retryable: true, cause: message };
+  }
+  if (lower.includes("rate limit") || lower.includes("too many requests")) {
+    return { code: ErrorCode.RATE_LIMITED, message: "Rate limit exceeded", retryable: true, cause: message };
+  }
+  if (message.includes("API_KEY") || message.includes("api_key") || message.includes("Invalid API")) {
+    return { code: ErrorCode.AUTH_ERROR, message: "API key missing or invalid", retryable: false, cause: message };
+  }
+  if (message.includes("JSON") || message.includes("parse") || message.includes("Unexpected token")) {
+    return { code: ErrorCode.PARSE_ERROR, message: "Failed to parse response", retryable: false, cause: message };
+  }
+  return null;
+}
+function classifyFallback(message, cause) {
+  return {
+    code: ErrorCode.UNKNOWN_ERROR,
+    message,
+    retryable: false,
+    cause: cause ? String(cause) : void 0
+  };
+}
+function classifyError(error2) {
+  if (error2 == null) {
+    return { code: ErrorCode.UNKNOWN_ERROR, message: "An unknown error occurred", retryable: false };
+  }
+  if (error2 instanceof DOMException) return classifyDomException(error2);
+  if (!isErrorLike(error2)) {
+    return { code: ErrorCode.UNKNOWN_ERROR, message: String(error2), retryable: false };
+  }
+  return classifyByErrorCode(error2) ?? classifyByStatusCode(error2) ?? classifyByMessage(error2.message ?? String(error2)) ?? classifyFallback(error2.message ?? String(error2), error2.cause);
+}
+function isErrorLike(value) {
+  return typeof value === "object" && value !== null;
+}
+function classifyHttpError(status, message) {
+  switch (status) {
+    case 400:
+      return { code: ErrorCode.INVALID_INPUT, message: "Bad request", retryable: false, statusCode: status };
+    case 401:
+      return { code: ErrorCode.AUTH_ERROR, message: "Invalid API key", retryable: false, statusCode: status };
+    case 403:
+      return { code: ErrorCode.QUOTA_EXCEEDED, message: "Access forbidden or quota exceeded", retryable: false, statusCode: status };
+    case 404:
+      return { code: ErrorCode.NOT_FOUND, message: "Resource not found", retryable: false, statusCode: status };
+    case 408:
+      return { code: ErrorCode.TIMEOUT, message: "Request timeout", retryable: true, statusCode: status };
+    case 429:
+      return { code: ErrorCode.RATE_LIMITED, message: "Rate limit exceeded", retryable: true, statusCode: status };
+    case 500:
+      return { code: ErrorCode.INTERNAL_ERROR, message: "Server error", retryable: true, statusCode: status };
+    case 502:
+      return { code: ErrorCode.SERVICE_UNAVAILABLE, message: "Bad gateway", retryable: true, statusCode: status };
+    case 503:
+      return { code: ErrorCode.SERVICE_UNAVAILABLE, message: "Service unavailable", retryable: true, statusCode: status };
+    case 504:
+      return { code: ErrorCode.TIMEOUT, message: "Gateway timeout", retryable: true, statusCode: status };
+    case 510:
+      return { code: ErrorCode.SERVICE_UNAVAILABLE, message: "Request canceled", retryable: true, statusCode: status };
+    default:
+      if (status >= 500) {
+        return { code: ErrorCode.SERVICE_UNAVAILABLE, message: `Server error: ${status}`, retryable: true, statusCode: status };
+      }
+      if (status >= 400) {
+        return { code: ErrorCode.INVALID_INPUT, message: `Client error: ${status}`, retryable: false, statusCode: status };
+      }
+      return { code: ErrorCode.UNKNOWN_ERROR, message: `HTTP ${status}: ${message}`, retryable: false, statusCode: status };
+  }
+}
+function calculateBackoff(attempt, options) {
+  const exponentialDelay = options.baseDelayMs * Math.pow(2, attempt);
+  const jitter = Math.random() * 0.3 * exponentialDelay;
+  return Math.min(exponentialDelay + jitter, options.maxDelayMs);
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new DOMException("Aborted", "AbortError"));
+      return;
+    }
+    function onAbort() {
+      clearTimeout(timeout);
+      reject(new DOMException("Aborted", "AbortError"));
+    }
+    const timeout = setTimeout(() => {
+      if (signal) signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+    if (signal?.aborted) {
+      onAbort();
+    }
+  });
+}
+function fetchWithTimeout(url, options = {}) {
+  const { timeoutMs = 3e4, signal: externalSignal, ...fetchOptions } = options;
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  let onExternalAbort;
+  if (externalSignal) {
+    onExternalAbort = () => controller.abort();
+    externalSignal.addEventListener("abort", onExternalAbort, { once: true });
+    if (externalSignal.aborted) {
+      controller.abort();
+    }
+  }
+  return fetch(url, { ...fetchOptions, signal: controller.signal }).finally(() => {
+    clearTimeout(timeoutId);
+    if (externalSignal && onExternalAbort) {
+      externalSignal.removeEventListener("abort", onExternalAbort);
+    }
+  });
+}
+async function withStallProtection(fn, stallMs, maxAttempts = 2, label = "request") {
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const controller = new AbortController();
+    let stallTimer;
+    const stallPromise = new Promise((_, reject) => {
+      stallTimer = setTimeout(() => {
+        controller.abort();
+        reject(Object.assign(new Error(`Service temporarily unavailable \u2014 no response received (attempt ${attempt + 1}/${maxAttempts})`), {
+          code: "ESTALLED",
+          retryable: attempt < maxAttempts - 1
+        }));
+      }, stallMs);
+    });
+    let fnPromise;
+    try {
+      fnPromise = fn(controller.signal);
+      const result = await Promise.race([fnPromise, stallPromise]);
+      clearTimeout(stallTimer);
+      return result;
+    } catch (err) {
+      fnPromise?.catch(() => {
+      });
+      clearTimeout(stallTimer);
+      const isStall = err instanceof Error && err.code === "ESTALLED";
+      if (isStall && attempt < maxAttempts - 1) {
+        const backoff = calculateBackoff(attempt, DEFAULT_RETRY_OPTIONS);
+        mcpLog("warning", `${label} stalled, retrying in ${backoff}ms (attempt ${attempt + 1})`, "stability");
+        await sleep(backoff);
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw new Error(`${label} failed after ${maxAttempts} stall-protection attempts`);
+}
+
+// src/utils/retry.ts
+var JITTER_FACTOR = 0.3;
+var EXPONENTIAL_BASE = 2;
+var DEFAULT_BASE_DELAY_MS = 1e3;
+var DEFAULT_MAX_DELAY_MS = 3e4;
+function calculateBackoff2(attempt, baseDelayMs = DEFAULT_BASE_DELAY_MS, maxDelayMs = DEFAULT_MAX_DELAY_MS) {
+  const exponentialDelay = baseDelayMs * Math.pow(EXPONENTIAL_BASE, attempt);
+  const jitter = JITTER_FACTOR * exponentialDelay * Math.random();
+  return Math.min(exponentialDelay + jitter, maxDelayMs);
+}
+
+// src/clients/jina.ts
+var JINA_READER_BASE = "https://r.jina.ai/";
+var JINA_SEARCH_BASE = "https://s.jina.ai/";
+var DEFAULT_TIMEOUT_SECONDS = 15;
+var DEFAULT_TIMEOUT_MS = DEFAULT_TIMEOUT_SECONDS * 1e3;
+var MAX_RETRIES = 2;
+var SEARCH_RESULTS_PER_QUERY = 10;
+function buildJinaSearchUrl(query) {
+  const params = new URLSearchParams({ q: query });
+  return `${JINA_SEARCH_BASE}?${params.toString()}`;
+}
+function buildScrapeDoProxyUrl(token, parameters = "render=false") {
+  const trimmed = token.trim();
+  if (!trimmed) return "";
+  return `http://${encodeURIComponent(trimmed)}:${parameters}@proxy.scrape.do:8080`;
+}
+var JinaClient = class {
+  apiKey;
+  constructor(apiKey) {
+    const fromEnv = process.env.JINA_API_KEY?.trim();
+    this.apiKey = apiKey?.trim() || fromEnv || void 0;
+  }
+  /**
+   * Convert a URL to markdown via Jina Reader.
+   * NEVER throws — always returns a JinaConvertResponse (possibly with error).
+   */
+  async convert(request) {
+    const {
+      url,
+      timeoutSeconds = DEFAULT_TIMEOUT_SECONDS,
+      proxyUrl,
+      noCache = false,
+      allowProxyRetry = false
+    } = request;
+    try {
+      new URL(url);
+    } catch {
+      return {
+        content: `Invalid URL: ${url}`,
+        statusCode: 400,
+        credits: 0,
+        error: { code: ErrorCode.INVALID_INPUT, message: `Invalid URL: ${url}`, retryable: false }
+      };
+    }
+    const first = await this.convertOnce({
+      url,
+      timeoutSeconds,
+      proxyUrl,
+      noCache
+    });
+    if (!first.error || !allowProxyRetry || proxyUrl || isTerminalReaderError(first.error)) {
+      return first;
+    }
+    mcpLog("warning", `Jina Reader failed for ${url}; retrying with Jina proxy`, "jina");
+    return this.convertOnce({
+      url,
+      timeoutSeconds,
+      proxyUrl: "auto",
+      noCache: true
+    });
+  }
+  async searchMultiple(queries) {
+    const startTime = Date.now();
+    if (queries.length === 0) {
+      return {
+        searches: [],
+        totalQueries: 0,
+        executionTime: 0,
+        error: { code: ErrorCode.INVALID_INPUT, message: "No queries provided", retryable: false }
+      };
+    }
+    if (!this.apiKey) {
+      return {
+        searches: [],
+        totalQueries: queries.length,
+        executionTime: Date.now() - startTime,
+        error: { code: ErrorCode.AUTH_ERROR, message: "Jina Search requires JINA_API_KEY", retryable: false }
+      };
+    }
+    const searches = await Promise.all(queries.map((query) => this.searchOne(query)));
+    const firstError = searches.find((search) => search.error)?.error;
+    const allFailed = searches.every((search) => search.error);
+    return {
+      searches,
+      totalQueries: queries.length,
+      executionTime: Date.now() - startTime,
+      ...allFailed && firstError ? { error: firstError } : {}
+    };
+  }
+  async convertOnce(request) {
+    const headers = {
+      Accept: "application/json",
+      "Content-Type": "application/json"
+    };
+    if (this.apiKey) headers["Authorization"] = `Bearer ${this.apiKey}`;
+    if (request.proxyUrl && request.proxyUrl !== "auto") {
+      headers["X-Proxy-Url"] = request.proxyUrl;
+    }
+    const body = {
+      url: request.url,
+      respondWith: "markdown",
+      timeout: request.timeoutSeconds,
+      base: "final",
+      removeOverlay: true
+    };
+    if (request.proxyUrl === "auto") body["proxy"] = "auto";
+    if (request.noCache) body["noCache"] = true;
+    return this.fetchReader(body, headers, request.timeoutSeconds);
+  }
+  async fetchReader(body, headers, timeoutSeconds) {
+    let lastError;
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+      try {
+        const response = await fetchWithTimeout(JINA_READER_BASE, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(body),
+          timeoutMs: (timeoutSeconds + 5) * 1e3
+        });
+        const raw = await response.text().catch(
+          (readError) => `Failed to read Jina response: ${readError instanceof Error ? readError.message : String(readError)}`
+        );
+        const usageHeader = response.headers.get("x-usage-tokens");
+        const usageTokens = usageHeader ? Number(usageHeader) : void 0;
+        const parsed = parseReaderContent(raw);
+        if (response.ok) {
+          if (!parsed.content.trim()) {
+            return emptyReaderResponse(response.status, usageTokens);
+          }
+          return {
+            content: parsed.content,
+            statusCode: response.status,
+            credits: 0,
+            usageTokens: Number.isFinite(usageTokens) ? usageTokens : void 0
+          };
+        }
+        const terminal = terminalReaderResponse(response.status, parsed.content || raw);
+        if (terminal) return terminal;
+        lastError = classifyError({ status: response.status, message: raw.slice(0, 200) });
+        if (lastError.retryable && attempt < MAX_RETRIES) {
+          const delayMs = calculateBackoff2(attempt);
+          mcpLog(
+            "warning",
+            `Jina ${response.status} on attempt ${attempt + 1}/${MAX_RETRIES + 1}. Retrying in ${delayMs}ms`,
+            "jina"
+          );
+          await sleep(delayMs);
+          continue;
+        }
+        return {
+          content: `Jina Reader error (${response.status}): ${raw.slice(0, 200)}`,
+          statusCode: response.status,
+          credits: 0,
+          error: lastError
+        };
+      } catch (error2) {
+        lastError = classifyError(error2);
+        if (lastError.retryable && attempt < MAX_RETRIES) {
+          const delayMs = calculateBackoff2(attempt);
+          mcpLog(
+            "warning",
+            `Jina ${lastError.code}: ${lastError.message}. Retry ${attempt + 1}/${MAX_RETRIES + 1} in ${delayMs}ms`,
+            "jina"
+          );
+          await sleep(delayMs);
+          continue;
+        }
+        return {
+          content: `Jina Reader failed: ${lastError.message}`,
+          statusCode: lastError.statusCode ?? 500,
+          credits: 0,
+          error: lastError
+        };
+      }
+    }
+    return {
+      content: `Jina Reader failed after ${MAX_RETRIES + 1} attempts: ${lastError?.message ?? "Unknown error"}`,
+      statusCode: lastError?.statusCode ?? 500,
+      credits: 0,
+      error: lastError ?? { code: ErrorCode.UNKNOWN_ERROR, message: "All retries exhausted", retryable: false }
+    };
+  }
+  async searchOne(query) {
+    const headers = {
+      Accept: "application/json",
+      Authorization: `Bearer ${this.apiKey ?? ""}`
+    };
+    try {
+      const response = await fetchWithTimeout(buildJinaSearchUrl(query), {
+        method: "GET",
+        headers,
+        timeoutMs: DEFAULT_TIMEOUT_MS
+      });
+      const raw = await response.text().catch(
+        (readError) => `Failed to read Jina Search response: ${readError instanceof Error ? readError.message : String(readError)}`
+      );
+      if (!response.ok) {
+        return {
+          query,
+          results: [],
+          totalResults: 0,
+          related: [],
+          error: classifyError({ status: response.status, message: raw.slice(0, 200) })
+        };
+      }
+      const results = parseSearchResults(raw);
+      return { query, results, totalResults: results.length, related: [] };
+    } catch (error2) {
+      return {
+        query,
+        results: [],
+        totalResults: 0,
+        related: [],
+        error: classifyError(error2)
+      };
+    }
+  }
+};
+function parseReaderContent(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    const data = readRecord(parsed, "data");
+    const content = readString(data, "content");
+    if (content) return { content };
+  } catch {
+  }
+  return { content: raw };
+}
+function emptyReaderResponse(statusCode, usageTokens) {
+  return {
+    content: "Jina returned an empty body",
+    statusCode,
+    credits: 0,
+    usageTokens: Number.isFinite(usageTokens) ? usageTokens : void 0,
+    error: {
+      code: ErrorCode.UNSUPPORTED_BINARY_CONTENT,
+      message: "Jina Reader returned empty content for this URL",
+      retryable: false
+    }
+  };
+}
+function terminalReaderResponse(statusCode, content) {
+  if (statusCode === 401 || statusCode === 403) {
+    return {
+      content: `Jina auth/quota error (${statusCode}): ${content.slice(0, 200)}`,
+      statusCode,
+      credits: 0,
+      error: {
+        code: statusCode === 401 ? ErrorCode.AUTH_ERROR : ErrorCode.QUOTA_EXCEEDED,
+        message: statusCode === 401 ? "Jina Reader auth failed \u2014 check JINA_API_KEY" : "Jina Reader quota exceeded",
+        retryable: false,
+        statusCode
+      }
+    };
+  }
+  if (statusCode === 404) {
+    return {
+      content: "Jina could not fetch the target URL (404)",
+      statusCode: 404,
+      credits: 0,
+      error: {
+        code: ErrorCode.NOT_FOUND,
+        message: "Target URL not reachable by Jina Reader",
+        retryable: false,
+        statusCode: 404
+      }
+    };
+  }
+  if (statusCode >= 400 && statusCode < 500 && statusCode !== 429) {
+    return {
+      content: `Jina Reader error (${statusCode}): ${content.slice(0, 200)}`,
+      statusCode,
+      credits: 0,
+      error: {
+        code: ErrorCode.INVALID_INPUT,
+        message: `Jina Reader returned ${statusCode}`,
+        retryable: false,
+        statusCode
+      }
+    };
+  }
+  return null;
+}
+function isTerminalReaderError(error2) {
+  return !error2.retryable && (error2.code === ErrorCode.AUTH_ERROR || error2.code === ErrorCode.QUOTA_EXCEEDED || error2.code === ErrorCode.NOT_FOUND || error2.code === ErrorCode.INVALID_INPUT);
+}
+function parseSearchResults(raw) {
+  let data;
+  try {
+    const parsed = JSON.parse(raw);
+    data = readUnknown(parsed, "data");
+  } catch {
+    data = parseMarkdownSearchResults(raw);
+  }
+  const items = Array.isArray(data) ? data : [];
+  return items.map((item, index) => normalizeSearchItem(item, index)).filter((item) => item !== null).slice(0, SEARCH_RESULTS_PER_QUERY);
+}
+function normalizeSearchItem(item, index) {
+  const link = readString(item, "url") ?? readString(item, "link");
+  if (!link) return null;
+  return {
+    title: readString(item, "title") || link,
+    link,
+    snippet: (readString(item, "snippet") || readString(item, "description") || readString(item, "content") || "").slice(0, 500),
+    date: readString(item, "date") ?? readString(item, "publishedTime"),
+    position: index + 1
+  };
+}
+function parseMarkdownSearchResults(raw) {
+  const items = [];
+  const markdownLink = /\[([^\]]+)\]\((https?:\/\/[^)]+)\)/g;
+  let match;
+  while ((match = markdownLink.exec(raw)) !== null && items.length < SEARCH_RESULTS_PER_QUERY) {
+    const title = match[1];
+    const url = match[2];
+    if (title && url) items.push({ title, url });
+  }
+  return items;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function readUnknown(value, key) {
+  return isRecord(value) ? value[key] : void 0;
+}
+function readRecord(value, key) {
+  const child = readUnknown(value, key);
+  return isRecord(child) ? child : void 0;
+}
+function readString(value, key) {
+  const child = readUnknown(value, key);
+  return typeof child === "string" ? child : void 0;
+}
+
+// src/services/markdown-cleaner.ts
+import { Logger as Logger3 } from "mcp-use";
+import TurndownService from "turndown";
+var logger = Logger3.get("markdown-cleaner");
+var turndown = new TurndownService({
+  headingStyle: "atx",
+  codeBlockStyle: "fenced",
+  bulletListMarker: "-"
+});
+turndown.remove(["script", "style", "nav", "footer", "aside", "noscript"]);
+var MAX_CONTENT_LENGTH = 524288;
+function removeHtmlComments(html) {
+  const parts = [];
+  let pos = 0;
+  while (pos < html.length) {
+    const start = html.indexOf("<!--", pos);
+    if (start === -1) {
+      parts.push(html.substring(pos));
+      break;
+    }
+    if (start > pos) parts.push(html.substring(pos, start));
+    const end = html.indexOf("-->", start + 4);
+    if (end === -1) {
+      parts.push(html.substring(start));
+      break;
+    }
+    pos = end + 3;
+  }
+  return parts.join("");
+}
+var MarkdownCleaner = class {
+  /**
+   * Process HTML content and convert to clean Markdown
+   * NEVER throws - returns original content on any error for graceful degradation
+   */
+  processContent(htmlContent) {
+    try {
+      if (!htmlContent || typeof htmlContent !== "string") {
+        return htmlContent || "";
+      }
+      if (!htmlContent.includes("<")) {
+        return htmlContent.trim();
+      }
+      if (htmlContent.length > MAX_CONTENT_LENGTH) {
+        htmlContent = htmlContent.substring(0, MAX_CONTENT_LENGTH);
+      }
+      let content = removeHtmlComments(htmlContent);
+      content = turndown.turndown(content);
+      content = content.replace(/\n{3,}/g, "\n\n");
+      content = content.trim();
+      return content;
+    } catch (error2) {
+      logger.warn(
+        `processContent failed: ${error2 instanceof Error ? error2.message : String(error2)} | Content length: ${htmlContent?.length ?? 0}`
+      );
+      return htmlContent || "";
+    }
+  }
+};
+
+// src/services/llm-processor.ts
+import OpenAI from "openai";
+
+// src/schemas/web-search.ts
+import { z as z2 } from "zod";
+var QUERY_REWRITE_PAIR_EXAMPLES = [
+  'Bad: `<feature> support` \u2192 Better: `site:<official-docs-domain> "<feature>" "<platform-or-version>"`',
+  'Bad: `<product> pricing` \u2192 Better: `site:<vendor-domain> "<product>" pricing "enterprise" OR "free tier"`',
+  'Bad: `<library> bug fix` \u2192 Better: `"<exact error text>" "<library-or-package>" "<version>" site:github.com`',
+  'Bad: `<tool> reviews` \u2192 Better: `site:reddit.com/r/<community>/comments "<tool>" "migration" OR "regression"`'
+];
+var QUERY_REWRITE_PAIR_GUIDANCE = [
+  "Write Google retrieval probes, not topic labels.",
+  "For each broad idea, rewrite it into a query that names the evidence source class, discriminating anchor terms, and one useful operator when possible.",
+  "Use rewrite-pair thinking before searching:",
+  ...QUERY_REWRITE_PAIR_EXAMPLES,
+  "Do not repeat the same noun phrase with adjectives changed; fan out by source type and evidence need."
+];
+var QUERY_REWRITE_PAIR_GUIDANCE_TEXT = QUERY_REWRITE_PAIR_GUIDANCE.join(" ");
+var keywordSchema = z2.string().min(1, { message: "search: Keyword cannot be empty" }).describe(
+  `A single search keyword/query. Each item runs as a separate parallel search. ${QUERY_REWRITE_PAIR_GUIDANCE_TEXT}`
+);
+var keywordsSchema = z2.array(keywordSchema).min(1, { message: "search: At least 1 keyword required" }).max(50, { message: "search: At most 50 keywords allowed per call" }).describe(
+  `Search keywords to run in parallel. Serper is primary when configured; Jina Search is fallback when Serper is missing, fails, or yields empty query results. ${QUERY_REWRITE_PAIR_GUIDANCE_TEXT} Think of keywords as retrieval probes, not topic labels. Pack distinct facets in one call: official docs, implementation, failures, comparisons, sentiment, changelog, CVE, pricing, or other source classes.`
+);
+var rawWebSearchParamsSchema = z2.object({
+  keywords: keywordsSchema,
+  extract: z2.never().optional(),
+  scope: z2.never().optional(),
+  verbose: z2.never().optional()
+}).strict();
+var smartWebSearchParamsSchema = z2.object({
+  keywords: keywordsSchema,
+  extract: z2.string().min(1, { message: "smart-web-search: extract cannot be empty" }).describe(
+    'Semantic instruction for the relevance classifier \u2014 what "relevant" means for THIS goal. This is the post-sort target, so name the evidence you need and the source-of-truth expectation: e.g. official docs/release notes for specs, issue/PR/error text for bugs, Reddit/HN/blogs for lived experience, vendor pricing pages for pricing, CVE databases for security. Drives tiering (HIGHLY_RELEVANT / MAYBE_RELEVANT / OTHER), synthesis, gap analysis, and refine-query suggestions. Be specific: "OAuth 2.1 support in TypeScript MCP frameworks \u2014 runnable code, not marketing", not "MCP OAuth".'
+  ),
+  scope: z2.enum(["web", "reddit", "both"]).default("web").describe(
+    'Search scope. "web" (default) = open web, no augmentation. "reddit" = server appends `site:reddit.com` to every keyword and filters results to post permalinks (`/r/.+/comments/[a-z0-9]+/`); subreddit homepages are dropped. "both" = runs every keyword twice (open web + reddit-scoped), merges the result set, and tags each row with its source. Use "reddit" for sentiment/migration/lived-experience research; use "both" when opinion-heavy AND official sources also matter.'
+  ),
+  verbose: z2.boolean().default(false).describe(
+    "Include per-row scoring/coverage metadata, the trailing Signals block, and CONSENSUS labels even when they carry little signal. Default false."
+  )
+}).strict();
+
+// src/services/llm-processor.ts
+var MAX_LLM_INPUT_CHARS = 5e5;
+var MAX_PRIMARY_MODEL_INPUT_CHARS = 1e5;
+var LLM_CLIENT_TIMEOUT_MS = 6e5;
+var BACKOFF_JITTER_FACTOR = 0.3;
+var LLM_STALL_TIMEOUT_MS = 75e3;
+var LLM_REQUEST_DEADLINE_MS = 15e4;
+var llmHealth = {
+  lastPlannerOk: false,
+  lastExtractorOk: false,
+  lastPlannerCheckedAt: null,
+  lastExtractorCheckedAt: null,
+  lastPlannerError: null,
+  lastExtractorError: null,
+  consecutivePlannerFailures: 0,
+  consecutiveExtractorFailures: 0
+};
+function markLLMSuccess(kind) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  if (kind === "planner") {
+    llmHealth.lastPlannerOk = true;
+    llmHealth.lastPlannerCheckedAt = ts;
+    llmHealth.lastPlannerError = null;
+    llmHealth.consecutivePlannerFailures = 0;
+  } else {
+    llmHealth.lastExtractorOk = true;
+    llmHealth.lastExtractorCheckedAt = ts;
+    llmHealth.lastExtractorError = null;
+    llmHealth.consecutiveExtractorFailures = 0;
+  }
+}
+function markLLMFailure(kind, err) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  const message = err instanceof Error ? err.message : String(err ?? "unknown error");
+  if (kind === "planner") {
+    llmHealth.lastPlannerOk = false;
+    llmHealth.lastPlannerCheckedAt = ts;
+    llmHealth.lastPlannerError = message;
+    llmHealth.consecutivePlannerFailures += 1;
+  } else {
+    llmHealth.lastExtractorOk = false;
+    llmHealth.lastExtractorCheckedAt = ts;
+    llmHealth.lastExtractorError = message;
+    llmHealth.consecutiveExtractorFailures += 1;
+  }
+}
+var LLM_RETRY_CONFIG = {
+  maxRetries: 2,
+  baseDelayMs: 1e3,
+  maxDelayMs: 5e3
+};
+var FALLBACK_RETRY_COUNT = 3;
+var RETRYABLE_LLM_ERROR_CODES = /* @__PURE__ */ new Set([
+  "rate_limit_exceeded",
+  "server_error",
+  "timeout",
+  "service_unavailable"
+]);
+function hasStatus(error2) {
+  return typeof error2 === "object" && error2 !== null && "status" in error2 && typeof error2.status === "number";
+}
+var llmClient = null;
+function createLLMProcessor() {
+  if (!getCapabilities().llmExtraction) return null;
+  if (!llmClient) {
+    llmClient = new OpenAI({
+      baseURL: LLM_EXTRACTION.BASE_URL,
+      apiKey: LLM_EXTRACTION.API_KEY,
+      timeout: LLM_CLIENT_TIMEOUT_MS,
+      maxRetries: 0,
+      defaultHeaders: { "X-Title": "mcp-research-powerpack" }
+    });
+    mcpLog("info", `LLM extraction configured (model: ${LLM_EXTRACTION.MODEL}, baseURL: ${LLM_EXTRACTION.BASE_URL})`, "llm");
+  }
+  return llmClient;
+}
+function buildChatRequestBody(model, prompt) {
+  return {
+    model,
+    messages: [{ role: "user", content: prompt }],
+    reasoning_effort: "low"
+  };
+}
+function normalizeProviderError(err, message) {
+  if (typeof err === "object" && err !== null) return err;
+  return new Error(message);
+}
+function getProviderFailure(response) {
+  if (response.content !== null || response.failureKind !== "provider") return null;
+  return response.errorCause;
+}
+function emptyLLMExtractionResult(content) {
+  return {
+    content,
+    processed: false,
+    error: "LLM returned empty response",
+    errorDetails: {
+      code: ErrorCode.INTERNAL_ERROR,
+      message: "LLM returned empty response",
+      retryable: false
+    }
+  };
+}
+async function requestText(processor, prompt, operationLabel, signal, modelOverride) {
+  const model = modelOverride || LLM_EXTRACTION.MODEL;
+  try {
+    const response = await withStallProtection(
+      (stallSignal) => processor.chat.completions.create(
+        buildChatRequestBody(model, prompt),
+        {
+          signal: signal ? AbortSignal.any([stallSignal, signal]) : stallSignal,
+          timeout: LLM_REQUEST_DEADLINE_MS
+        }
+      ),
+      LLM_STALL_TIMEOUT_MS,
+      3,
+      `${operationLabel} (${model})`
+    );
+    const content = response.choices?.[0]?.message?.content?.trim();
+    if (content) {
+      return { content, model };
+    }
+    const err = `Empty response from model ${model}`;
+    mcpLog("warning", `${operationLabel} returned empty content for model ${model}`, "llm");
+    return { content: null, model, error: err, failureKind: "empty" };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    mcpLog("warning", `${operationLabel} failed for model ${model}: ${message}`, "llm");
+    return {
+      content: null,
+      model,
+      error: message,
+      failureKind: "provider",
+      errorCause: normalizeProviderError(err, message)
+    };
+  }
+}
+async function requestTextWithFallback(processor, prompt, operationLabel, signal) {
+  const primary = await requestText(processor, prompt, operationLabel, signal);
+  if (primary.content !== null) return primary;
+  const fallbackModel = LLM_EXTRACTION.FALLBACK_MODEL;
+  if (!fallbackModel) return primary;
+  mcpLog("warning", `Primary model failed, switching to fallback ${fallbackModel}`, "llm");
+  let lastFailure = primary;
+  for (let attempt = 0; attempt < FALLBACK_RETRY_COUNT; attempt++) {
+    if (attempt > 0) {
+      const delayMs = calculateLLMBackoff(attempt - 1);
+      mcpLog("warning", `Fallback retry ${attempt}/${FALLBACK_RETRY_COUNT - 1} in ${delayMs}ms`, "llm");
+      try {
+        await sleep(delayMs, signal);
+      } catch {
+        break;
+      }
+    }
+    const result = await requestText(processor, prompt, `${operationLabel} [fallback]`, signal, fallbackModel);
+    if (result.content !== null) return result;
+    lastFailure = result;
+  }
+  return lastFailure;
+}
+function isRetryableLLMError(error2) {
+  if (!error2 || typeof error2 !== "object") return false;
+  const stallCode = error2?.code;
+  if (stallCode === "ESTALLED" || stallCode === "ETIMEDOUT") {
+    return true;
+  }
+  if (hasStatus(error2)) {
+    if (error2.status === 429 || error2.status === 500 || error2.status === 502 || error2.status === 503 || error2.status === 504) {
+      return true;
+    }
+  }
+  const record = error2;
+  const code = typeof record.code === "string" ? record.code : void 0;
+  const nested = typeof record.error === "object" && record.error !== null ? record.error : null;
+  const errorCode = code ?? (nested && typeof nested.code === "string" ? nested.code : void 0) ?? (nested && typeof nested.type === "string" ? nested.type : void 0);
+  if (errorCode && RETRYABLE_LLM_ERROR_CODES.has(errorCode)) {
+    return true;
+  }
+  const message = typeof record.message === "string" ? record.message.toLowerCase() : "";
+  if (message.includes("rate limit") || message.includes("timeout") || message.includes("timed out") || message.includes("service unavailable") || message.includes("server error") || message.includes("connection") || message.includes("econnreset")) {
+    return true;
+  }
+  return false;
+}
+function isContextWindowError(error2) {
+  if (!error2 || typeof error2 !== "object") return false;
+  const record = error2;
+  const nested = typeof record.error === "object" && record.error !== null ? record.error : null;
+  const code = typeof record.code === "string" ? record.code : void 0;
+  const nestedCode = nested && typeof nested.code === "string" ? nested.code : void 0;
+  if (code === "context_length_exceeded" || nestedCode === "context_length_exceeded") {
+    return true;
+  }
+  const messages = [];
+  if (typeof record.message === "string") messages.push(record.message);
+  if (nested && typeof nested.message === "string") messages.push(nested.message);
+  const combined = messages.join(" ").toLowerCase();
+  return combined.includes("context length") || combined.includes("context window") || combined.includes("maximum context") || combined.includes("maximum tokens") || combined.includes("token limit") || combined.includes("too many tokens") || combined.includes("prompt is too long") || combined.includes("reduce the length");
+}
+function calculateLLMBackoff(attempt) {
+  const exponentialDelay = LLM_RETRY_CONFIG.baseDelayMs * Math.pow(2, attempt);
+  const jitter = Math.random() * BACKOFF_JITTER_FACTOR * exponentialDelay;
+  return Math.min(exponentialDelay + jitter, LLM_RETRY_CONFIG.maxDelayMs);
+}
+async function processContentWithLLM(content, config, processor, signal) {
+  if (!config.enabled) {
+    return { content, processed: false };
+  }
+  if (!processor) {
+    return {
+      content,
+      processed: false,
+      error: "LLM processor not available (LLM_API_KEY, LLM_BASE_URL, and LLM_MODEL must all be set)",
+      errorDetails: {
+        code: ErrorCode.AUTH_ERROR,
+        message: "LLM processor not available",
+        retryable: false
+      }
+    };
+  }
+  if (!content?.trim()) {
+    return { content: content || "", processed: false, error: "Empty content provided" };
+  }
+  const truncatedContent = content.length > MAX_LLM_INPUT_CHARS ? content.substring(0, MAX_LLM_INPUT_CHARS) + "\n\n[Content truncated due to length]" : content;
+  const skipPrimaryForSize = truncatedContent.length > MAX_PRIMARY_MODEL_INPUT_CHARS && !!LLM_EXTRACTION.FALLBACK_MODEL;
+  const safeUrl = (() => {
+    if (!config.url) return void 0;
+    try {
+      const u = new URL(config.url);
+      return `${u.origin}${u.pathname}`;
+    } catch {
+      return void 0;
+    }
+  })();
+  const urlLine = safeUrl ? `PAGE URL: ${safeUrl}
+
+` : "";
+  const prompt = config.extract ? `You are a factual extractor for a research agent. Extract ONLY the information that matches the instruction below. Do not summarize, interpret, or editorialize.
+
+${urlLine}EXTRACTION INSTRUCTION: ${config.extract}
+
+STEP 1 \u2014 Classify this page. Look at the URL if present, plus structural cues (code blocks, table patterns, comment threads, marketing copy). Pick ONE:
+\`docs | changelog | github-readme | github-thread | reddit | hackernews | forum | blog | marketing | announcement | qa | cve | paper | release-notes | other\`
+
+STEP 2 \u2014 Adjust emphasis by page type:
+- docs / changelog / github-readme / release-notes \u2192 API signatures, version numbers, flags, exact config keys, code blocks. Copy verbatim. Preserve tables as tables.
+- github-thread \u2192 weight MAINTAINER comments (label "[maintainer]") over drive-by commenters. Preserve stacktraces verbatim. Capture chronological resolution \u2014 what was decided and when. Link the accepted-fix commit/PR if referenced.
+- reddit / hackernews / forum \u2192 lived experience. Quote verbatim with attribution ("u/foo wrote: \u2026" or "user <name>"). Prioritize replies with stack details, specific failure stories, or replies that contradict the OP. Record overall sentiment distribution as one bullet if clear skew ("~70% agree / ~20% dissent / rest off-topic"). Drop context-free opinions ("this sucks") from Matches.
+- blog \u2192 prioritize concrete reproductions, code, measurements. If the author makes a claim without evidence, mark "[unsourced claim]".
+- marketing / announcement \u2192 pricing tiers, feature matrices verbatim, free-tier quotas, enterprise contact. Preserve tables as tables. Treat roadmap/future-tense claims skeptically \u2014 note them as "[announced, not shipped]" when framing is future-tense.
+- qa (stackoverflow) \u2192 accepted answer's code + high-voted disagreements. Always note the answer date \u2014 SO rots.
+- cve \u2192 CVSS vector verbatim, CWE, CPE ranges, affected versions, fix version, references. Each with its label.
+- paper \u2192 claim, method, dataset, benchmark numbers, comparison baseline. Preserve numeric deltas verbatim.
+
+STEP 3 \u2014 Emit markdown with these sections, in order:
+
+## Source
+- URL: <verbatim if visible, else "unknown">
+- Page type: <the type you picked>
+- Page date: <verbatim if visible, else "not visible">
+- Author / maintainer (if identifiable): <verbatim>
+
+## Matches
+One bullet per distinct piece of matching info:
+- **<short label>** \u2014 the information. Quote VERBATIM for: numbers, versions, dates, API names, prices, error messages, stacktraces, CVSS vectors, benchmark scores, command flags, proper nouns, and people's words. Backticks for code/identifiers. Preserve tables.
+
+## Not found
+Every part of the extraction instruction this page did NOT answer. Be explicit. Example: "Enterprise pricing contact \u2014 not present on this page."
+
+## Follow-up signals
+Short bullets \u2014 NEW angles this page surfaced that the agent should investigate. Include: new terms, unexpected vendor names, contradicting claims, referenced-but-unscraped URLs. Copy URLs VERBATIM from the source; if only anchor text is visible, write "anchor: <text> (URL not in scraped content)". Skip this section if nothing new surfaced. Do NOT invent.
+
+## Contradictions
+(Include this section only if the page contains internally contradictory claims.) Bullet each contradiction with both sides quoted verbatim.
+
+## Truncation
+(Include only if content appears cut mid-element.) "Content cut mid-<table row / code block / comment / paragraph>; extraction may be incomplete for <section>."
+
+RULES:
+- Never paraphrase numbers, versions, code, or quoted text.
+- If an instruction item is not answered, it goes in "Not found" \u2014 do NOT invent an answer to please the caller.
+- Preserve code blocks, command examples, tables exactly.
+- Do NOT add commentary or recommendations outside "Follow-up signals".
+- Page language \u2260 English: quote verbatim in the original language AND provide a parenthetical gloss in English.
+- Page appears gated (login wall, paywall, JS-render-empty shell) or near-empty: BEFORE dismissing the page, look for ANY visible text \u2014 og:title, og:description, meta description, headline, author name, nav labels, teaser/preview sentences, visible comment snippets. If ANY such text exists, extract it as usual under \`## Source\` + \`## Matches\`, and list the blocked facets under \`## Not found\`. Prefix the first \`## Matches\` bullet with \`**[partial \u2014 <reason>]**\` so the caller knows the body is gated (reasons: \`login-wall | paywall | JS-render-empty | truncated-before-relevant-section\`). ONLY when there is NO visible extractable text at all (< 50 words AND no og:* AND no headline AND no preview), return exactly one line:
+  \`## Matches\\n_Page did not load: <reason>_\`
+  Valid reasons: \`404 | login-wall | paywall | JS-render-empty | non-text-asset | truncated-before-relevant-section\`.
+
+Content:
+${truncatedContent}` : `Clean the following page content: drop navigation, ads, cookie banners, footers, author bios, related-article lists. Preserve headings, paragraphs, code blocks, tables, and inline links as \`[text](url)\`. Do NOT summarize \u2014 preserve the full body.
+
+${urlLine}Content:
+${truncatedContent}`;
+  let lastError;
+  if (skipPrimaryForSize) {
+    mcpLog(
+      "info",
+      `Input ${truncatedContent.length} chars exceeds primary model cap (${MAX_PRIMARY_MODEL_INPUT_CHARS}); routing directly to fallback`,
+      "llm"
+    );
+  } else {
+    for (let attempt = 0; attempt <= LLM_RETRY_CONFIG.maxRetries; attempt++) {
+      try {
+        if (attempt === 0) {
+          mcpLog("info", `Starting extraction with ${LLM_EXTRACTION.MODEL}`, "llm");
+        } else {
+          mcpLog("warning", `Retry attempt ${attempt}/${LLM_RETRY_CONFIG.maxRetries}`, "llm");
+        }
+        const response = await requestText(processor, prompt, "LLM extraction", signal);
+        if (response.content !== null) {
+          mcpLog("info", `Successfully extracted ${response.content.length} characters`, "llm");
+          markLLMSuccess("extractor");
+          return { content: response.content, processed: true };
+        }
+        const providerFailure = getProviderFailure(response);
+        if (providerFailure) {
+          throw providerFailure;
+        }
+        mcpLog("warning", "Received empty response from LLM", "llm");
+        markLLMFailure("extractor", "LLM returned empty response");
+        return emptyLLMExtractionResult(content);
+      } catch (err) {
+        lastError = classifyError(err);
+        const status = hasStatus(err) ? err.status : void 0;
+        const code = typeof err === "object" && err !== null && "code" in err ? String(err.code) : void 0;
+        const ctxErr = isContextWindowError(err);
+        mcpLog("error", `Error (attempt ${attempt + 1}): ${lastError.message} [status=${status}, code=${code}, retryable=${isRetryableLLMError(err)}, context_window=${ctxErr}]`, "llm");
+        if (ctxErr) {
+          mcpLog("warning", "Context window exceeded on primary \u2014 skipping remaining retries, routing to fallback", "llm");
+          break;
+        }
+        if (isRetryableLLMError(err) && attempt < LLM_RETRY_CONFIG.maxRetries) {
+          const delayMs = calculateLLMBackoff(attempt);
+          mcpLog("warning", `Retrying in ${delayMs}ms...`, "llm");
+          try {
+            await sleep(delayMs, signal);
+          } catch {
+            break;
+          }
+          continue;
+        }
+        break;
+      }
+    }
+  }
+  const fallbackModel = LLM_EXTRACTION.FALLBACK_MODEL;
+  if (fallbackModel) {
+    mcpLog("warning", `Primary exhausted, switching to fallback ${fallbackModel}`, "llm");
+    for (let attempt = 0; attempt < FALLBACK_RETRY_COUNT; attempt++) {
+      if (attempt > 0) {
+        const delayMs = calculateLLMBackoff(attempt - 1);
+        mcpLog("warning", `Fallback retry ${attempt}/${FALLBACK_RETRY_COUNT - 1} in ${delayMs}ms`, "llm");
+        try {
+          await sleep(delayMs, signal);
+        } catch {
+          break;
+        }
+      }
+      try {
+        const response = await requestText(processor, prompt, "LLM extraction [fallback]", signal, fallbackModel);
+        if (response.content !== null) {
+          mcpLog("info", `Fallback extracted ${response.content.length} characters`, "llm");
+          markLLMSuccess("extractor");
+          return { content: response.content, processed: true };
+        }
+        const providerFailure = getProviderFailure(response);
+        if (providerFailure) {
+          throw providerFailure;
+        }
+        mcpLog("warning", "Fallback returned empty response", "llm");
+        markLLMFailure("extractor", "LLM returned empty response");
+        return emptyLLMExtractionResult(content);
+      } catch (err) {
+        lastError = classifyError(err);
+        mcpLog("error", `Fallback error (attempt ${attempt + 1}): ${lastError.message}`, "llm");
+        if (isContextWindowError(err) || !isRetryableLLMError(err)) break;
+      }
+    }
+  }
+  const errorMessage = lastError?.message || "Unknown LLM error";
+  mcpLog("error", `All attempts failed: ${errorMessage}. Returning original content.`, "llm");
+  markLLMFailure("extractor", errorMessage);
+  return {
+    content,
+    processed: false,
+    error: `LLM extraction failed: ${errorMessage}`,
+    errorDetails: lastError || {
+      code: ErrorCode.UNKNOWN_ERROR,
+      message: errorMessage,
+      retryable: false
+    }
+  };
+}
+var MAX_CLASSIFICATION_URLS = 50;
+async function classifySearchResults(rankedUrls, objective, totalQueries, processor, previousQueries = []) {
+  const urlsToClassify = rankedUrls.slice(0, MAX_CLASSIFICATION_URLS);
+  const STATIC_WEIGHTS = [30, 20, 15, 10, 8, 6, 5, 4, 3, 2];
+  const weightForRank = (rank) => STATIC_WEIGHTS[rank - 1] ?? 1;
+  const lines = [];
+  for (const url of urlsToClassify) {
+    let domain;
+    try {
+      domain = new URL(url.url).hostname.replace(/^www\./, "");
+    } catch {
+      domain = url.url;
+    }
+    const snippet = url.snippet.length > 120 ? url.snippet.slice(0, 117) + "..." : url.snippet;
+    lines.push(`[${url.rank}] w=${weightForRank(url.rank)} ${url.title} \u2014 ${domain} \u2014 ${snippet}`);
+  }
+  const prevQueriesBlock = previousQueries.length > 0 ? previousQueries.map((q) => `- ${q}`).join("\n") : "- (none provided)";
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const prompt = `You are the relevance filter for a research agent. Classify each search result below against the objective and produce a structured analysis.
+
+OBJECTIVE: ${objective}
+TODAY: ${today}
+
+PREVIOUS QUERIES (already run \u2014 do NOT paraphrase in refine_queries):
+${prevQueriesBlock}
+
+Return ONLY a JSON object (no markdown, no code fences):
+
+{
+  "title": "2\u20138 word label for this RESULT CLUSTER (not the objective)",
+  "synthesis": "3\u20135 sentences grounded in the results. Every non-trivial claim cites a rank in [brackets], e.g. '[3] documents the flag; [7][12] report it is broken on macOS.' A synthesis with zero citations is invalid.",
+  "confidence": "high | medium | low",
+  "confidence_reason": "one sentence \u2014 why",
+  "gaps": [
+    { "id": 0, "description": "specific, actionable thing the current results do NOT answer \u2014 not 'more info needed'" }
+  ],
+  "refine_queries": [
+    { "query": "concrete next search", "gap_id": 0, "rationale": "\u226412 words" }
+  ],
+  "results": [
+    {
+      "rank": 1,
+      "tier": "HIGHLY_RELEVANT | MAYBE_RELEVANT | OTHER",
+      "source_type": "vendor_doc | github | reddit | hackernews | blog | news | marketing | stackoverflow | cve | paper | release_notes | aggregator | other",
+      "reason": "\u226412 words citing the snippet cue that drove the tier"
+    }
+  ]
+}
+
+WEIGHT SCHEME: each row is prefixed with a weight (w=N). Higher weight means the URL ranked better across input queries \u2014 prefer HIGHLY_RELEVANT for high-weight rows when content matches the objective. Weight alone never justifies HIGHLY_RELEVANT; snippet cues still drive the decision.
+
+SOURCE-OF-TRUTH RUBRIC (the "primary source" is goal-dependent \u2014 infer goal type from the objective):
+- spec / API / config questions \u2192 vendor_doc, github (README, RFC), release_notes are primary
+- bug / failure-mode questions \u2192 github (issue/PR), stackoverflow are primary
+- migration / sentiment / lived-experience \u2192 reddit, hackernews, blog are primary; docs are secondary
+- pricing / commercial \u2192 marketing (the vendor's own pricing page IS the primary source, but treat feature lists skeptically)
+- security / CVE \u2192 cve databases, distro security trackers (nvd.nist.gov, security-tracker.debian.org, ubuntu.com/security) are primary
+- synthesis / open-ended \u2192 blend; no single type is primary
+- product launch \u2192 vendor_doc + news + marketing for the launch itself; blogs + reddit for independent verification
+
+FRESHNESS: proportional to topic velocity. For a week-old release, demote anything older than 30 days. For general tech questions, demote older than 18 months. For stable protocols (HTTP, TCP, POSIX), don't demote by age.
+
+CONFIDENCE:
+- high = \u22653 HIGHLY_RELEVANT results from INDEPENDENT domains agree on the core answer
+- medium = \u22652 HIGHLY_RELEVANT exist but disagree or share a domain; OR a single authoritative primary source answers it
+- low = otherwise; snippet-only judgments cap at medium
+
+REFINE QUERIES \u2014 each MUST differ from every previousQuery by:
+- a new operator (site:, quotes, verbatim version number), OR
+- a domain-specific noun ABSENT from every prior query
+Adding a year alone does NOT count as differentiation.
+Each refine_query MUST reference a specific gap_id from the gaps array above.
+Produce 4\u20138 refine_queries total. Cover: (a) a primary-source probe, (b) a temporal sharpener, (c) a failure-mode or comparison probe, (d) at least one new-term probe seeded by a specific result's snippet.
+
+RULES:
+- Classify ALL ${urlsToClassify.length} results. Do not skip or collapse any.
+- Use only the three tier values.
+- Judge from title + domain + snippet only. Do NOT invent facts not present in the snippet.
+- If ALL results are OTHER: synthesis = "", confidence = "low", and \`gaps\` must explicitly state why the current queries missed the target.
+- Casing: tier = UPPERCASE_WITH_UNDERSCORES, confidence = lowercase.
+
+SEARCH RESULTS (${urlsToClassify.length} URLs from ${totalQueries} queries):
+${lines.join("\n")}`;
+  try {
+    mcpLog("info", `Classifying ${urlsToClassify.length} URLs against objective`, "llm");
+    const response = await requestTextWithFallback(
+      processor,
+      prompt,
+      "Search classification"
+    );
+    if (response.content === null) {
+      const errMsg = response.error ?? "LLM returned empty classification response";
+      markLLMFailure("planner", errMsg);
+      return { result: null, error: errMsg };
+    }
+    const cleaned = response.content.replace(/^```(?:json)?\s*\n?/m, "").replace(/\n?```\s*$/m, "").trim();
+    const parsed = JSON.parse(cleaned);
+    if (!parsed.title || typeof parsed.synthesis !== "string" || !Array.isArray(parsed.results)) {
+      const errMsg = "LLM response missing required fields (title, synthesis, results)";
+      markLLMFailure("planner", errMsg);
+      return { result: null, error: errMsg };
+    }
+    mcpLog("info", `Classification complete: ${parsed.results.filter((r) => r.tier === "HIGHLY_RELEVANT").length} highly relevant`, "llm");
+    markLLMSuccess("planner");
+    return { result: parsed };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    mcpLog("error", `Classification failed: ${message}`, "llm");
+    markLLMFailure("planner", message);
+    return { result: null, error: `Classification failed: ${message}` };
+  }
+}
+async function suggestRefineQueriesForRawMode(rankedUrls, objective, originalQueries, processor) {
+  const urlsToSummarize = rankedUrls.slice(0, 12);
+  const lines = urlsToSummarize.map((url) => {
+    let domain;
+    try {
+      domain = new URL(url.url).hostname.replace(/^www\./, "");
+    } catch {
+      domain = url.url;
+    }
+    return `[${url.rank}] ${url.title} \u2014 ${domain}`;
+  });
+  const prompt = `You are generating follow-up search queries for an agent using raw search results.
+
+Return ONLY a JSON object (no markdown, no code fences):
+{
+  "refine_queries": [
+    { "query": "next search query", "gap_description": "what gap this closes", "rationale": "\u226412 words on why" }
+  ]
+}
+
+OBJECTIVE: ${objective}
+
+PREVIOUS QUERIES (already run \u2014 do NOT paraphrase):
+${originalQueries.map((query) => `- ${query}`).join("\n")}
+
+TOP RESULT TITLES (to seed new-term probes):
+${lines.join("\n")}
+
+RULES:
+- Produce 4\u20136 diverse follow-ups. Cover: (a) a primary-source probe (site:, RFC, vendor docs); (b) a temporal sharpener (changelog, version number); (c) a failure-mode or comparison probe; (d) at least one new-term probe seeded by a specific result title.
+- Each query MUST differ from every previousQuery by either a new operator (site:, quotes, a verbatim version number) OR a domain-specific noun absent from every prior query. Adding a year alone does NOT count.
+- Each refine_query MUST include a \`gap_description\` naming what the current results don't answer.
+- Do not include URLs.
+- Keep rationales \u226412 words.`;
+  try {
+    const response = await requestTextWithFallback(
+      processor,
+      prompt,
+      "Raw-mode refine query generation"
+    );
+    if (response.content === null) {
+      const errMsg = response.error ?? "LLM returned empty raw-mode refine query response";
+      markLLMFailure("planner", errMsg);
+      return { result: [], error: errMsg };
+    }
+    const cleaned = response.content.replace(/^```(?:json)?\s*\n?/m, "").replace(/\n?```\s*$/m, "").trim();
+    const parsed = JSON.parse(cleaned);
+    markLLMSuccess("planner");
+    return { result: Array.isArray(parsed.refine_queries) ? parsed.refine_queries : [] };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    mcpLog("error", `Raw-mode refine query generation failed: ${message}`, "llm");
+    markLLMFailure("planner", message);
+    return { result: [], error: message };
+  }
+}
+var VALID_GOAL_CLASSES = /* @__PURE__ */ new Set([
+  "spec",
+  "bug",
+  "migration",
+  "sentiment",
+  "pricing",
+  "security",
+  "synthesis",
+  "product_launch",
+  "other"
+]);
+var VALID_FRESHNESS = /* @__PURE__ */ new Set(["days", "weeks", "months", "years"]);
+var VALID_BRANCHES = /* @__PURE__ */ new Set(["reddit", "web", "both"]);
+var VALID_STEP_TOOLS = /* @__PURE__ */ new Set(["raw-web-search", "smart-web-search", "raw-scrape-links", "smart-scrape-links"]);
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((v) => typeof v === "string");
+}
+function isStepArray(value) {
+  return Array.isArray(value) && value.every((s) => {
+    if (typeof s !== "object" || s === null) return false;
+    const tool = s.tool;
+    const reason = s.reason;
+    return typeof tool === "string" && VALID_STEP_TOOLS.has(tool) && typeof reason === "string" && reason.trim().length > 0;
+  });
+}
+function parseResearchBrief(raw) {
+  try {
+    const cleaned = raw.replace(/^```(?:json)?\s*\n?/m, "").replace(/\n?```\s*$/m, "").trim();
+    const parsed = JSON.parse(cleaned);
+    const goal_class = typeof parsed.goal_class === "string" ? parsed.goal_class : null;
+    if (!goal_class || !VALID_GOAL_CLASSES.has(goal_class)) return null;
+    const freshness_window = typeof parsed.freshness_window === "string" ? parsed.freshness_window : null;
+    if (!freshness_window || !VALID_FRESHNESS.has(freshness_window)) return null;
+    const primary_branch = parsed.primary_branch;
+    if (typeof primary_branch !== "string" || !VALID_BRANCHES.has(primary_branch)) return null;
+    if (!isStepArray(parsed.first_call_sequence) || parsed.first_call_sequence.length === 0) return null;
+    if (!isStringArray(parsed.keyword_seeds) || parsed.keyword_seeds.length === 0) return null;
+    return {
+      goal_class,
+      goal_class_reason: typeof parsed.goal_class_reason === "string" ? parsed.goal_class_reason : "",
+      primary_branch,
+      primary_branch_reason: typeof parsed.primary_branch_reason === "string" ? parsed.primary_branch_reason : "",
+      freshness_window,
+      first_call_sequence: parsed.first_call_sequence,
+      keyword_seeds: parsed.keyword_seeds.filter((s) => s.trim().length > 0),
+      iteration_hints: isStringArray(parsed.iteration_hints) ? parsed.iteration_hints : [],
+      gaps_to_watch: isStringArray(parsed.gaps_to_watch) ? parsed.gaps_to_watch : [],
+      stop_criteria: isStringArray(parsed.stop_criteria) ? parsed.stop_criteria : []
+    };
+  } catch {
+    return null;
+  }
+}
+async function generateResearchBrief(goal, processor, signal) {
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const prompt = `You are a research planner. An agent is about to run a multi-pass research loop on the goal below using 5 tools:
+
+  - start-research: orientation and this brief
+  - raw-web-search: raw search fan-out, keywords only, up to 50 keywords per call, no LLM; best for breadth, audit trails, and candidate URL capture
+  - smart-web-search: search fan-out + required LLM prioritization/classification over titles/snippets, scope: web|reddit|both, up to 50 keywords per call; best for triage after a strong diverse keyword set
+  - raw-scrape-links: fetch URLs as full markdown, urls only, no LLM; Reddit permalinks return threaded comments; best for complete context and ambiguous sources
+  - smart-scrape-links: fetch URLs then required LLM extraction over page bodies; Reddit permalinks return threaded comments before extraction; best for focused evidence extraction once facets are known
+
+Produce a tailored JSON brief.
+
+GOAL: ${goal}
+TODAY: ${today}
+
+Return ONLY a JSON object (no markdown, no code fences):
+
+{
+  "goal_class": "spec | bug | migration | sentiment | pricing | security | synthesis | product_launch | other",
+  "goal_class_reason": "one sentence \u2014 why this class",
+  "primary_branch": "reddit | web | both",
+  "primary_branch_reason": "one sentence \u2014 why this branch leads",
+  "freshness_window": "days | weeks | months | years",
+  "first_call_sequence": [
+    { "tool": "raw-web-search | smart-web-search | raw-scrape-links | smart-scrape-links", "reason": "what this call establishes for the agent" }
+  ],
+  "keyword_seeds": ["25\u201350 concrete search keywords \u2014 flat list, to be fired in the first search call as keywords"],
+  "iteration_hints": ["2\u20135 pointers on which harvested terms / follow-up signals to watch for after pass 1"],
+  "gaps_to_watch": ["2\u20135 concrete questions the agent MUST verify or the answer is incomplete"],
+  "stop_criteria": ["2\u20134 checkable conditions \u2014 all must hold before the agent declares done"]
+}
+
+RULES:
+
+primary_branch:
+- "reddit"  \u2192 sentiment / migration / lived-experience / community-consensus goals. Usually leads with raw-web-search using Reddit-focused keywords, then raw-scrape-links on post permalinks to preserve full comments.
+- "web"     \u2192 spec / bug / pricing / CVE / API / primary-source goals. Usually leads with raw-web-search for maximum candidate breadth OR smart-web-search scope:"web" when the initial keyword set is already diverse and needs prioritization.
+- "both"    \u2192 opinion-heavy AND needs official sources (e.g. product launch + practitioner reception).
+
+first_call_sequence:
+- 1\u20133 steps.
+- Use raw-web-search when the first need is recall: many distinct source classes, exact candidate URLs, Reddit permalink discovery, or cheap follow-up passes.
+- Use smart-web-search when the first need is prioritization: the agent has 10\u201350 distinct keyword probes and needs HIGHLY/MAYBE tiers, gaps, and refine queries. Smart search reads snippets only; never plan it as final evidence.
+- Use raw-scrape-links when complete page/thread context is valuable, the extraction shape is unclear, or Reddit comments are the source of truth.
+- Use smart-scrape-links when the extraction shape is known (facets separated by |) and the agent needs compact evidence from page bodies; this is usually the highest-value smart tool for answer construction.
+- reddit-first: step 1 = raw-web-search with Reddit permalink probes; step 2 = raw-scrape-links on best post permalinks for full comments. Add smart-web-search only when there are many candidate posts to triage.
+- web-first:    step 1 = raw-web-search for broad URL capture OR smart-web-search scope:"web" for prioritizing a diverse keyword fan-out; step 2 = smart-scrape-links on selected URLs when extraction facets are known, otherwise raw-scrape-links first.
+- both:         step 1 = parallel search calls split by source need; step 2 = raw-scrape-links for full evidence and smart-scrape-links for final extraction.
+
+keyword_seeds:
+- 25\u201350 total. Narrow bug \u2192 fewer. Open synthesis \u2192 more.
+- Write Google retrieval probes, not topic labels.
+- For each broad idea, first do a bad \u2192 better rewrite in your head: replace a vague phrase with a query that names the evidence source class, discriminating anchor terms, and one useful operator when possible.
+- ${QUERY_REWRITE_PAIR_GUIDANCE_TEXT}
+- Use operators where helpful (site:, quotes, verbatim version numbers, exact error text, package names, release/version strings).
+- DIVERSE facets \u2014 same noun-phrase cannot repeat across seeds with adjectives-only variation.
+- Optimize keyword_seeds for distinct coverage first. Smart-web-search can prioritize a broad result set, but it cannot compensate for a narrow or repetitive keyword set.
+- Do NOT invent vendor names you are uncertain exist.
+- For \`site:<domain>\` filters, ONLY use domains you are highly confident are real. Safe choices: \`github.com\`, \`stackoverflow.com\`, \`reddit.com\`, \`news.ycombinator.com\`, \`arxiv.org\`, \`nvd.nist.gov\`, \`pypi.org\`, \`npmjs.com\`, plus any canonical homepage/docs domain explicitly spelled out in the goal itself (e.g. goal names "Cursor" \u2192 \`cursor.com\`/\`docs.cursor.com\` is acceptable). If you don't know the product's real docs domain, leave the query open (no \`site:\`) instead of guessing.
+
+freshness_window:
+- If the goal mentions a recent release / date / version, use "days" or "weeks".
+- Stable protocols / APIs \u2192 "months" or "years".`;
+  try {
+    const response = await requestTextWithFallback(
+      processor,
+      prompt,
+      "Research brief generation",
+      signal
+    );
+    if (response.content === null) {
+      mcpLog("warning", `Research brief generation returned no content: ${response.error ?? "unknown"}`, "llm");
+      markLLMFailure("planner", response.error ?? "empty response");
+      return null;
+    }
+    const brief = parseResearchBrief(response.content);
+    if (!brief) {
+      mcpLog("warning", "Research brief JSON parse or shape validation failed", "llm");
+      markLLMFailure("planner", "brief parse/validation failed");
+      return null;
+    }
+    markLLMSuccess("planner");
+    return brief;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    mcpLog("warning", `Research brief generation failed: ${message}`, "llm");
+    markLLMFailure("planner", message);
+    return null;
+  }
+}
+
+// src/utils/markdown-formatter.ts
+function removeMetaTags(content) {
+  if (!content || typeof content !== "string") {
+    return content;
+  }
+  const lines = content.split("\n");
+  const filteredLines = lines.filter((line) => {
+    const trimmed = line.trim();
+    return !trimmed.startsWith("- Meta:") && !trimmed.startsWith("Meta:");
+  });
+  return filteredLines.join("\n");
+}
+
+// src/utils/content-extractor.ts
+import { Readability } from "@mozilla/readability";
+import { JSDOM, VirtualConsole } from "jsdom";
+var MAX_READABILITY_BYTES = 15e5;
+function extractReadableContent(html, url) {
+  if (!html || typeof html !== "string") {
+    return { title: "", content: html ?? "", extracted: false };
+  }
+  if (html.length > MAX_READABILITY_BYTES) {
+    return { title: "", content: html, extracted: false };
+  }
+  if (!html.includes("<")) {
+    return { title: "", content: html, extracted: false };
+  }
+  const virtualConsole = new VirtualConsole();
+  virtualConsole.on("error", () => {
+  });
+  virtualConsole.on("warn", () => {
+  });
+  virtualConsole.on("jsdomError", () => {
+  });
+  let dom;
+  try {
+    dom = new JSDOM(html, {
+      url: url && /^https?:/i.test(url) ? url : "https://example.com/",
+      virtualConsole
+    });
+  } catch (err) {
+    mcpLog("warning", `JSDOM construction failed: ${err instanceof Error ? err.message : String(err)}`, "content-extractor");
+    return { title: "", content: html, extracted: false };
+  }
+  try {
+    const reader = new Readability(dom.window.document, {
+      // Keep classes that downstream cleanup may need; Turndown ignores them.
+      keepClasses: false
+      // Strip <script>/<style> already handled by Readability defaults.
+    });
+    const article = reader.parse();
+    if (!article || !article.content) {
+      return { title: article?.title ?? "", content: html, extracted: false };
+    }
+    return {
+      title: article.title ?? "",
+      content: article.content,
+      byline: article.byline ?? void 0,
+      extracted: true
+    };
+  } catch (err) {
+    mcpLog("warning", `Readability.parse failed: ${err instanceof Error ? err.message : String(err)}`, "content-extractor");
+    return { title: "", content: html, extracted: false };
+  } finally {
+    try {
+      dom.window.close();
+    } catch {
+    }
+  }
+}
+
+// src/utils/source-type.ts
+var DOCUMENT_PATH_SUFFIXES = [
+  ".pdf",
+  ".doc",
+  ".docx",
+  ".ppt",
+  ".pptx",
+  ".xls",
+  ".xlsx"
+];
+function isDocumentUrl(url) {
+  let pathname;
+  try {
+    pathname = new URL(url).pathname.toLowerCase();
+  } catch {
+    return false;
+  }
+  for (const suffix of DOCUMENT_PATH_SUFFIXES) {
+    if (pathname.endsWith(suffix)) return true;
+  }
+  return false;
+}
+
+// src/utils/content-quality.ts
+var MIN_MARKDOWN_CHARS = 800;
+var MIN_MARKDOWN_WORDS = 120;
+var BLOCK_PHRASES = [
+  "access denied",
+  "are you a human",
+  "captcha",
+  "checking your browser",
+  "enable javascript",
+  "just a moment",
+  "login required",
+  "please enable cookies",
+  "please verify you are human",
+  "sign in to continue",
+  "temporarily unavailable"
+];
+function countWords(content) {
+  const matches = content.trim().match(/\S+/g);
+  return matches ? matches.length : 0;
+}
+function findBlockPhrase(content) {
+  const lower = content.toLowerCase();
+  return BLOCK_PHRASES.find((phrase) => lower.includes(phrase));
+}
+function assessMarkdownQuality(content) {
+  const trimmed = content.trim();
+  const charCount = trimmed.length;
+  const wordCount = countWords(trimmed);
+  const blockPhrase = findBlockPhrase(trimmed);
+  if (blockPhrase) {
+    return {
+      weak: true,
+      reason: `blocked_or_interstitial:${blockPhrase}`,
+      charCount,
+      wordCount,
+      blockPhrase
+    };
+  }
+  if (charCount < MIN_MARKDOWN_CHARS) {
+    return {
+      weak: true,
+      reason: `too_few_chars:${charCount}<${MIN_MARKDOWN_CHARS}`,
+      charCount,
+      wordCount
+    };
+  }
+  if (wordCount < MIN_MARKDOWN_WORDS) {
+    return {
+      weak: true,
+      reason: `too_few_words:${wordCount}<${MIN_MARKDOWN_WORDS}`,
+      charCount,
+      wordCount
+    };
+  }
+  return {
+    weak: false,
+    reason: "ok",
+    charCount,
+    wordCount
+  };
+}
+
+// src/effect/runtime.ts
+import { Effect as Effect2, Layer as Layer2 } from "effect";
+
+// src/effect/services.ts
+import { Context, Effect, Layer } from "effect";
+
+// src/utils/concurrency.ts
+import pMapLib from "p-map";
+async function pMap(items, mapper, concurrency = 6, signal) {
+  if (items.length === 0) return [];
+  const limit = Math.max(1, Math.min(concurrency, items.length));
+  return pMapLib(items, mapper, { concurrency: limit, signal });
+}
+async function pMapSettled(items, mapper, concurrency = 6, signal) {
+  if (items.length === 0) return [];
+  const limit = Math.max(1, Math.min(concurrency, items.length));
+  return pMapLib(
+    items,
+    async (item, index) => {
+      try {
+        const value = await mapper(item, index);
+        return { status: "fulfilled", value };
+      } catch (reason) {
+        return { status: "rejected", reason };
+      }
+    },
+    { concurrency: limit, signal, stopOnError: false }
+  );
+}
+
+// src/clients/search.ts
+var SERPER_API_URL = "https://google.serper.dev/search";
+var DEFAULT_RESULTS_PER_QUERY = 10;
+var MAX_RETRIES2 = 3;
+var SEARCH_RETRY_CONFIG = {
+  maxRetries: MAX_RETRIES2,
+  baseDelayMs: 1e3,
+  maxDelayMs: 1e4,
+  timeoutMs: 3e4
+};
+var RETRYABLE_SEARCH_CODES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+var REDDIT_SITE_REGEX = /site:\s*reddit\.com/i;
+var REDDIT_SUBREDDIT_SUFFIX_REGEX = / : r\/\w+$/;
+var REDDIT_SUFFIX_REGEX = / - Reddit$/;
+function parseSearchResponses(responses, queries) {
+  return responses.map((resp, index) => {
+    try {
+      const organic = resp.organic || [];
+      const results = organic.map((item, idx) => ({
+        title: item.title || "No title",
+        link: item.link || "#",
+        snippet: item.snippet || "",
+        date: item.date,
+        position: item.position || idx + 1
+      }));
+      const searchInfo = resp.searchInformation;
+      const totalResults = searchInfo?.totalResults ? parseInt(String(searchInfo.totalResults).replace(/,/g, ""), 10) : results.length;
+      const relatedSearches = resp.relatedSearches || [];
+      const related = relatedSearches.map((r) => r.query || "");
+      return { query: queries[index] || "", results, totalResults, related };
+    } catch {
+      return { query: queries[index] || "", results: [], totalResults: 0, related: [] };
+    }
+  });
+}
+async function executeSearchWithRetry(apiKey, body, isRetryable) {
+  let lastError;
+  for (let attempt = 0; attempt <= SEARCH_RETRY_CONFIG.maxRetries; attempt++) {
+    try {
+      if (attempt > 0) {
+        mcpLog("warning", `Retry attempt ${attempt}/${SEARCH_RETRY_CONFIG.maxRetries}`, "search");
+      }
+      const response = await fetchWithTimeout(SERPER_API_URL, {
+        method: "POST",
+        headers: {
+          "X-API-KEY": apiKey,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(body),
+        timeoutMs: SEARCH_RETRY_CONFIG.timeoutMs
+      });
+      if (!response.ok) {
+        const errorText = await response.text().catch(() => "");
+        lastError = classifyError({ status: response.status, message: errorText });
+        if (isRetryable(response.status) && attempt < SEARCH_RETRY_CONFIG.maxRetries) {
+          const delayMs = calculateBackoff2(attempt, SEARCH_RETRY_CONFIG.baseDelayMs, SEARCH_RETRY_CONFIG.maxDelayMs);
+          mcpLog("warning", `API returned ${response.status}, retrying in ${delayMs}ms...`, "search");
+          await sleep(delayMs);
+          continue;
+        }
+        return { data: void 0, error: lastError };
+      }
+      try {
+        const data = await response.json();
+        return { data };
+      } catch {
+        return {
+          data: void 0,
+          error: { code: ErrorCode.PARSE_ERROR, message: "Failed to parse search response", retryable: false }
+        };
+      }
+    } catch (error2) {
+      lastError = classifyError(error2);
+      if (isRetryable(void 0, error2) && attempt < SEARCH_RETRY_CONFIG.maxRetries) {
+        const delayMs = calculateBackoff2(attempt, SEARCH_RETRY_CONFIG.baseDelayMs, SEARCH_RETRY_CONFIG.maxDelayMs);
+        mcpLog("warning", `${lastError.code}: ${lastError.message}, retrying in ${delayMs}ms...`, "search");
+        await sleep(delayMs);
+        continue;
+      }
+      return { data: void 0, error: lastError };
+    }
+  }
+  return {
+    data: void 0,
+    error: lastError || { code: ErrorCode.UNKNOWN_ERROR, message: "Search failed", retryable: false }
+  };
+}
+var SearchClient = class {
+  apiKey;
+  constructor(apiKey) {
+    const env = parseEnv();
+    this.apiKey = apiKey || env.SEARCH_API_KEY || "";
+    if (!this.apiKey) {
+      throw new Error("Web search capability is not configured. Please set up the required API credentials.");
+    }
+  }
+  /**
+   * Check if error is retryable
+   */
+  isRetryable(status, error2) {
+    if (status && RETRYABLE_SEARCH_CODES.has(status)) return true;
+    if (error2 == null) return false;
+    const message = typeof error2 === "object" && "message" in error2 && typeof error2.message === "string" ? error2.message.toLowerCase() : "";
+    return message.includes("timeout") || message.includes("rate limit") || message.includes("connection");
+  }
+  /**
+   * Search multiple queries in parallel
+   * NEVER throws - always returns a valid response
+   */
+  async searchMultiple(queries) {
+    const startTime = Date.now();
+    if (queries.length === 0) {
+      return {
+        searches: [],
+        totalQueries: 0,
+        executionTime: 0,
+        error: { code: ErrorCode.INVALID_INPUT, message: "No queries provided", retryable: false }
+      };
+    }
+    const searchQueries = queries.map((query) => ({ q: query }));
+    const { data, error: error2 } = await executeSearchWithRetry(
+      this.apiKey,
+      searchQueries,
+      (status, err) => this.isRetryable(status, err)
+    );
+    if (error2 || data === void 0) {
+      return {
+        searches: [],
+        totalQueries: queries.length,
+        executionTime: Date.now() - startTime,
+        error: error2 ?? { code: ErrorCode.UNKNOWN_ERROR, message: "Search provider returned no data", retryable: false }
+      };
+    }
+    const responses = Array.isArray(data) ? data : [data];
+    const searches = parseSearchResponses(responses, queries);
+    return { searches, totalQueries: queries.length, executionTime: Date.now() - startTime };
+  }
+  /**
+   * Search Reddit via Google (adds site:reddit.com automatically)
+   * NEVER throws - returns empty array on failure
+   */
+  async searchReddit(query, dateAfter) {
+    if (!query?.trim()) {
+      return [];
+    }
+    let q = query.replace(REDDIT_SITE_REGEX, "").trim() + " site:reddit.com";
+    if (dateAfter) {
+      q += ` after:${dateAfter}`;
+    }
+    for (let attempt = 0; attempt <= SEARCH_RETRY_CONFIG.maxRetries; attempt++) {
+      try {
+        const res = await fetchWithTimeout(SERPER_API_URL, {
+          method: "POST",
+          headers: { "X-API-KEY": this.apiKey, "Content-Type": "application/json" },
+          body: JSON.stringify({ q, num: DEFAULT_RESULTS_PER_QUERY }),
+          timeoutMs: SEARCH_RETRY_CONFIG.timeoutMs
+        });
+        if (!res.ok) {
+          if (this.isRetryable(res.status) && attempt < SEARCH_RETRY_CONFIG.maxRetries) {
+            const delayMs = calculateBackoff2(attempt, SEARCH_RETRY_CONFIG.baseDelayMs, SEARCH_RETRY_CONFIG.maxDelayMs);
+            mcpLog("warning", `Reddit search ${res.status}, retrying in ${delayMs}ms...`, "search");
+            await sleep(delayMs);
+            continue;
+          }
+          mcpLog("error", `Reddit search failed with status ${res.status}`, "search");
+          return [];
+        }
+        const data = await res.json();
+        return (data.organic || []).map((r) => ({
+          title: (r.title || "").replace(REDDIT_SUBREDDIT_SUFFIX_REGEX, "").replace(REDDIT_SUFFIX_REGEX, ""),
+          url: r.link || "",
+          snippet: r.snippet || "",
+          date: r.date
+        }));
+      } catch (error2) {
+        const err = classifyError(error2);
+        if (this.isRetryable(void 0, error2) && attempt < SEARCH_RETRY_CONFIG.maxRetries) {
+          const delayMs = calculateBackoff2(attempt, SEARCH_RETRY_CONFIG.baseDelayMs, SEARCH_RETRY_CONFIG.maxDelayMs);
+          mcpLog("warning", `Reddit search ${err.code}, retrying in ${delayMs}ms...`, "search");
+          await sleep(delayMs);
+          continue;
+        }
+        mcpLog("error", `Reddit search failed: ${err.message}`, "search");
+        return [];
+      }
+    }
+    return [];
+  }
+  /**
+   * Search Reddit with multiple queries (bounded concurrency)
+   * NEVER throws - searchReddit never throws, pMap preserves order
+   */
+  async searchRedditMultiple(queries, dateAfter) {
+    if (queries.length === 0) {
+      return /* @__PURE__ */ new Map();
+    }
+    const results = await pMap(
+      queries,
+      (q) => this.searchReddit(q, dateAfter),
+      CONCURRENCY.SEARCH
+    );
+    return new Map(queries.map((q, i) => [q, results[i] || []]));
+  }
+};
+
+// src/clients/kernel.ts
+import Kernel from "@onkernel/sdk";
+var DEFAULT_RENDER_TIMEOUT_SECONDS = 15;
+var BROWSER_IDLE_TIMEOUT_SECONDS = 300;
+var KernelClient = class {
+  kernel;
+  constructor(apiKey) {
+    const env = parseEnv();
+    const resolvedKey = apiKey?.trim() || env.KERNEL_API_KEY;
+    if (!resolvedKey) {
+      throw new Error("Kernel browser rendering is not configured. Set KERNEL_API_KEY.");
+    }
+    this.kernel = new Kernel({
+      apiKey: resolvedKey,
+      timeout: 3e4,
+      maxRetries: 1,
+      ...env.KERNEL_PROJECT ? { defaultHeaders: { "X-Kernel-Project-Id": env.KERNEL_PROJECT } } : {}
+    });
+  }
+  async render(request) {
+    const { url, timeoutSeconds = DEFAULT_RENDER_TIMEOUT_SECONDS } = request;
+    try {
+      new URL(url);
+    } catch {
+      return {
+        content: `Invalid URL: ${url}`,
+        statusCode: 400,
+        credits: 0,
+        error: { code: ErrorCode.INVALID_INPUT, message: `Invalid URL: ${url}`, retryable: false }
+      };
+    }
+    let sessionId;
+    try {
+      const session = await this.kernel.browsers.create({
+        headless: true,
+        stealth: true,
+        timeout_seconds: BROWSER_IDLE_TIMEOUT_SECONDS,
+        viewport: { width: 1280, height: 800 }
+      });
+      sessionId = session.session_id;
+      const response = await this.kernel.browsers.playwright.execute(session.session_id, {
+        code: buildRenderScript(url, timeoutSeconds),
+        timeout_sec: Math.min(timeoutSeconds + 5, 300)
+      });
+      if (!response.success) {
+        const message = response.error || response.stderr || "Kernel Playwright execution failed";
+        return {
+          content: `Kernel render failed: ${message}`,
+          statusCode: 500,
+          credits: 0,
+          error: { code: ErrorCode.SERVICE_UNAVAILABLE, message, retryable: true }
+        };
+      }
+      const rendered = parseRenderedPage(response.result);
+      if (!rendered) {
+        return {
+          content: "Kernel render returned an invalid payload",
+          statusCode: 500,
+          credits: 0,
+          error: {
+            code: ErrorCode.PARSE_ERROR,
+            message: "Kernel render returned an invalid payload",
+            retryable: false
+          }
+        };
+      }
+      return {
+        content: rendered.html,
+        statusCode: 200,
+        credits: 0,
+        finalUrl: rendered.finalUrl,
+        title: rendered.title,
+        text: rendered.text
+      };
+    } catch (error2) {
+      const err = formatKernelError(error2);
+      return {
+        content: `Kernel render failed: ${err.message}`,
+        statusCode: err.statusCode ?? 500,
+        credits: 0,
+        error: err
+      };
+    } finally {
+      if (sessionId) {
+        try {
+          await this.kernel.browsers.deleteByID(sessionId);
+        } catch (deleteError) {
+          const err = formatKernelError(deleteError);
+          mcpLog("warning", `Kernel browser cleanup failed for ${sessionId}: ${err.message}`, "kernel");
+        }
+      }
+    }
+  }
+};
+function buildRenderScript(url, timeoutSeconds) {
+  const timeoutMs = timeoutSeconds * 1e3;
+  return `
+const targetUrl = ${JSON.stringify(url)};
+const timeoutMs = ${timeoutMs};
+await page.goto(targetUrl, { waitUntil: 'domcontentloaded', timeout: timeoutMs });
+await page.waitForLoadState('networkidle', { timeout: Math.min(5000, timeoutMs) }).catch(() => {});
+const html = await page.content();
+const text = await page.locator('body').innerText({ timeout: 2000 }).catch(() => '');
+return {
+  html,
+  text,
+  title: await page.title(),
+  finalUrl: page.url(),
+};
+`;
+}
+function parseRenderedPage(value) {
+  if (!isRecord2(value)) return null;
+  const html = readString2(value, "html");
+  const finalUrl = readString2(value, "finalUrl");
+  const title = readString2(value, "title");
+  const text = readString2(value, "text");
+  if (!html || !finalUrl || title === void 0 || text === void 0) return null;
+  return { html, finalUrl, title, text };
+}
+function formatKernelError(error2) {
+  if (error2 instanceof Kernel.APIError) {
+    return {
+      ...classifyError({ status: error2.status, message: error2.message }),
+      cause: error2.message
+    };
+  }
+  return classifyError(error2);
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function readString2(value, key) {
+  const child = value[key];
+  return typeof child === "string" ? child : void 0;
+}
+
+// src/clients/reddit.ts
+import { Logger as Logger4 } from "mcp-use";
+var REDDIT_TOKEN_URL = "https://www.reddit.com/api/v1/access_token";
+var REDDIT_API_BASE = "https://oauth.reddit.com";
+var TOKEN_EXPIRY_MS = 55e3;
+var FETCH_LIMIT = 500;
+var cachedToken = null;
+var cachedTokenExpiry = 0;
+var DEBUG_TOKEN_CACHE = process.env.DEBUG_REDDIT === "true";
+var clientLogger = Logger4.get("reddit-client");
+var pendingAuthPromise = null;
+async function fetchRedditJson(sub, id, token, userAgent) {
+  const limit = Math.min(FETCH_LIMIT, 500);
+  const apiUrl = `${REDDIT_API_BASE}/r/${sub}/comments/${id}?sort=top&limit=${limit}&depth=10&raw_json=1`;
+  const res = await fetchWithTimeout(apiUrl, {
+    headers: {
+      "Authorization": `Bearer ${token}`,
+      "User-Agent": userAgent
+    },
+    timeoutMs: 3e4
+  });
+  if (res.status === 429) {
+    const err = new Error("Rate limited by Reddit API");
+    err.status = 429;
+    throw err;
+  }
+  if (res.status === 404) {
+    throw new Error(`Post not found: /r/${sub}/comments/${id}`);
+  }
+  if (!res.ok) {
+    const err = new Error(`Reddit API error: ${res.status}`);
+    err.status = res.status;
+    throw err;
+  }
+  try {
+    return await res.json();
+  } catch {
+    throw new Error("Failed to parse Reddit API response");
+  }
+}
+function parsePostData(postListing, sub) {
+  const p = postListing?.data?.children?.[0]?.data;
+  if (!p) {
+    throw new Error(`Post data not found in response for /r/${sub}`);
+  }
+  return {
+    title: p.title || "Untitled",
+    author: p.author || "[deleted]",
+    subreddit: p.subreddit || sub,
+    body: formatBody(p),
+    score: p.score || 0,
+    commentCount: p.num_comments || 0,
+    url: `https://reddit.com${p.permalink || ""}`,
+    created: new Date((p.created_utc || 0) * 1e3),
+    flair: p.link_flair_text || void 0,
+    isNsfw: p.over_18 || false,
+    isPinned: p.stickied || false
+  };
+}
+function formatBody(p) {
+  if (p.selftext?.trim()) return p.selftext;
+  if (p.is_self) return "";
+  if (p.url) return `**Link:** ${p.url}`;
+  return "";
+}
+var MAX_COMMENT_DEPTH = 15;
+function parseCommentTree(commentListing, opAuthor) {
+  const result = [];
+  const extract = (items, depth = 0) => {
+    if (depth > MAX_COMMENT_DEPTH) return;
+    const sorted = [...items].sort((a, b) => (b.data?.score || 0) - (a.data?.score || 0));
+    for (const c of sorted) {
+      if (c.kind !== "t1" || !c.data?.author || c.data.author === "[deleted]") continue;
+      result.push({
+        author: c.data.author,
+        body: c.data.body || "",
+        score: c.data.score || 0,
+        depth,
+        isOP: c.data.author === opAuthor
+      });
+      if (typeof c.data.replies === "object" && c.data.replies?.data?.children) {
+        extract(c.data.replies.data.children, depth + 1);
+      }
+    }
+  };
+  extract(commentListing?.data?.children || []);
+  return result;
+}
+async function processBatch(client, batchUrls) {
+  const results = /* @__PURE__ */ new Map();
+  let rateLimitHits = 0;
+  const batchResults = await pMapSettled(
+    batchUrls,
+    (url) => client.getPost(url),
+    CONCURRENCY.REDDIT
+  );
+  for (let i = 0; i < batchResults.length; i++) {
+    const result = batchResults[i];
+    if (!result) continue;
+    const url = batchUrls[i] ?? "";
+    if (result.status === "fulfilled") {
+      results.set(url, result.value);
+    } else {
+      const errorMsg = result.reason?.message || String(result.reason);
+      if (errorMsg.includes("429") || errorMsg.includes("rate")) rateLimitHits++;
+      results.set(url, new Error(errorMsg));
+    }
+  }
+  return { results, rateLimitHits };
+}
+var RedditClient = class {
+  constructor(clientId, clientSecret) {
+    this.clientId = clientId;
+    this.clientSecret = clientSecret;
+  }
+  userAgent = `script:${USER_AGENT_VERSION} (by /u/research-powerpack)`;
+  /**
+   * Authenticate with Reddit API with retry logic
+   * Uses module-level token cache and promise deduplication to prevent
+   * concurrent auth calls from firing multiple token requests
+   * Returns null on failure instead of throwing
+   */
+  async auth() {
+    if (cachedToken && Date.now() < cachedTokenExpiry - TOKEN_EXPIRY_MS) {
+      if (DEBUG_TOKEN_CACHE) clientLogger.debug("Token cache HIT");
+      return cachedToken;
+    }
+    if (pendingAuthPromise) {
+      if (DEBUG_TOKEN_CACHE) clientLogger.debug("Auth already in flight, awaiting...");
+      return pendingAuthPromise;
+    }
+    pendingAuthPromise = this.performAuth();
+    try {
+      return await pendingAuthPromise;
+    } finally {
+      pendingAuthPromise = null;
+    }
+  }
+  async performAuth() {
+    if (DEBUG_TOKEN_CACHE) clientLogger.debug("Token cache MISS - authenticating");
+    const credentials = Buffer.from(`${this.clientId}:${this.clientSecret}`).toString("base64");
+    for (let attempt = 0; attempt < 3; attempt++) {
+      try {
+        const res = await fetchWithTimeout(REDDIT_TOKEN_URL, {
+          method: "POST",
+          headers: {
+            "Authorization": `Basic ${credentials}`,
+            "Content-Type": "application/x-www-form-urlencoded",
+            "User-Agent": this.userAgent
+          },
+          body: "grant_type=client_credentials",
+          timeoutMs: 15e3
+        });
+        if (!res.ok) {
+          const text = await res.text().catch(() => "");
+          mcpLog("error", `Auth failed (${res.status}): ${text}`, "reddit");
+          if (res.status === 401 || res.status === 403) {
+            cachedToken = null;
+            cachedTokenExpiry = 0;
+            return null;
+          }
+          if (res.status >= 500 && attempt < 2) {
+            await sleep(calculateBackoff2(attempt));
+            continue;
+          }
+          return null;
+        }
+        const data = await res.json();
+        if (!data.access_token) {
+          mcpLog("error", "Auth response missing access_token", "reddit");
+          return null;
+        }
+        cachedToken = data.access_token;
+        cachedTokenExpiry = Date.now() + (data.expires_in || 3600) * 1e3;
+        return cachedToken;
+      } catch (error2) {
+        const err = classifyError(error2);
+        mcpLog("error", `Auth error (attempt ${attempt + 1}): ${err.message}`, "reddit");
+        if (err.code === ErrorCode.AUTH_ERROR) {
+          cachedToken = null;
+          cachedTokenExpiry = 0;
+        }
+        if (attempt < 2 && err.retryable) {
+          await sleep(calculateBackoff2(attempt));
+          continue;
+        }
+        return null;
+      }
+    }
+    return null;
+  }
+  parseUrl(url) {
+    const m = url.match(/reddit\.com\/r\/([^\/]+)\/comments\/([a-z0-9]+)/i);
+    return m ? { sub: m[1], id: m[2] } : null;
+  }
+  /**
+   * Get a single Reddit post with comments
+   * Returns PostResult or throws Error (for use with Promise.allSettled)
+   */
+  async getPost(url) {
+    const parsed = this.parseUrl(url);
+    if (!parsed) {
+      throw new Error(`Invalid Reddit URL format: ${url}`);
+    }
+    const token = await this.auth();
+    if (!token) {
+      throw new Error("Reddit authentication failed - check credentials");
+    }
+    let lastError = null;
+    for (let attempt = 0; attempt < REDDIT.RETRY_COUNT; attempt++) {
+      try {
+        const data = await fetchRedditJson(parsed.sub, parsed.id, token, this.userAgent);
+        const [postListing, commentListing] = data;
+        const post = parsePostData(postListing, parsed.sub);
+        const comments = parseCommentTree(commentListing, post.author);
+        return { post, comments, actualComments: post.commentCount };
+      } catch (error2) {
+        lastError = classifyError(error2);
+        const status = error2.status;
+        if (status === 429) {
+          const delay = REDDIT.RETRY_DELAYS[attempt] || 32e3;
+          mcpLog("warning", `Rate limited. Retry ${attempt + 1}/${REDDIT.RETRY_COUNT} after ${delay}ms`, "reddit");
+          await sleep(delay);
+          continue;
+        }
+        if (!lastError.retryable) {
+          throw error2 instanceof Error ? error2 : new Error(lastError.message);
+        }
+        if (attempt < REDDIT.RETRY_COUNT - 1) {
+          const delay = REDDIT.RETRY_DELAYS[attempt] || 2e3;
+          mcpLog("warning", `${lastError.code}: ${lastError.message}. Retry ${attempt + 1}/${REDDIT.RETRY_COUNT}`, "reddit");
+          await sleep(delay);
+        }
+      }
+    }
+    throw new Error(lastError?.message || "Failed to fetch Reddit post after retries");
+  }
+  async batchGetPosts(urls, fetchComments = true, onBatchComplete) {
+    const allResults = /* @__PURE__ */ new Map();
+    let rateLimitHits = 0;
+    const totalBatches = Math.ceil(urls.length / REDDIT.BATCH_SIZE);
+    mcpLog("info", `Fetching ${urls.length} posts in ${totalBatches} batch(es), up to ${FETCH_LIMIT} comments/post`, "reddit");
+    for (let batchNum = 0; batchNum < totalBatches; batchNum++) {
+      const startIdx = batchNum * REDDIT.BATCH_SIZE;
+      const batchUrls = urls.slice(startIdx, startIdx + REDDIT.BATCH_SIZE);
+      mcpLog("info", `Batch ${batchNum + 1}/${totalBatches} (${batchUrls.length} posts)`, "reddit");
+      const batchResult = await processBatch(this, batchUrls);
+      for (const [url, result] of batchResult.results) {
+        allResults.set(url, result);
+      }
+      rateLimitHits += batchResult.rateLimitHits;
+      try {
+        onBatchComplete?.(batchNum + 1, totalBatches, allResults.size);
+      } catch (callbackError) {
+        mcpLog("error", `onBatchComplete callback error: ${callbackError}`, "reddit");
+      }
+      mcpLog("info", `Batch ${batchNum + 1} complete (${allResults.size}/${urls.length})`, "reddit");
+      if (batchNum < totalBatches - 1) {
+        await sleep(500);
+      }
+    }
+    return { results: allResults, batchesProcessed: totalBatches, totalPosts: urls.length, rateLimitHits };
+  }
+};
+
+// src/effect/errors.ts
+import { Data } from "effect";
+var ProviderRequestError = class extends Data.TaggedError("ProviderRequestError") {
+};
+var ProviderTimeoutError = class extends Data.TaggedError("ProviderTimeoutError") {
+};
+var WeakContentError = class extends Data.TaggedError("WeakContentError") {
+};
+var AllStrategiesExhaustedError = class extends Data.TaggedError("AllStrategiesExhaustedError") {
+};
+function providerError(provider, operation, error2) {
+  return new ProviderRequestError({
+    provider,
+    operation,
+    error: classifyError(error2)
+  });
+}
+
+// src/effect/services.ts
+var SearchService = Context.GenericTag("SearchService");
+var JinaService = Context.GenericTag("JinaService");
+var KernelService = Context.GenericTag("KernelService");
+var RedditService = Context.GenericTag("RedditService");
+var LlmService = Context.GenericTag("LlmService");
+var SearchServiceLive = Layer.sync(SearchService, () => {
+  const env = parseEnv();
+  return {
+    serperSearchMultiple: (queries) => Effect.tryPromise({
+      try: () => new SearchClient(env.SEARCH_API_KEY).searchMultiple([...queries]),
+      catch: (error2) => providerError("serper", "searchMultiple", error2)
+    }),
+    jinaSearchMultiple: (queries) => Effect.tryPromise({
+      try: () => new JinaClient(env.JINA_API_KEY).searchMultiple([...queries]),
+      catch: (error2) => providerError("jina", "searchMultiple", error2)
+    })
+  };
+});
+var JinaServiceLive = Layer.sync(JinaService, () => {
+  const env = parseEnv();
+  const client = new JinaClient(env.JINA_API_KEY);
+  return {
+    convert: (request) => Effect.tryPromise({
+      try: () => client.convert(request),
+      catch: (error2) => providerError("jina", "convert", error2)
+    })
+  };
+});
+var KernelServiceLive = Layer.sync(KernelService, () => {
+  const client = new KernelClient();
+  return {
+    render: (request) => Effect.tryPromise({
+      try: () => client.render(request),
+      catch: (error2) => providerError("kernel", "render", error2)
+    })
+  };
+});
+function RedditServiceLive(clientId, clientSecret) {
+  return Layer.sync(RedditService, () => {
+    const client = new RedditClient(clientId, clientSecret);
+    return {
+      batchGetPosts: (urls, includeComments) => Effect.tryPromise({
+        try: () => client.batchGetPosts([...urls], includeComments),
+        catch: (error2) => providerError("reddit", "batchGetPosts", error2)
+      })
+    };
+  });
+}
+var LlmServiceLive = Layer.succeed(LlmService, {
+  extractContent: (content, config) => Effect.tryPromise({
+    try: () => processContentWithLLM(content, config, createLLMProcessor()),
+    catch: (error2) => providerError("llm", "extractContent", error2)
+  }),
+  classifySearchResults: (rankedUrls, objective, totalQueries, processor, previousQueries) => Effect.tryPromise({
+    try: () => classifySearchResults(rankedUrls, objective, totalQueries, processor, previousQueries),
+    catch: (error2) => providerError("llm", "classifySearchResults", error2)
+  }),
+  suggestRefineQueriesForRawMode: (rankedUrls, objective, originalQueries, processor) => Effect.tryPromise({
+    try: () => suggestRefineQueriesForRawMode(rankedUrls, objective, originalQueries, processor),
+    catch: (error2) => providerError("llm", "suggestRefineQueriesForRawMode", error2)
+  }),
+  generateResearchBrief: (goal, processor) => Effect.tryPromise({
+    try: () => generateResearchBrief(goal, processor),
+    catch: (error2) => providerError("llm", "generateResearchBrief", error2)
+  })
+});
+
+// src/effect/runtime.ts
+var BaseExternalLive = Layer2.mergeAll(
   JinaServiceLive,
-  KernelService,
-  KernelServiceLive,
-  LlmService,
-  LlmServiceLive,
-  RedditService,
-  RedditServiceLive
-} from "../effect/services.js";
-import { ProviderTimeoutError } from "../effect/errors.js";
-import {
-  mcpLog,
-  formatSuccess,
-  formatError,
-  formatBatchHeader,
-  formatDuration
-} from "./utils.js";
-import {
-  createToolReporter,
-  NOOP_REPORTER,
-  toolFailure,
-  toolSuccess,
-  toToolResponse
-} from "./mcp-helpers.js";
-const markdownCleaner = new MarkdownCleaner();
+  SearchServiceLive,
+  LlmServiceLive
+);
+function runExternalEffect(effect, layer) {
+  return Effect2.runPromise(effect.pipe(Effect2.provide(layer)));
+}
+
+// src/utils/response.ts
+var SECONDS_MS = 1e3;
+var MINUTES_MS = 6e4;
+function formatSuccess(opts) {
+  const parts = [];
+  parts.push(`\u2713 ${opts.title}`);
+  parts.push("");
+  parts.push(opts.summary);
+  if (opts.data) {
+    parts.push("");
+    parts.push("---");
+    parts.push(opts.data);
+  }
+  if (opts.nextSteps?.length) {
+    parts.push("");
+    parts.push("---");
+    parts.push("**Next Steps:**");
+    opts.nextSteps.forEach((step) => parts.push(`\u2192 ${step}`));
+  }
+  if (opts.metadata && Object.keys(opts.metadata).length > 0) {
+    parts.push("");
+    parts.push("---");
+    const metaStr = Object.entries(opts.metadata).map(([k, v]) => `${k}: ${v}`).join(" | ");
+    parts.push(`*${metaStr}*`);
+  }
+  return parts.join("\n");
+}
+function formatError(opts) {
+  const parts = [];
+  const prefix = opts.toolName ? `[${opts.toolName}] ` : "";
+  parts.push(`\u274C ${prefix}${opts.code}: ${opts.message}`);
+  if (opts.retryable) {
+    parts.push("*Retryable.*");
+  }
+  if (opts.howToFix?.length) {
+    parts.push("");
+    parts.push("**How to Fix:**");
+    opts.howToFix.forEach((step, i) => parts.push(`${i + 1}. ${step}`));
+  }
+  if (opts.alternatives?.length) {
+    parts.push("");
+    parts.push("**Alternatives:**");
+    opts.alternatives.forEach((alt, i) => parts.push(`${i + 1}. ${alt}`));
+  }
+  return parts.join("\n");
+}
+function formatBatchHeader(opts) {
+  const parts = [];
+  const successRate = opts.totalItems > 0 ? opts.successful / opts.totalItems : 0;
+  const emoji = successRate === 1 ? "\u2713" : successRate >= 0.5 ? "\u26A0\uFE0F" : "\u274C";
+  parts.push(`${emoji} ${opts.title}`);
+  parts.push("");
+  parts.push(`\u2022 Total: ${opts.totalItems}`);
+  parts.push(`\u2022 Successful: ${opts.successful}`);
+  if (opts.failed > 0) {
+    parts.push(`\u2022 Failed: ${opts.failed}`);
+  }
+  if (opts.tokensPerItem) {
+    parts.push(`\u2022 Tokens/item: ~${opts.tokensPerItem.toLocaleString()}`);
+  }
+  if (opts.batches) {
+    parts.push(`\u2022 Batches: ${opts.batches}`);
+  }
+  if (opts.extras) {
+    Object.entries(opts.extras).forEach(([key, val]) => {
+      parts.push(`\u2022 ${key}: ${val}`);
+    });
+  }
+  return parts.join("\n");
+}
+function formatDuration(ms) {
+  if (ms < SECONDS_MS) return `${ms}ms`;
+  if (ms < MINUTES_MS) return `${(ms / SECONDS_MS).toFixed(1)}s`;
+  return `${(ms / MINUTES_MS).toFixed(1)}m`;
+}
+
+// src/tools/mcp-helpers.ts
+import { error, markdown } from "mcp-use/server";
+var NOOP_REPORTER = {
+  async log() {
+  },
+  async progress() {
+  }
+};
+function toolSuccess(content, structuredContent) {
+  return {
+    isError: false,
+    content,
+    structuredContent
+  };
+}
+function toolFailure(content) {
+  return {
+    isError: true,
+    content
+  };
+}
+function createToolReporter(ctx, loggerName) {
+  return {
+    log(level, message) {
+      return ctx.log(level, message, loggerName);
+    },
+    progress(loaded, total, message) {
+      return ctx.reportProgress?.(loaded, total, message) ?? Promise.resolve();
+    }
+  };
+}
+function toToolResponse(result) {
+  if (result.isError) {
+    return error(result.content);
+  }
+  if (result.structuredContent) {
+    return {
+      ...markdown(result.content),
+      structuredContent: result.structuredContent
+    };
+  }
+  return markdown(result.content);
+}
+
+// src/tools/scrape.ts
+var markdownCleaner = new MarkdownCleaner();
 function formatInputValidationError(toolName, issues) {
   const details = issues.map((issue) => {
     const path = issue.path.length > 0 ? issue.path.map(String).join(".") : "<root>";
@@ -71,23 +2601,23 @@ function cleanFetchedContent(rawContent, url) {
     return rawContent;
   }
 }
-function effectErrorMessage(error) {
-  if (typeof error === "object" && error !== null) {
-    if ("error" in error) {
-      const structured = error.error;
+function effectErrorMessage(error2) {
+  if (typeof error2 === "object" && error2 !== null) {
+    if ("error" in error2) {
+      const structured = error2.error;
       if (typeof structured?.message === "string") return structured.message;
     }
-    if ("message" in error && typeof error.message === "string") {
-      return error.message;
+    if ("message" in error2 && typeof error2.message === "string") {
+      return error2.message;
     }
-    if ("_tag" in error && typeof error._tag === "string") {
-      return error._tag;
+    if ("_tag" in error2 && typeof error2._tag === "string") {
+      return error2._tag;
     }
   }
-  return String(error);
+  return String(error2);
 }
-const REDDIT_HOST = /(?:^|\.)reddit\.com$/i;
-const REDDIT_POST_PERMALINK = /\/r\/[^/]+\/comments\/[a-z0-9]+/i;
+var REDDIT_HOST = /(?:^|\.)reddit\.com$/i;
+var REDDIT_POST_PERMALINK = /\/r\/[^/]+\/comments\/[a-z0-9]+/i;
 function isRedditUrl(url) {
   try {
     const u = new URL(url);
@@ -185,12 +2715,12 @@ async function fetchJinaFirstBranch(inputs, kernelEnabled, scrapeDoProxyUrl) {
     "scrape"
   );
   const directResults = await runExternalEffect(
-    Effect.gen(function* () {
+    Effect3.gen(function* () {
       const jina = yield* JinaService;
-      return yield* Effect.forEach(
+      return yield* Effect3.forEach(
         inputs,
         (input) => jina.convert({ url: input.url, timeoutSeconds: 15, allowProxyRetry: false }).pipe(
-          Effect.timeoutFail({
+          Effect3.timeoutFail({
             duration: "20 seconds",
             onTimeout: () => new ProviderTimeoutError({
               provider: "jina",
@@ -198,7 +2728,7 @@ async function fetchJinaFirstBranch(inputs, kernelEnabled, scrapeDoProxyUrl) {
               durationMs: 2e4
             })
           }),
-          Effect.either
+          Effect3.either
         ),
         { concurrency: CONCURRENCY.JINA_READER }
       );
@@ -261,9 +2791,9 @@ async function fetchJinaFirstBranch(inputs, kernelEnabled, scrapeDoProxyUrl) {
         "scrape"
       );
       const proxyResults = await runExternalEffect(
-        Effect.gen(function* () {
+        Effect3.gen(function* () {
           const jina = yield* JinaService;
-          return yield* Effect.forEach(
+          return yield* Effect3.forEach(
             proxyInputs,
             (input) => jina.convert({
               url: input.url,
@@ -272,7 +2802,7 @@ async function fetchJinaFirstBranch(inputs, kernelEnabled, scrapeDoProxyUrl) {
               noCache: true,
               allowProxyRetry: false
             }).pipe(
-              Effect.timeoutFail({
+              Effect3.timeoutFail({
                 duration: "20 seconds",
                 onTimeout: () => new ProviderTimeoutError({
                   provider: "jina",
@@ -280,7 +2810,7 @@ async function fetchJinaFirstBranch(inputs, kernelEnabled, scrapeDoProxyUrl) {
                   durationMs: 2e4
                 })
               }),
-              Effect.either
+              Effect3.either
             ),
             { concurrency: CONCURRENCY.JINA_READER }
           );
@@ -337,12 +2867,12 @@ async function fetchKernelBranch(inputs) {
     "scrape"
   );
   const results = await runExternalEffect(
-    Effect.gen(function* () {
+    Effect3.gen(function* () {
       const kernel = yield* KernelService;
-      return yield* Effect.forEach(
+      return yield* Effect3.forEach(
         inputs,
         (input) => kernel.render({ url: input.url, timeoutSeconds: 15 }).pipe(
-          Effect.timeoutFail({
+          Effect3.timeoutFail({
             duration: "25 seconds",
             onTimeout: () => new ProviderTimeoutError({
               provider: "kernel",
@@ -350,7 +2880,7 @@ async function fetchKernelBranch(inputs) {
               durationMs: 25e3
             })
           }),
-          Effect.either
+          Effect3.either
         ),
         { concurrency: CONCURRENCY.KERNEL }
       );
@@ -488,10 +3018,10 @@ async function fetchRedditBranch(inputs) {
   mcpLog("info", `[concurrency] reddit branch: fetching ${postInputs.length} post(s) with limit=${CONCURRENCY.REDDIT}`, "scrape");
   const urls = postInputs.map((i) => i.url);
   const batchResult = await runExternalEffect(
-    Effect.gen(function* () {
+    Effect3.gen(function* () {
       const reddit = yield* RedditService;
       return yield* reddit.batchGetPosts(urls, true).pipe(
-        Effect.timeoutFail({
+        Effect3.timeoutFail({
           duration: "60 seconds",
           onTimeout: () => new ProviderTimeoutError({
             provider: "reddit",
@@ -523,8 +3053,8 @@ async function fetchRedditBranch(inputs) {
   }
   return { successItems, failedContents, metrics: { successful, failed, totalCredits: 0 } };
 }
-const TERSE_LLM_FAILURE_RE = /^\s*##\s*Matches\s*\n+\s*_Page did not load:\s*([a-z0-9_-]+)_\s*\.?\s*$/i;
-const RAW_FALLBACK_CHAR_CAP = 4e3;
+var TERSE_LLM_FAILURE_RE = /^\s*##\s*Matches\s*\n+\s*_Page did not load:\s*([a-z0-9_-]+)_\s*\.?\s*$/i;
+var RAW_FALLBACK_CHAR_CAP = 4e3;
 function detectTerseFailure(llmOutput) {
   const m = llmOutput.trim().match(TERSE_LLM_FAILURE_RE);
   return m ? m[1] : null;
@@ -558,15 +3088,15 @@ async function processItemsWithLlm(successItems, enhancedInstruction, llmProcess
   }
   mcpLog("info", `[concurrency] llm extraction: fanning out ${successItems.length} item(s) with limit=${CONCURRENCY.LLM_EXTRACTION}`, "scrape");
   const llmResults = await runExternalEffect(
-    Effect.gen(function* () {
+    Effect3.gen(function* () {
       const llm = yield* LlmService;
-      return yield* Effect.forEach(
+      return yield* Effect3.forEach(
         successItems,
         (item) => llm.extractContent(
           item.content,
           { enabled: true, extract: enhancedInstruction, url: item.url }
         ).pipe(
-          Effect.timeoutFail({
+          Effect3.timeoutFail({
             duration: "155 seconds",
             onTimeout: () => new ProviderTimeoutError({
               provider: "llm",
@@ -574,8 +3104,8 @@ async function processItemsWithLlm(successItems, enhancedInstruction, llmProcess
               durationMs: 155e3
             })
           }),
-          Effect.either,
-          Effect.map((result) => ({ item, result }))
+          Effect3.either,
+          Effect3.map((result) => ({ item, result }))
         ),
         { concurrency: CONCURRENCY.LLM_EXTRACTION }
       );
@@ -707,8 +3237,8 @@ async function handleScrapeLinksMode(params, reporter = NOOP_REPORTER) {
     const env = parseEnv();
     kernelEnabled = getCapabilities().kernel;
     scrapeDoProxyUrl = env.SCRAPER_API_KEY ? buildScrapeDoProxyUrl(env.SCRAPER_API_KEY) : void 0;
-  } catch (error) {
-    const err = classifyError(error);
+  } catch (error2) {
+    const err = classifyError(error2);
     return createScrapeErrorResponse(
       "CLIENT_INIT_FAILED",
       `Failed to initialize scrape providers: ${err.message}`,