@phneakngar/cli 0.0.2 → 0.0.3

package/dist/bin-mcp.js

@@ -0,0 +1,2991 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// ../web-brain/src/mcp-server.ts
+import { writeSync } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { join as join5 } from "node:path";
+
+// ../web-brain/src/fetch.ts
+import { createHash } from "node:crypto";
+import { lookup } from "node:dns/promises";
+
+// ../web-brain/src/ssrf.ts
+import { isIP } from "node:net";
+var BLOCKED_HOSTNAMES = new Set([
+  "localhost",
+  "localhost.localdomain",
+  "metadata.google.internal",
+  "metadata",
+  "0.0.0.0"
+]);
+function fail(code, message) {
+  return { ok: false, code, message };
+}
+function isBlockedIPv4(ip) {
+  const parts = ip.split(".").map((p) => Number(p));
+  if (parts.length !== 4 || parts.some((n) => !Number.isInteger(n) || n < 0 || n > 255)) {
+    return true;
+  }
+  const [a, b] = parts;
+  if (a === 0)
+    return true;
+  if (a === 10)
+    return true;
+  if (a === 127)
+    return true;
+  if (a === 169 && b === 254)
+    return true;
+  if (a === 172 && b >= 16 && b <= 31)
+    return true;
+  if (a === 192 && b === 168)
+    return true;
+  if (a === 100 && b >= 64 && b <= 127)
+    return true;
+  if (a === 192 && b === 0 && parts[2] === 0)
+    return true;
+  if (a === 192 && b === 0 && parts[2] === 2)
+    return true;
+  if (a === 198 && (b === 18 || b === 19))
+    return true;
+  if (a === 198 && b === 51 && parts[2] === 100)
+    return true;
+  if (a === 203 && b === 0 && parts[2] === 113)
+    return true;
+  if (a >= 224)
+    return true;
+  return false;
+}
+function isBlockedIPv6(ip) {
+  const normalized = ip.toLowerCase().replace(/^\[|\]$/g, "");
+  if (normalized === "::" || normalized === "::1")
+    return true;
+  if (normalized.startsWith("fe80:"))
+    return true;
+  if (normalized.startsWith("fc") || normalized.startsWith("fd"))
+    return true;
+  if (normalized.startsWith("ff"))
+    return true;
+  const mapped = normalized.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/i);
+  if (mapped)
+    return isBlockedIPv4(mapped[1]);
+  return false;
+}
+function isBlockedIpAddress(ip) {
+  const v = isIP(ip);
+  if (v === 4)
+    return isBlockedIPv4(ip);
+  if (v === 6)
+    return isBlockedIPv6(ip);
+  return true;
+}
+function assertSafeHttpUrl(raw, opts = {}) {
+  if (typeof raw !== "string" || !raw.trim()) {
+    return fail("invalid_url", "URL is required");
+  }
+  let url;
+  try {
+    url = new URL(raw.trim());
+  } catch {
+    return fail("invalid_url", `Invalid URL: ${raw}`);
+  }
+  const scheme = url.protocol.replace(/:$/, "").toLowerCase();
+  if (scheme !== "http" && scheme !== "https") {
+    return fail("blocked_scheme", `Blocked URL scheme: ${scheme}`);
+  }
+  if (url.username || url.password) {
+    return fail("invalid_url", "URLs with embedded credentials are not allowed");
+  }
+  const host = url.hostname.toLowerCase().replace(/^\[|\]$/g, "");
+  if (!host) {
+    return fail("invalid_url", "URL host is required");
+  }
+  if (!opts.allowPrivateNetwork) {
+    if (BLOCKED_HOSTNAMES.has(host) || host.endsWith(".localhost") || host.endsWith(".local")) {
+      return fail("blocked_host", `Blocked host: ${host}`);
+    }
+    const ipVersion = isIP(host);
+    if (ipVersion === 4 || ipVersion === 6) {
+      if (isBlockedIpAddress(host)) {
+        return fail("blocked_ip", `Blocked IP address: ${host}`);
+      }
+    } else if (/^\d+$/.test(host)) {
+      try {
+        const n = Number(host) >>> 0;
+        const dotted = [n >>> 24 & 255, n >>> 16 & 255, n >>> 8 & 255, n & 255].join(".");
+        if (isBlockedIPv4(dotted)) {
+          return fail("blocked_ip", `Blocked IP address: ${host}`);
+        }
+      } catch {
+        return fail("invalid_url", `Invalid host: ${host}`);
+      }
+    }
+  }
+  return { ok: true, url };
+}
+function assertResolvedAddressesSafe(addresses, opts = {}) {
+  if (opts.allowPrivateNetwork)
+    return { ok: true };
+  if (!addresses.length) {
+    return fail("dns_failed", "DNS returned no addresses");
+  }
+  for (const addr of addresses) {
+    if (isBlockedIpAddress(addr)) {
+      return fail("blocked_ip", `Resolved to blocked address: ${addr}`);
+    }
+  }
+  return { ok: true };
+}
+function toWebError(code, message) {
+  return { ok: false, error: { code, message } };
+}
+
+// ../web-brain/src/extract.ts
+function decodeEntities(s) {
+  return s.replace(/&nbsp;/gi, " ").replace(/&amp;/gi, "&").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/&quot;/gi, '"').replace(/&#39;/gi, "'").replace(/&#x([0-9a-f]+);/gi, (_, h) => String.fromCodePoint(parseInt(h, 16))).replace(/&#(\d+);/g, (_, d) => String.fromCodePoint(Number(d)));
+}
+function stripTags(html) {
+  return decodeEntities(html.replace(/<[^>]+>/g, " "));
+}
+function collapseWs(s) {
+  return s.replace(/[ \t]+\n/g, `
+`).replace(/\n{3,}/g, `
+
+`).replace(/[ \t]{2,}/g, " ").trim();
+}
+function extractTitle(html) {
+  const t = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+  if (t?.[1]) {
+    const title = collapseWs(stripTags(t[1]));
+    if (title)
+      return title.slice(0, 500);
+  }
+  const h1 = html.match(/<h1[^>]*>([\s\S]*?)<\/h1>/i);
+  if (h1?.[1]) {
+    const title = collapseWs(stripTags(h1[1]));
+    if (title)
+      return title.slice(0, 500);
+  }
+  const og = html.match(/<meta[^>]+property=["']og:title["'][^>]+content=["']([^"']+)["']/i) || html.match(/<meta[^>]+content=["']([^"']+)["'][^>]+property=["']og:title["']/i);
+  if (og?.[1])
+    return collapseWs(decodeEntities(og[1])).slice(0, 500);
+  return "";
+}
+function stripBoilerplate(html) {
+  let s = html;
+  s = s.replace(/<script\b[\s\S]*?<\/script>/gi, "");
+  s = s.replace(/<style\b[\s\S]*?<\/style>/gi, "");
+  s = s.replace(/<noscript\b[\s\S]*?<\/noscript>/gi, "");
+  s = s.replace(/<!--[\s\S]*?-->/g, "");
+  s = s.replace(/<svg\b[\s\S]*?<\/svg>/gi, "");
+  s = s.replace(/<(header|footer|nav|aside|form)\b[\s\S]*?<\/\1>/gi, "");
+  return s;
+}
+function bodyHtml(html) {
+  const m = html.match(/<body[^>]*>([\s\S]*)<\/body>/i);
+  return m?.[1] ?? html;
+}
+function mainContentHtml(html) {
+  const article = html.match(/<article\b[^>]*>([\s\S]*?)<\/article>/i);
+  if (article?.[1] && article[1].length > 80)
+    return article[1];
+  const main = html.match(/<main\b[^>]*>([\s\S]*?)<\/main>/i);
+  if (main?.[1] && main[1].length > 80)
+    return main[1];
+  return bodyHtml(html);
+}
+function htmlToMarkdown(html, maxChars = 30000) {
+  let s = stripBoilerplate(mainContentHtml(html));
+  s = s.replace(/<h([1-6])[^>]*>([\s\S]*?)<\/h\1>/gi, (_, level, inner) => {
+    const text = collapseWs(stripTags(inner));
+    if (!text)
+      return `
+`;
+    return `
+
+${"#".repeat(Number(level))} ${text}
+
+`;
+  });
+  s = s.replace(/<a\b[^>]*href=["']([^"']+)["'][^>]*>([\s\S]*?)<\/a>/gi, (_, href, inner) => {
+    const text = collapseWs(stripTags(inner)) || href;
+    return `[${text}](${href})`;
+  });
+  s = s.replace(/<img\b[^>]*alt=["']([^"']*)["'][^>]*>/gi, (_, alt) => alt ? ` ${alt} ` : " ");
+  s = s.replace(/<img\b[^>]*>/gi, " ");
+  s = s.replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, (_, inner) => {
+    const text = collapseWs(stripTags(inner));
+    return text ? `
+- ${text}` : "";
+  });
+  s = s.replace(/<\/p>/gi, `
+
+`);
+  s = s.replace(/<br\s*\/?>/gi, `
+`);
+  s = s.replace(/<\/div>/gi, `
+`);
+  s = s.replace(/<\/tr>/gi, `
+`);
+  s = s.replace(/<\/(ul|ol|table|section|blockquote)>/gi, `
+
+`);
+  s = s.replace(/<pre[^>]*>([\s\S]*?)<\/pre>/gi, (_, inner) => {
+    const text = decodeEntities(inner.replace(/<[^>]+>/g, ""));
+    return `
+
+\`\`\`
+${text.trim()}
+\`\`\`
+
+`;
+  });
+  s = s.replace(/<code[^>]*>([\s\S]*?)<\/code>/gi, (_, inner) => {
+    const text = collapseWs(stripTags(inner));
+    return text ? `\`${text}\`` : "";
+  });
+  s = stripTags(s);
+  s = collapseWs(s);
+  if (s.length > maxChars) {
+    let cut = s.slice(0, maxChars);
+    const lastBreak = Math.max(cut.lastIndexOf(`
+
+`), cut.lastIndexOf(`
+`));
+    if (lastBreak > maxChars * 0.6)
+      cut = cut.slice(0, lastBreak);
+    s = `${cut.trimEnd()}
+
+[... content truncated]`;
+  }
+  return s;
+}
+function extractFromHtml(html, maxChars = 30000) {
+  const title = extractTitle(html);
+  const markdown = htmlToMarkdown(html, maxChars);
+  return { title, markdown, textLength: markdown.length };
+}
+
+// ../web-brain/src/auth.ts
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+function defaultAuthPaths() {
+  const home = homedir();
+  return [
+    process.env.PHNEAKNGAR_AUTH_STATE || "",
+    process.env.PHNEAKNGAR_AUTH_COOKIES || "",
+    join(home, ".phneakngar", "auth", "storageState.json"),
+    join(home, ".phneakngar", "auth", "cookies.txt")
+  ].filter(Boolean);
+}
+function cookiesFromNetscape(text, host) {
+  const parts = [];
+  for (const line of text.split(/\r?\n/)) {
+    if (!line || line.startsWith("#"))
+      continue;
+    const cols = line.split("\t");
+    if (cols.length < 7)
+      continue;
+    const domain = cols[0].replace(/^\./, "");
+    const name = cols[5];
+    const value = cols[6];
+    if (host && !host.endsWith(domain) && domain !== host)
+      continue;
+    parts.push(`${name}=${value}`);
+  }
+  return parts.length ? parts.join("; ") : null;
+}
+function cookiesFromStorageState(json, host) {
+  if (!json || typeof json !== "object")
+    return null;
+  const cookies = json.cookies;
+  if (!Array.isArray(cookies))
+    return null;
+  const parts = [];
+  for (const c of cookies) {
+    if (!c || typeof c !== "object")
+      continue;
+    const rec = c;
+    if (!rec.name || rec.value == null)
+      continue;
+    if (host && rec.domain) {
+      const d = rec.domain.replace(/^\./, "");
+      if (!host.endsWith(d) && d !== host)
+        continue;
+    }
+    parts.push(`${rec.name}=${rec.value}`);
+  }
+  return parts.length ? parts.join("; ") : null;
+}
+function resolveAuth(opts = {}) {
+  if (!opts.useAuth && !opts.cookieHeader && !opts.authStatePath) {
+    if (process.env.PHNEAKNGAR_USE_AUTH !== "1")
+      return null;
+  }
+  if (opts.useAuth === false)
+    return null;
+  if (opts.cookieHeader) {
+    return { cookieHeader: opts.cookieHeader, source: "explicit" };
+  }
+  const envCookie = process.env.PHNEAKNGAR_AUTH_COOKIE_HEADER;
+  if (envCookie) {
+    return { cookieHeader: envCookie, source: "env:PHNEAKNGAR_AUTH_COOKIE_HEADER" };
+  }
+  const paths = opts.authStatePath ? [opts.authStatePath] : defaultAuthPaths();
+  for (const p of paths) {
+    if (!p || !existsSync(p))
+      continue;
+    try {
+      const raw = readFileSync(p, "utf-8");
+      if (p.endsWith(".json") || raw.trimStart().startsWith("{")) {
+        const cookie = cookiesFromStorageState(JSON.parse(raw), opts.host);
+        if (cookie)
+          return { cookieHeader: cookie, source: p };
+      } else {
+        const cookie = cookiesFromNetscape(raw, opts.host);
+        if (cookie)
+          return { cookieHeader: cookie, source: p };
+      }
+    } catch {}
+  }
+  return null;
+}
+function applyAuthHeaders(base, auth) {
+  const h = { ...base ?? {} };
+  if (auth?.cookieHeader)
+    h.Cookie = auth.cookieHeader;
+  if (auth?.headers)
+    Object.assign(h, auth.headers);
+  return h;
+}
+
+// ../web-brain/src/fetch.ts
+var DEFAULT_MAX_CHARS = 30000;
+var DEFAULT_TIMEOUT_MS = 15000;
+var MAX_BYTES = 2000000;
+var MAX_REDIRECTS = 5;
+var TEXT_TYPES = [
+  "text/html",
+  "application/xhtml",
+  "text/plain",
+  "text/markdown",
+  "application/json"
+];
+function contentTypeOk(ct) {
+  if (!ct)
+    return true;
+  const base = ct.split(";")[0]?.trim().toLowerCase() ?? "";
+  return TEXT_TYPES.some((t) => base.includes(t)) || base.startsWith("text/");
+}
+function hashContent(s) {
+  return createHash("sha256").update(s).digest("hex");
+}
+async function resolveAndCheckHost(hostname, allowPrivateNetwork) {
+  const { isIP: isIP2 } = await import("node:net");
+  if (isIP2(hostname.replace(/^\[|\]$/g, "")))
+    return null;
+  try {
+    const results = await lookup(hostname, { all: true });
+    const addrs = results.map((r) => r.address);
+    const check = assertResolvedAddressesSafe(addrs, { allowPrivateNetwork });
+    if (!check.ok) {
+      return toWebError(check.code, check.message);
+    }
+    return null;
+  } catch (err) {
+    return toWebError("dns_failed", `DNS lookup failed for ${hostname}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+async function webFetch(rawUrl, opts = {}) {
+  const maxChars = opts.maxChars ?? DEFAULT_MAX_CHARS;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const allowPrivate = opts.allowPrivateNetwork ?? false;
+  const safe = assertSafeHttpUrl(rawUrl, { allowPrivateNetwork: allowPrivate });
+  if (!safe.ok) {
+    return toWebError(safe.code, safe.message);
+  }
+  const canonical = safe.url.toString();
+  if (!opts.forceRefresh && opts.cache) {
+    const hit = opts.cache.get(canonical);
+    if (hit) {
+      return {
+        ok: true,
+        url: hit.url,
+        finalUrl: hit.finalUrl,
+        title: hit.title,
+        markdown: hit.markdown,
+        contentType: hit.contentType,
+        httpStatus: hit.httpStatus,
+        fromCache: true,
+        fetchedAt: hit.fetchedAt,
+        contentHash: hit.contentHash
+      };
+    }
+  }
+  let current = safe.url;
+  let redirects = 0;
+  let res;
+  const skipDns = opts.fetchImpl != null && opts.fetchImpl !== fetch;
+  while (redirects <= MAX_REDIRECTS) {
+    if (!skipDns) {
+      const dnsErr = await resolveAndCheckHost(current.hostname, allowPrivate);
+      if (dnsErr)
+        return dnsErr;
+    }
+    const hopSafe = assertSafeHttpUrl(current.toString(), {
+      allowPrivateNetwork: allowPrivate
+    });
+    if (!hopSafe.ok) {
+      return toWebError(hopSafe.code, hopSafe.message);
+    }
+    const auth = resolveAuth({
+      useAuth: opts.useAuth,
+      authStatePath: opts.authStatePath,
+      host: current.hostname
+    });
+    const headers = applyAuthHeaders({
+      Accept: "text/html,application/xhtml+xml,text/plain;q=0.9,*/*;q=0.1",
+      "User-Agent": "phneakngar-web-brain/0.0.2 (+https://github.com/silence-guy/phneakngar)",
+      ...opts.headers
+    }, auth);
+    try {
+      res = await fetchImpl(current.toString(), {
+        method: "GET",
+        redirect: "manual",
+        signal: AbortSignal.timeout(timeoutMs),
+        headers
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (/timeout|aborted/i.test(msg)) {
+        return toWebError("timeout", `Request timed out after ${timeoutMs}ms`);
+      }
+      return toWebError("network_error", msg);
+    }
+    if (res.status >= 300 && res.status < 400) {
+      const loc = res.headers.get("location");
+      if (!loc) {
+        return toWebError("http_error", `Redirect ${res.status} without Location`);
+      }
+      let next;
+      try {
+        next = new URL(loc, current);
+      } catch {
+        return toWebError("invalid_url", `Invalid redirect location: ${loc}`);
+      }
+      const nextSafe = assertSafeHttpUrl(next.toString(), {
+        allowPrivateNetwork: allowPrivate
+      });
+      if (!nextSafe.ok) {
+        return toWebError(nextSafe.code, `Redirect blocked: ${nextSafe.message}`);
+      }
+      current = nextSafe.url;
+      redirects += 1;
+      continue;
+    }
+    break;
+  }
+  if (!res) {
+    return toWebError("network_error", "No response");
+  }
+  if (res.status === 403 || res.status === 401) {
+    return toWebError("http_error", `HTTP ${res.status} from ${current.toString()} (blocked or unauthorized)`);
+  }
+  if (!res.ok) {
+    return toWebError("http_error", `HTTP ${res.status} from ${current.toString()}`);
+  }
+  const ct = res.headers.get("content-type");
+  if (!contentTypeOk(ct)) {
+    return toWebError("unsupported_content", `Unsupported content-type: ${ct ?? "unknown"}`);
+  }
+  const buf = Buffer.from(await res.arrayBuffer());
+  if (buf.byteLength > MAX_BYTES) {
+    return toWebError("too_large", `Response exceeds ${MAX_BYTES} bytes`);
+  }
+  const text = buf.toString("utf-8");
+  if (!text.trim()) {
+    return toWebError("empty_content", "Empty response body");
+  }
+  const lowerCt = (ct ?? "").toLowerCase();
+  let title = "";
+  let markdown = "";
+  if (lowerCt.includes("json") || text.trimStart().startsWith("{") || text.trimStart().startsWith("[")) {
+    title = current.hostname;
+    markdown = "```json\n" + text.slice(0, maxChars) + (text.length > maxChars ? `
+/* truncated */` : "") + "\n```";
+    if (text.length > maxChars) {
+      markdown += `
+
+[... content truncated]`;
+    }
+  } else if (lowerCt.includes("html") || /<html[\s>]/i.test(text) || /<body[\s>]/i.test(text)) {
+    const extracted = extractFromHtml(text, maxChars);
+    title = extracted.title || current.hostname;
+    markdown = extracted.markdown;
+  } else {
+    title = current.hostname;
+    markdown = text.length > maxChars ? text.slice(0, maxChars) + `
+
+[... content truncated]` : text;
+  }
+  if (!markdown.trim()) {
+    return toWebError("empty_content", "No extractable text content");
+  }
+  const fetchedAt = new Date().toISOString();
+  const contentHash = hashContent(markdown);
+  const entry = {
+    url: canonical,
+    finalUrl: current.toString(),
+    title,
+    markdown,
+    contentType: ct ?? "text/html",
+    httpStatus: res.status,
+    fetchedAt,
+    contentHash
+  };
+  if (opts.cache) {
+    opts.cache.put(entry);
+  }
+  return {
+    ok: true,
+    url: canonical,
+    finalUrl: entry.finalUrl,
+    title,
+    markdown,
+    contentType: entry.contentType,
+    httpStatus: entry.httpStatus,
+    fromCache: false,
+    fetchedAt,
+    contentHash
+  };
+}
+
+// ../web-brain/src/search.ts
+var UA = "phneakngar-web-brain/0.0.2 (+https://github.com/silence-guy/phneakngar)";
+function ddgTimeParam(timeRange) {
+  if (!timeRange)
+    return;
+  switch (timeRange) {
+    case "day":
+      return "d";
+    case "week":
+      return "w";
+    case "month":
+      return "m";
+    case "year":
+      return "y";
+    default:
+      return;
+  }
+}
+function decodeHtmlEntities(s) {
+  return s.replace(/&#x([0-9a-f]+);/gi, (_, h) => String.fromCodePoint(Number.parseInt(h, 16))).replace(/&#(\d+);/g, (_, d) => String.fromCodePoint(Number(d))).replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&#39;/g, "'").replace(/&nbsp;/g, " ");
+}
+function stripTags2(s) {
+  return decodeHtmlEntities(s.replace(/<[^>]+>/g, "")).replace(/\s+/g, " ").trim();
+}
+function resolveDdgResultHref(href) {
+  let raw = href.trim();
+  if (!raw)
+    return null;
+  raw = decodeHtmlEntities(raw);
+  if (raw.startsWith("//"))
+    raw = `https:${raw}`;
+  try {
+    const u = new URL(raw);
+    const uddg = u.searchParams.get("uddg");
+    if (uddg) {
+      const dest = decodeURIComponent(uddg);
+      if (/^https?:\/\//i.test(dest))
+        return dest;
+    }
+    if (u.hostname.includes("duckduckgo.com"))
+      return null;
+    if (u.protocol === "http:" || u.protocol === "https:")
+      return u.toString();
+  } catch {}
+  const m = raw.match(/[?&]uddg=([^&]+)/i);
+  if (m?.[1]) {
+    try {
+      const dest = decodeURIComponent(m[1]);
+      if (/^https?:\/\//i.test(dest))
+        return dest;
+    } catch {}
+  }
+  if (/^https?:\/\//i.test(raw) && !raw.includes("duckduckgo.com"))
+    return raw;
+  return null;
+}
+function detectBlockedHint(html) {
+  const lower = html.toLowerCase();
+  if (lower.includes("anomaly-modal") || lower.includes("anomaly")) {
+    return "anomaly";
+  }
+  if (lower.includes("captcha") || lower.includes("challenge-form")) {
+    return "captcha";
+  }
+  if (lower.includes("unfortunately, bots use duckduckgo too")) {
+    return "bot_block";
+  }
+  return;
+}
+function parseDdgLiteHtml(html, maxResults) {
+  const results = [];
+  const seen = new Set;
+  const push = (url, titleRaw, snippet = "") => {
+    if (!url || seen.has(url) || results.length >= maxResults)
+      return;
+    if (url.includes("duckduckgo.com"))
+      return;
+    const title = stripTags2(titleRaw);
+    if (!title)
+      return;
+    seen.add(url);
+    results.push({ title, url, snippet: stripTags2(snippet) });
+  };
+  const anchorRe = /<a\b([^>]*)>([\s\S]*?)<\/a>/gi;
+  let m;
+  while ((m = anchorRe.exec(html)) !== null && results.length < maxResults) {
+    const attrs = m[1] ?? "";
+    const inner = m[2] ?? "";
+    const hrefM = attrs.match(/\bhref\s*=\s*["']([^"']+)["']/i);
+    if (!hrefM?.[1])
+      continue;
+    const href = hrefM[1];
+    const isResultClass = /class\s*=\s*["'][^"']*result(?:__a|-link)/i.test(attrs) || /rel\s*=\s*["'][^"']*nofollow/i.test(attrs) || /uddg=/i.test(href);
+    if (!isResultClass)
+      continue;
+    push(resolveDdgResultHref(href), inner);
+  }
+  if (results.length === 0) {
+    const uddgRe = /[?&]uddg=([^&"'>\s]+)/gi;
+    let um;
+    while ((um = uddgRe.exec(html)) !== null && results.length < maxResults) {
+      try {
+        const dest = decodeURIComponent(um[1]);
+        if (/^https?:\/\//i.test(dest) && !dest.includes("duckduckgo.com")) {
+          push(dest, dest);
+        }
+      } catch {}
+    }
+  }
+  const snippetRe = /class=["'][^"']*result(?:__|-)?snippet[^"']*["'][^>]*>([\s\S]*?)<\//gi;
+  const snippets = [];
+  let sm;
+  while ((sm = snippetRe.exec(html)) !== null) {
+    snippets.push(stripTags2(sm[1] ?? ""));
+  }
+  for (let i = 0;i < results.length; i++) {
+    if (snippets[i])
+      results[i].snippet = snippets[i];
+  }
+  return results;
+}
+async function runHtmlProvider(name, url, maxResults, fetchImpl) {
+  const t0 = Date.now();
+  try {
+    const res = await fetchImpl(url.toString(), {
+      method: "GET",
+      signal: AbortSignal.timeout(12000),
+      headers: {
+        Accept: "text/html,application/xhtml+xml",
+        "User-Agent": UA,
+        "Accept-Language": "en-US,en;q=0.9"
+      },
+      redirect: "follow"
+    });
+    const html = await res.text();
+    const blockedHint = detectBlockedHint(html);
+    const results = res.ok ? parseDdgLiteHtml(html, maxResults) : [];
+    return {
+      results,
+      telemetry: {
+        provider: name,
+        ok: res.ok,
+        httpStatus: res.status,
+        latencyMs: Date.now() - t0,
+        rawHtmlBytes: html.length,
+        parseCount: results.length,
+        blockedHint,
+        error: res.ok ? undefined : `Search HTTP ${res.status}`
+      }
+    };
+  } catch (err) {
+    return {
+      results: [],
+      telemetry: {
+        provider: name,
+        ok: false,
+        latencyMs: Date.now() - t0,
+        parseCount: 0,
+        error: err instanceof Error ? err.message : String(err)
+      }
+    };
+  }
+}
+function applyDdgParams(u, query, timeRange) {
+  u.searchParams.set("q", query);
+  const df = ddgTimeParam(timeRange);
+  if (df)
+    u.searchParams.set("df", df);
+}
+var ddgLiteProvider = {
+  name: "ddg-lite",
+  async search(query, { maxResults, fetchImpl, timeRange }) {
+    const u = new URL("https://lite.duckduckgo.com/lite/");
+    applyDdgParams(u, query, timeRange);
+    const run = await runHtmlProvider("ddg-lite", u, maxResults, fetchImpl);
+    if (run.telemetry.error && run.results.length === 0) {
+      throw new Error(run.telemetry.error);
+    }
+    return run.results;
+  }
+};
+var ddgHtmlProvider = {
+  name: "ddg-html",
+  async search(query, { maxResults, fetchImpl, timeRange }) {
+    const u = new URL("https://html.duckduckgo.com/html/");
+    applyDdgParams(u, query, timeRange);
+    const run = await runHtmlProvider("ddg-html", u, maxResults, fetchImpl);
+    if (run.telemetry.error && run.results.length === 0) {
+      throw new Error(run.telemetry.error);
+    }
+    return run.results;
+  }
+};
+async function runProvider(provider, query, ctx) {
+  if (provider.name === "ddg-lite") {
+    const u = new URL("https://lite.duckduckgo.com/lite/");
+    applyDdgParams(u, query, ctx.timeRange);
+    return runHtmlProvider("ddg-lite", u, ctx.maxResults, ctx.fetchImpl);
+  }
+  if (provider.name === "ddg-html") {
+    const u = new URL("https://html.duckduckgo.com/html/");
+    applyDdgParams(u, query, ctx.timeRange);
+    return runHtmlProvider("ddg-html", u, ctx.maxResults, ctx.fetchImpl);
+  }
+  const t0 = Date.now();
+  try {
+    const results = await provider.search(query, ctx);
+    return {
+      results,
+      telemetry: {
+        provider: provider.name,
+        ok: true,
+        latencyMs: Date.now() - t0,
+        parseCount: results.length
+      }
+    };
+  } catch (err) {
+    return {
+      results: [],
+      telemetry: {
+        provider: provider.name,
+        ok: false,
+        latencyMs: Date.now() - t0,
+        parseCount: 0,
+        error: err instanceof Error ? err.message : String(err)
+      }
+    };
+  }
+}
+async function webSearch(query, opts = {}) {
+  const q = query?.trim() ?? "";
+  if (!q) {
+    return toWebError("invalid_url", "Search query is required");
+  }
+  const maxResults = Math.min(Math.max(opts.maxResults ?? 5, 1), 20);
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const timeRange = opts.timeRange;
+  const ctx = { maxResults, fetchImpl, timeRange };
+  if (opts.provider) {
+    const run = await runProvider(opts.provider, q, ctx);
+    if (run.results.length > 0) {
+      return {
+        ok: true,
+        query: q,
+        results: run.results.slice(0, maxResults),
+        provider: opts.provider.name,
+        providersTried: [opts.provider.name],
+        telemetry: [run.telemetry],
+        timeRange
+      };
+    }
+    return {
+      ok: true,
+      query: q,
+      results: [],
+      provider: opts.provider.name,
+      degraded: true,
+      error: {
+        code: "empty_provider_results",
+        message: run.telemetry.error ? `Provider ${opts.provider.name} failed: ${run.telemetry.error}` : `Provider ${opts.provider.name} returned 0 results (parse/engine empty)`
+      },
+      providersTried: [opts.provider.name],
+      telemetry: [run.telemetry],
+      timeRange
+    };
+  }
+  const chain = opts.noFallback ? [{ name: "ddg-lite", search: ddgLiteProvider.search }] : [
+    { name: "ddg-lite", search: ddgLiteProvider.search },
+    { name: "ddg-html", search: ddgHtmlProvider.search }
+  ];
+  const telemetry = [];
+  const tried = [];
+  let lastProvider = chain[0].name;
+  for (const provider of chain) {
+    tried.push(provider.name);
+    lastProvider = provider.name;
+    const run = await runProvider(provider, q, ctx);
+    telemetry.push(run.telemetry);
+    if (run.results.length > 0) {
+      return {
+        ok: true,
+        query: q,
+        results: run.results.slice(0, maxResults),
+        provider: provider.name,
+        degraded: provider.name !== chain[0].name,
+        providersTried: tried,
+        telemetry,
+        timeRange
+      };
+    }
+  }
+  const blocked = telemetry.map((t) => t.blockedHint).find(Boolean);
+  const lastErr = [...telemetry].reverse().find((t) => t.error)?.error;
+  return {
+    ok: true,
+    query: q,
+    results: [],
+    provider: lastProvider,
+    degraded: true,
+    error: {
+      code: "empty_provider_results",
+      message: blocked ? `All search providers returned 0 results (blocked: ${blocked})` : lastErr ? `All search providers returned 0 results (${lastErr})` : "All search providers returned 0 results — engine empty, parse miss, or soft-block"
+    },
+    providersTried: tried,
+    telemetry,
+    timeRange
+  };
+}
+function createMockSearchProvider(results, name = "mock") {
+  return {
+    name,
+    async search(_query, { maxResults }) {
+      return results.slice(0, maxResults);
+    }
+  };
+}
+
+// ../web-brain/src/cache.ts
+import {
+  existsSync as existsSync2,
+  mkdirSync,
+  readFileSync as readFileSync2,
+  writeFileSync,
+  readdirSync,
+  unlinkSync,
+  rmSync
+} from "node:fs";
+import { join as join2 } from "node:path";
+import { createHash as createHash2 } from "node:crypto";
+function hashUrl(url) {
+  return createHash2("sha256").update(url).digest("hex").slice(0, 32);
+}
+function tokenize(q) {
+  return q.toLowerCase().split(/[^a-z0-9\u1780-\u17ff]+/i).map((t) => t.trim()).filter((t) => t.length >= 2);
+}
+
+class WebCache {
+  dir;
+  pagesDir;
+  constructor(opts) {
+    this.dir = opts.dir;
+    this.pagesDir = join2(this.dir, "pages");
+    mkdirSync(this.pagesDir, { recursive: true, mode: 448 });
+  }
+  pathFor(url) {
+    return join2(this.pagesDir, `${hashUrl(url)}.json`);
+  }
+  get(url) {
+    const p = this.pathFor(url);
+    if (!existsSync2(p))
+      return null;
+    try {
+      const raw = readFileSync2(p, "utf-8");
+      const entry = JSON.parse(raw);
+      if (!entry?.url || typeof entry.markdown !== "string")
+        return null;
+      return entry;
+    } catch {
+      return null;
+    }
+  }
+  put(entry) {
+    const p = this.pathFor(entry.url);
+    writeFileSync(p, JSON.stringify(entry), { mode: 384 });
+    if (entry.finalUrl && entry.finalUrl !== entry.url) {
+      const p2 = this.pathFor(entry.finalUrl);
+      writeFileSync(p2, JSON.stringify(entry), { mode: 384 });
+    }
+  }
+  search(query, limit = 20) {
+    const tokens = tokenize(query);
+    if (!tokens.length)
+      return [];
+    const out = [];
+    let names;
+    try {
+      names = readdirSync(this.pagesDir).filter((n) => n.endsWith(".json"));
+    } catch {
+      return [];
+    }
+    const seen = new Set;
+    for (const name of names) {
+      try {
+        const entry = JSON.parse(readFileSync2(join2(this.pagesDir, name), "utf-8"));
+        if (!entry?.url || seen.has(entry.url))
+          continue;
+        seen.add(entry.url);
+        const hay = `${entry.title}
+${entry.markdown}`.toLowerCase();
+        let score = 0;
+        for (const t of tokens) {
+          if (hay.includes(t))
+            score += 1;
+        }
+        if (score > 0)
+          out.push({ entry, score });
+      } catch {}
+    }
+    out.sort((a, b) => b.score - a.score);
+    return out.slice(0, limit).map((x) => x.entry);
+  }
+  stats() {
+    let entries = 0;
+    try {
+      const names = readdirSync(this.pagesDir).filter((n) => n.endsWith(".json"));
+      entries = names.length;
+    } catch {
+      entries = 0;
+    }
+    return { entries, path: this.dir };
+  }
+  clear() {
+    try {
+      rmSync(this.pagesDir, { recursive: true, force: true });
+    } catch {}
+    mkdirSync(this.pagesDir, { recursive: true, mode: 448 });
+  }
+  delete(url) {
+    const p = this.pathFor(url);
+    if (existsSync2(p))
+      unlinkSync(p);
+  }
+}
+function defaultCacheDir(configRoot) {
+  return join2(configRoot, "web-cache");
+}
+
+// ../web-brain/src/structured-extract.ts
+import { lookup as lookup2 } from "node:dns/promises";
+import { isIP as isIP2 } from "node:net";
+function decodeEntities2(s) {
+  return s.replace(/&nbsp;/gi, " ").replace(/&amp;/gi, "&").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/&quot;/gi, '"').replace(/&#39;/gi, "'").replace(/&#x([0-9a-f]+);/gi, (_, h) => String.fromCodePoint(parseInt(h, 16))).replace(/&#(\d+);/g, (_, d) => String.fromCodePoint(Number(d)));
+}
+function cellText(html) {
+  return decodeEntities2(html.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim());
+}
+function metaContent(html, nameOrProp) {
+  const re = new RegExp(`<meta[^>]+(?:name|property)=["']${nameOrProp.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["'][^>]+content=["']([^"']*)["']`, "i");
+  const re2 = new RegExp(`<meta[^>]+content=["']([^"']*)["'][^>]+(?:name|property)=["']${nameOrProp.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["']`, "i");
+  const m = html.match(re) || html.match(re2);
+  return m?.[1] ? decodeEntities2(m[1]) : "";
+}
+function extractMetadata(html) {
+  const og = {};
+  const ogRe = /<meta[^>]+property=["'](og:[^"']+)["'][^>]+content=["']([^"']*)["']/gi;
+  let m;
+  while ((m = ogRe.exec(html)) !== null) {
+    og[m[1]] = decodeEntities2(m[2]);
+  }
+  const ogRe2 = /<meta[^>]+content=["']([^"']*)["'][^>]+property=["'](og:[^"']+)["']/gi;
+  while ((m = ogRe2.exec(html)) !== null) {
+    og[m[2]] = decodeEntities2(m[1]);
+  }
+  const canonical = html.match(/<link[^>]+rel=["']canonical["'][^>]+href=["']([^"']+)["']/i)?.[1] || html.match(/<link[^>]+href=["']([^"']+)["'][^>]+rel=["']canonical["']/i)?.[1] || "";
+  const lang = html.match(/<html[^>]+lang=["']([^"']+)["']/i)?.[1] || "";
+  return {
+    title: extractTitle(html),
+    description: metaContent(html, "description") || og["og:description"] || "",
+    canonical: decodeEntities2(canonical),
+    og,
+    lang
+  };
+}
+function extractTables(html, maxTables = 20, maxRows = 200) {
+  const cleaned = stripBoilerplate(html);
+  const tables = [];
+  const tableRe = /<table\b[^>]*>([\s\S]*?)<\/table>/gi;
+  let tm;
+  while ((tm = tableRe.exec(cleaned)) !== null && tables.length < maxTables) {
+    const body = tm[1];
+    const rowsHtml = [...body.matchAll(/<tr\b[^>]*>([\s\S]*?)<\/tr>/gi)].map((x) => x[1]);
+    if (!rowsHtml.length)
+      continue;
+    let headers = [];
+    const dataRows = [];
+    for (let i = 0;i < rowsHtml.length && dataRows.length < maxRows; i++) {
+      const cells = [
+        ...rowsHtml[i].matchAll(/<t[hd]\b[^>]*>([\s\S]*?)<\/t[hd]>/gi)
+      ].map((c) => cellText(c[1]));
+      if (!cells.length)
+        continue;
+      if (i === 0 && /<th\b/i.test(rowsHtml[i])) {
+        headers = cells;
+      } else {
+        dataRows.push(cells);
+      }
+    }
+    if (headers.length || dataRows.length) {
+      tables.push({ headers, rows: dataRows });
+    }
+  }
+  return tables;
+}
+function extractJsonLd(html) {
+  const out = [];
+  const re = /<script\b[^>]*type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
+  let m;
+  while ((m = re.exec(html)) !== null) {
+    const raw = m[1].trim();
+    if (!raw)
+      continue;
+    try {
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed))
+        out.push(...parsed);
+      else
+        out.push(parsed);
+    } catch {}
+  }
+  return out;
+}
+async function fetchHtml(rawUrl, opts = {}) {
+  const allowPrivate = opts.allowPrivateNetwork ?? false;
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const timeoutMs = opts.timeoutMs ?? 15000;
+  const skipDns = opts.fetchImpl != null && opts.fetchImpl !== fetch;
+  const safe = assertSafeHttpUrl(rawUrl, { allowPrivateNetwork: allowPrivate });
+  if (!safe.ok)
+    return toWebError(safe.code, safe.message);
+  let current = safe.url;
+  for (let redirects = 0;redirects <= 5; redirects++) {
+    if (!skipDns) {
+      const host = current.hostname.replace(/^\[|\]$/g, "");
+      if (!isIP2(host)) {
+        try {
+          const results = await lookup2(host, { all: true });
+          const check = assertResolvedAddressesSafe(results.map((r) => r.address), { allowPrivateNetwork: allowPrivate });
+          if (!check.ok)
+            return toWebError(check.code, check.message);
+        } catch (err) {
+          return toWebError("dns_failed", err instanceof Error ? err.message : String(err));
+        }
+      }
+    }
+    const auth = resolveAuth({
+      useAuth: opts.useAuth,
+      authStatePath: opts.authStatePath,
+      host: current.hostname
+    });
+    const headers = applyAuthHeaders({
+      Accept: "text/html,application/xhtml+xml;q=0.9,*/*;q=0.1",
+      "User-Agent": "phneakngar-web-brain/0.0.2",
+      ...opts.headers
+    }, auth);
+    let res;
+    try {
+      res = await fetchImpl(current.toString(), {
+        method: "GET",
+        redirect: "manual",
+        signal: AbortSignal.timeout(timeoutMs),
+        headers
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (/timeout|aborted/i.test(msg))
+        return toWebError("timeout", msg);
+      return toWebError("network_error", msg);
+    }
+    if (res.status >= 300 && res.status < 400) {
+      const loc = res.headers.get("location");
+      if (!loc)
+        return toWebError("http_error", `Redirect ${res.status} without Location`);
+      let next;
+      try {
+        next = new URL(loc, current);
+      } catch {
+        return toWebError("invalid_url", `Invalid redirect: ${loc}`);
+      }
+      const hop = assertSafeHttpUrl(next.toString(), {
+        allowPrivateNetwork: allowPrivate
+      });
+      if (!hop.ok)
+        return toWebError(hop.code, hop.message);
+      current = hop.url;
+      continue;
+    }
+    if (!res.ok)
+      return toWebError("http_error", `HTTP ${res.status}`);
+    const buf = Buffer.from(await res.arrayBuffer());
+    if (buf.byteLength > 2000000) {
+      return toWebError("too_large", "HTML exceeds 2MB");
+    }
+    const html = buf.toString("utf-8");
+    if (!html.trim())
+      return toWebError("empty_content", "Empty HTML body");
+    return { ok: true, html, finalUrl: current.toString() };
+  }
+  return toWebError("http_error", "Too many redirects");
+}
+async function structuredExtract(opts) {
+  const mode = opts.mode ?? "all";
+  let html = opts.html;
+  let url = opts.url ?? null;
+  if (!html) {
+    if (!opts.url) {
+      return toWebError("invalid_url", "url or html is required");
+    }
+    const fetched = await fetchHtml(opts.url, opts.fetchOpts);
+    if (!fetched.ok)
+      return fetched;
+    html = fetched.html;
+    url = fetched.finalUrl;
+  }
+  const result = {
+    ok: true,
+    url,
+    mode
+  };
+  if (mode === "metadata" || mode === "all") {
+    result.metadata = extractMetadata(html);
+  }
+  if (mode === "tables" || mode === "all") {
+    result.tables = extractTables(html);
+  }
+  if (mode === "jsonld" || mode === "all") {
+    result.jsonld = extractJsonLd(html);
+  }
+  return result;
+}
+
+// ../web-brain/src/crawl.ts
+import { createHash as createHash5 } from "node:crypto";
+
+// ../web-brain/src/robots.ts
+var DEFAULT_UA = "phneakngar-web-brain";
+function parseRobotsTxt(text, userAgent = DEFAULT_UA) {
+  const lines = text.split(/\r?\n/).map((l) => l.replace(/#.*$/, "").trim());
+  const groups = [];
+  let current = null;
+  const flush = () => {
+    if (current && current.agents.length)
+      groups.push(current);
+    current = null;
+  };
+  for (const line of lines) {
+    if (!line)
+      continue;
+    const idx = line.indexOf(":");
+    if (idx < 0)
+      continue;
+    const key = line.slice(0, idx).trim().toLowerCase();
+    const value = line.slice(idx + 1).trim();
+    if (key === "user-agent") {
+      if (!current || current.disallows.length || current.allows.length) {
+        flush();
+        current = { agents: [value.toLowerCase()], disallows: [], allows: [], delay: null };
+      } else {
+        current.agents.push(value.toLowerCase());
+      }
+    } else if (current) {
+      if (key === "disallow")
+        current.disallows.push(value);
+      else if (key === "allow")
+        current.allows.push(value);
+      else if (key === "crawl-delay") {
+        const n = Number(value);
+        if (Number.isFinite(n) && n >= 0)
+          current.delay = Math.round(n * 1000);
+      }
+    }
+  }
+  flush();
+  const ua = userAgent.toLowerCase();
+  const match = groups.find((g) => g.agents.some((a) => a !== "*" && (ua === a || ua.startsWith(a)))) || groups.find((g) => g.agents.includes("*")) || null;
+  if (!match) {
+    return { disallows: [], allows: [], crawlDelayMs: null };
+  }
+  return {
+    disallows: match.disallows.filter((p) => p.length > 0),
+    allows: match.allows.filter((p) => p.length > 0),
+    crawlDelayMs: match.delay
+  };
+}
+function isPathAllowed(pathname, rules) {
+  const path = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  let bestAllow = -1;
+  for (const a of rules.allows) {
+    if (path.startsWith(a) && a.length > bestAllow)
+      bestAllow = a.length;
+  }
+  let bestDisallow = -1;
+  for (const d of rules.disallows) {
+    if (d === "")
+      continue;
+    if (path.startsWith(d) && d.length > bestDisallow)
+      bestDisallow = d.length;
+  }
+  if (bestDisallow < 0)
+    return true;
+  if (bestAllow > bestDisallow)
+    return true;
+  return false;
+}
+function isUrlAllowedByRobots(url, rules) {
+  try {
+    const u = new URL(url);
+    return isPathAllowed(u.pathname || "/", rules);
+  } catch {
+    return false;
+  }
+}
+
+// ../web-brain/src/sitemap.ts
+function extractSitemapUrlFromRobots(robotsTxt) {
+  const urls = [];
+  for (const line of robotsTxt.split(/\r?\n/)) {
+    const m = line.match(/^sitemap:\s*(.+)/i);
+    if (m?.[1])
+      urls.push(m[1].trim());
+  }
+  return urls;
+}
+function parseSitemapIndex(xml) {
+  if (!xml.includes("<sitemapindex"))
+    return [];
+  const urls = [];
+  for (const m of xml.matchAll(/<loc>\s*([^<]+?)\s*<\/loc>/gi)) {
+    const u = m[1]?.trim();
+    if (u)
+      urls.push(u);
+  }
+  return urls;
+}
+function parseSitemapEntries(xml) {
+  if (xml.includes("<sitemapindex"))
+    return [];
+  if (!xml.includes("<urlset") && !xml.includes("<loc>"))
+    return [];
+  const entries = [];
+  for (const block of xml.matchAll(/<url\b[^>]*>([\s\S]*?)<\/url>/gi)) {
+    const body = block[1] ?? "";
+    const loc = body.match(/<loc>\s*([^<]+?)\s*<\/loc>/i)?.[1]?.trim();
+    if (!loc)
+      continue;
+    const entry = { url: loc };
+    const lastmod = body.match(/<lastmod>\s*([^<]+?)\s*<\/lastmod>/i)?.[1]?.trim();
+    if (lastmod)
+      entry.lastmod = lastmod;
+    const pr = body.match(/<priority>\s*([^<]+?)\s*<\/priority>/i)?.[1]?.trim();
+    if (pr != null) {
+      const p = Number.parseFloat(pr);
+      if (Number.isFinite(p))
+        entry.priority = p;
+    }
+    entries.push(entry);
+  }
+  return entries;
+}
+function sortSitemapEntries(entries) {
+  return entries.map((entry, index) => ({ entry, index })).sort((a, b) => {
+    const aLm = a.entry.lastmod ? Date.parse(a.entry.lastmod) : NaN;
+    const bLm = b.entry.lastmod ? Date.parse(b.entry.lastmod) : NaN;
+    const aOk = Number.isFinite(aLm);
+    const bOk = Number.isFinite(bLm);
+    if (aOk !== bOk)
+      return aOk ? -1 : 1;
+    if (aOk && bOk && aLm !== bLm)
+      return bLm - aLm;
+    const ap = a.entry.priority;
+    const bp = b.entry.priority;
+    const aHas = typeof ap === "number";
+    const bHas = typeof bp === "number";
+    if (aHas !== bHas)
+      return aHas ? -1 : 1;
+    if (aHas && bHas && ap !== bp)
+      return bp - ap;
+    return a.index - b.index;
+  }).map((x) => x.entry);
+}
+var MAX_INDEX_CHILDREN = 5;
+async function discoverSitemapUrls(origin, lightFetch, robotsTxt) {
+  const locations = [];
+  if (robotsTxt)
+    locations.push(...extractSitemapUrlFromRobots(robotsTxt));
+  if (locations.length === 0) {
+    locations.push(`${origin}/sitemap.xml`, `${origin}/sitemap_index.xml`);
+  }
+  const all = [];
+  const seenLoc = new Set;
+  async function loadSitemap(url, depth = 0) {
+    if (seenLoc.has(url) || depth > 2)
+      return;
+    seenLoc.add(url);
+    const res = await lightFetch(url);
+    if (!res.ok || res.status >= 400 || !res.body)
+      return;
+    const xml = res.body;
+    if (xml.includes("<sitemapindex")) {
+      for (const child of parseSitemapIndex(xml).slice(0, MAX_INDEX_CHILDREN)) {
+        await loadSitemap(child, depth + 1);
+      }
+      return;
+    }
+    all.push(...parseSitemapEntries(xml));
+  }
+  for (const loc of locations) {
+    await loadSitemap(loc);
+  }
+  return sortSitemapEntries(all).map((e) => e.url);
+}
+
+// ../web-brain/src/url-utils.ts
+function stripFragment(url) {
+  try {
+    const u = new URL(url);
+    u.hash = "";
+    return u.toString();
+  } catch {
+    return url;
+  }
+}
+function canonicalForCrawl(url) {
+  try {
+    const u = new URL(url);
+    u.hash = "";
+    let pathname = u.pathname;
+    if (pathname.length > 1 && pathname.endsWith("/")) {
+      pathname = pathname.slice(0, -1);
+    }
+    u.pathname = pathname;
+    return u.toString();
+  } catch {
+    return url;
+  }
+}
+function canonicalForOutput(url) {
+  try {
+    const u = new URL(url);
+    let path = u.pathname;
+    if (path === "/")
+      path = "";
+    else if (path.length > 1 && path.endsWith("/"))
+      path = path.slice(0, -1);
+    return `${u.origin}${path}${u.search}`;
+  } catch {
+    return url;
+  }
+}
+function matchesPatterns(url, includePatterns, excludePatterns) {
+  if (includePatterns && includePatterns.length > 0) {
+    const ok = includePatterns.some((p) => {
+      try {
+        return new RegExp(p).test(url);
+      } catch {
+        return false;
+      }
+    });
+    if (!ok)
+      return false;
+  }
+  if (excludePatterns && excludePatterns.length > 0) {
+    const blocked = excludePatterns.some((p) => {
+      try {
+        return new RegExp(p).test(url);
+      } catch {
+        return false;
+      }
+    });
+    if (blocked)
+      return false;
+  }
+  return true;
+}
+var DOC_PATH_HINTS = ["/docs/", "/guide/", "/api/", "/reference/", "/learn/"];
+function isDocPathUrl(url) {
+  try {
+    const path = new URL(url).pathname.toLowerCase();
+    return DOC_PATH_HINTS.some((p) => path.includes(p));
+  } catch {
+    return false;
+  }
+}
+function prioritizeDocLinks(urls) {
+  return [...urls].sort((a, b) => {
+    const aDoc = isDocPathUrl(a) ? 0 : 1;
+    const bDoc = isDocPathUrl(b) ? 0 : 1;
+    return aDoc - bDoc;
+  });
+}
+
+// ../web-brain/src/dedup.ts
+import {
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync3,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import { join as join3 } from "node:path";
+import { createHash as createHash3 } from "node:crypto";
+import { homedir as homedir2 } from "node:os";
+function splitIntoBlocks(markdown) {
+  if (!markdown.trim())
+    return [];
+  const lines = markdown.split(`
+`);
+  const headingIndices = [];
+  for (let i = 0;i < lines.length; i++) {
+    if (/^#{1,6}\s+/.test(lines[i])) {
+      headingIndices.push({ lineIdx: i });
+    }
+  }
+  if (headingIndices.length === 0) {
+    return markdown.split(/\n\n+/).map((b) => b.trim()).filter(Boolean);
+  }
+  const blocks = [];
+  for (let i = 0;i < headingIndices.length; i++) {
+    const start = headingIndices[i].lineIdx;
+    const end = i + 1 < headingIndices.length ? headingIndices[i + 1].lineIdx : lines.length;
+    blocks.push(lines.slice(start, end).join(`
+`).trim());
+  }
+  return blocks.filter(Boolean);
+}
+function normalizeBlockText(text) {
+  return text.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function hashBlock(text) {
+  return createHash3("sha256").update(normalizeBlockText(text)).digest("hex");
+}
+function lineHash(line) {
+  return createHash3("sha1").update(line.trim().toLowerCase()).digest("hex");
+}
+var NAV_DEDUPE_THRESHOLD = 0.6;
+var MAX_LEADING_LINES = 30;
+var MAX_TRAILING_LINES = 20;
+var MIN_CORPUS = 4;
+function stripRepeatedNavigationLines(pages) {
+  if (pages.length < MIN_CORPUS)
+    return pages;
+  const lineSets = pages.map((p) => p.markdown.split(`
+`));
+  const countLeading = new Map;
+  const countTrailing = new Map;
+  for (const lines of lineSets) {
+    const seenL = new Set;
+    for (let i = 0;i < Math.min(MAX_LEADING_LINES, lines.length); i++) {
+      const h = lineHash(lines[i]);
+      if (!seenL.has(h)) {
+        seenL.add(h);
+        countLeading.set(h, (countLeading.get(h) ?? 0) + 1);
+      }
+    }
+    const seenT = new Set;
+    for (let i = lines.length - 1;i >= Math.max(lines.length - MAX_TRAILING_LINES, 0); i--) {
+      const h = lineHash(lines[i]);
+      if (!seenT.has(h)) {
+        seenT.add(h);
+        countTrailing.set(h, (countTrailing.get(h) ?? 0) + 1);
+      }
+    }
+  }
+  const threshold = pages.length * NAV_DEDUPE_THRESHOLD;
+  const navLeading = new Set([...countLeading].filter(([, c]) => c >= threshold).map(([h]) => h));
+  const navTrailing = new Set([...countTrailing].filter(([, c]) => c >= threshold).map(([h]) => h));
+  return pages.map((page, i) => {
+    const lines = lineSets[i];
+    let head = 0;
+    while (head < lines.length && (lines[head].trim() === "" || navLeading.has(lineHash(lines[head])))) {
+      head++;
+    }
+    let tail = lines.length;
+    while (tail > head && (lines[tail - 1].trim() === "" || navTrailing.has(lineHash(lines[tail - 1])))) {
+      tail--;
+    }
+    return { url: page.url, markdown: lines.slice(head, tail).join(`
+`) };
+  });
+}
+function defaultBoilerplatePath() {
+  return join3(process.env.PHNEAKNGAR_WEB_CACHE_DIR || join3(homedir2(), ".phneakngar", "web-cache"), "boilerplate");
+}
+function getStoredBoilerplate(domain, storeDir = defaultBoilerplatePath()) {
+  const p = join3(storeDir, `${domain.replace(/[^a-z0-9.-]/gi, "_")}.json`);
+  if (!existsSync3(p))
+    return [];
+  try {
+    const raw = JSON.parse(readFileSync3(p, "utf-8"));
+    return Array.isArray(raw.hashes) ? raw.hashes : [];
+  } catch {
+    return [];
+  }
+}
+function storeBoilerplate(domain, hashes, storeDir = defaultBoilerplatePath()) {
+  mkdirSync2(storeDir, { recursive: true, mode: 448 });
+  const p = join3(storeDir, `${domain.replace(/[^a-z0-9.-]/gi, "_")}.json`);
+  writeFileSync2(p, JSON.stringify({ domain, hashes, updatedAt: new Date().toISOString() }), { mode: 384 });
+}
+function deduplicatePages(pages, domain, storeDir) {
+  if (pages.length <= 1) {
+    return pages.map((p) => ({ url: p.url, markdown: p.markdown }));
+  }
+  const stripped = stripRepeatedNavigationLines(pages);
+  const dir = storeDir ?? defaultBoilerplatePath();
+  const boilerplateHashes = new Set(domain ? getStoredBoilerplate(domain, dir) : []);
+  const pageBlocks = stripped.map((page) => ({
+    url: page.url,
+    blocks: splitIntoBlocks(page.markdown)
+  }));
+  const hashPageCount = new Map;
+  for (const page of pageBlocks) {
+    const seenHashes = new Set;
+    for (const block of page.blocks) {
+      const h = hashBlock(block);
+      if (!seenHashes.has(h)) {
+        seenHashes.add(h);
+        hashPageCount.set(h, (hashPageCount.get(h) ?? 0) + 1);
+      }
+    }
+  }
+  const threshold = pages.length / 2;
+  for (const [hash, count] of hashPageCount) {
+    if (count > threshold)
+      boilerplateHashes.add(hash);
+  }
+  if (domain) {
+    storeBoilerplate(domain, [...boilerplateHashes], dir);
+  }
+  return pageBlocks.map((page) => {
+    const filtered = page.blocks.filter((block) => !boilerplateHashes.has(hashBlock(block)));
+    return {
+      url: page.url,
+      markdown: filtered.join(`
+
+`)
+    };
+  });
+}
+
+// ../web-brain/src/embed.ts
+import {
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync4,
+  writeFileSync as writeFileSync3,
+  readdirSync as readdirSync2,
+  unlinkSync as unlinkSync2
+} from "node:fs";
+import { join as join4 } from "node:path";
+import { createHash as createHash4 } from "node:crypto";
+import { homedir as homedir3 } from "node:os";
+var EMBED_DIM = 384;
+var SUMMARY_CHARS = 500;
+var MIN_TEXT_LEN = 20;
+function isIndexingEnabled() {
+  return process.env.PHNEAKNGAR_CRAWL_INDEX === "1" || process.env.PHNEAKNGAR_CRAWL_INDEX === "true";
+}
+function tokenize2(text) {
+  return text.toLowerCase().split(/[^a-z0-9\u1780-\u17ff]+/i).filter((t) => t.length >= 2);
+}
+function hashEmbed(text, dim = EMBED_DIM) {
+  const vec = new Float32Array(dim);
+  const tokens = tokenize2(text);
+  if (!tokens.length)
+    return vec;
+  const tf = new Map;
+  for (const t of tokens)
+    tf.set(t, (tf.get(t) ?? 0) + 1);
+  for (const [tok, count] of tf) {
+    const h = createHash4("sha256").update(tok).digest();
+    const idx = h.readUInt32BE(0) % dim;
+    const sign = h[4] & 1 ? 1 : -1;
+    vec[idx] += sign * (1 + Math.log(count));
+  }
+  let norm = 0;
+  for (let i = 0;i < dim; i++)
+    norm += vec[i] * vec[i];
+  norm = Math.sqrt(norm) || 1;
+  for (let i = 0;i < dim; i++)
+    vec[i] /= norm;
+  return vec;
+}
+function cosineSimilarity(a, b) {
+  const n = Math.min(a.length, b.length);
+  let dot = 0;
+  for (let i = 0;i < n; i++)
+    dot += a[i] * b[i];
+  return dot;
+}
+
+class VectorStore {
+  dir;
+  constructor(dir) {
+    this.dir = dir ?? join4(process.env.PHNEAKNGAR_WEB_CACHE_DIR || join4(homedir3(), ".phneakngar", "web-cache"), "vectors");
+    mkdirSync3(this.dir, { recursive: true, mode: 448 });
+  }
+  pathFor(url) {
+    const id = createHash4("sha256").update(url).digest("hex").slice(0, 32);
+    return join4(this.dir, `${id}.json`);
+  }
+  upsert(rec) {
+    writeFileSync3(this.pathFor(rec.url), JSON.stringify(rec), { mode: 384 });
+  }
+  get(url) {
+    const p = this.pathFor(url);
+    if (!existsSync4(p))
+      return null;
+    try {
+      return JSON.parse(readFileSync4(p, "utf-8"));
+    } catch {
+      return null;
+    }
+  }
+  list() {
+    const out = [];
+    for (const name of readdirSync2(this.dir).filter((n) => n.endsWith(".json"))) {
+      try {
+        out.push(JSON.parse(readFileSync4(join4(this.dir, name), "utf-8")));
+      } catch {}
+    }
+    return out;
+  }
+  clear() {
+    for (const name of readdirSync2(this.dir).filter((n) => n.endsWith(".json"))) {
+      unlinkSync2(join4(this.dir, name));
+    }
+  }
+  size() {
+    try {
+      return readdirSync2(this.dir).filter((n) => n.endsWith(".json")).length;
+    } catch {
+      return 0;
+    }
+  }
+}
+async function indexCrawlResult(item, store) {
+  if (!isIndexingEnabled())
+    return false;
+  try {
+    const summary = (item.markdown ?? "").slice(0, SUMMARY_CHARS);
+    const text = `${item.title ?? ""}
+${summary}`.trim();
+    if (text.length < MIN_TEXT_LEN)
+      return false;
+    const vector = hashEmbed(text);
+    const contentHash = createHash4("sha256").update(item.markdown ?? "").digest("hex");
+    const vs = store ?? new VectorStore;
+    vs.upsert({
+      url: item.url,
+      contentHash,
+      modelId: "hash-embed-v1",
+      dims: EMBED_DIM,
+      vector: Array.from(vector),
+      textPreview: text.slice(0, 200),
+      updatedAt: new Date().toISOString()
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function findSimilar(queryOrUrl, opts = {}) {
+  const store = opts.store ?? new VectorStore;
+  const limit = opts.limit ?? 5;
+  const minScore = opts.minScore ?? 0.05;
+  let queryVec;
+  const existing = store.get(queryOrUrl);
+  if (existing) {
+    queryVec = Float32Array.from(existing.vector);
+  } else {
+    queryVec = hashEmbed(queryOrUrl);
+  }
+  const hits = [];
+  for (const rec of store.list()) {
+    if (rec.url === queryOrUrl)
+      continue;
+    const score = cosineSimilarity(queryVec, Float32Array.from(rec.vector));
+    if (score >= minScore) {
+      hits.push({ url: rec.url, score, textPreview: rec.textPreview });
+    }
+  }
+  hits.sort((a, b) => b.score - a.score);
+  return hits.slice(0, limit);
+}
+
+// ../web-brain/src/budget.ts
+var DEFAULT_MAX_TOTAL_CHARS = 1e5;
+var DEFAULT_MAX_TOKENS_OUT = 4000;
+var PER_PAGE_TOKENS = 2000;
+var MAX_TOKENS_OUT_CEILING = 60000;
+var MIN_TOKENS_PER_PAGE = 256;
+var TRUNC_MARKER = `
+
+[... content truncated]`;
+function countTokens(text) {
+  if (!text)
+    return 0;
+  return Math.ceil(text.length / 4);
+}
+function truncateByTokens(text, maxTokens) {
+  if (maxTokens <= 0)
+    return TRUNC_MARKER.trim();
+  if (!text)
+    return "";
+  if (countTokens(text) <= maxTokens)
+    return text;
+  const maxChars = Math.max(0, maxTokens * 4 - 40);
+  const head = text.slice(0, maxChars);
+  const threshold = head.length * 0.7;
+  const lastSentence = Math.max(head.lastIndexOf(". "), head.lastIndexOf(`.
+`), head.lastIndexOf("? "), head.lastIndexOf("! "));
+  if (lastSentence > threshold) {
+    return head.slice(0, lastSentence + 1) + TRUNC_MARKER;
+  }
+  const lastPara = head.lastIndexOf(`
+
+`);
+  if (lastPara > threshold)
+    return head.slice(0, lastPara) + TRUNC_MARKER;
+  return head + TRUNC_MARKER;
+}
+function truncateByChars(text, maxChars) {
+  if (maxChars <= 0)
+    return "";
+  if (text.length <= maxChars)
+    return text;
+  return text.slice(0, Math.max(0, maxChars - 20)) + TRUNC_MARKER;
+}
+function applyAggregateMarkdownBudget(items, getBody, setBody, opts) {
+  let used = 0;
+  const minFloor = opts.minTokensPerItem ?? 0;
+  for (const item of items) {
+    const body = getBody(item);
+    if (!body)
+      continue;
+    const remaining = opts.maxTokensOut - used;
+    if (remaining <= 0) {
+      if (minFloor > 0) {
+        setBody(item, truncateByTokens(body, minFloor));
+        used += Math.min(minFloor, countTokens(body));
+      } else {
+        setBody(item, "");
+      }
+      continue;
+    }
+    const budget = Math.max(remaining, minFloor);
+    const next = truncateByTokens(body, budget);
+    setBody(item, next);
+    used += countTokens(next);
+  }
+}
+function buildEvidenceFromMarkdown(query, title, url, markdown, opts = {}) {
+  if (!markdown)
+    return [];
+  const maxItems = opts.maxItems ?? 1;
+  const budget = opts.maxTokensOut ?? 400;
+  const paras = markdown.split(/\n\n+/).map((p) => p.trim()).filter((p) => p.length >= 40);
+  const qTokens = query.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length >= 3);
+  const scored = paras.map((p) => {
+    const low = p.toLowerCase();
+    let score = 0.1;
+    for (const t of qTokens)
+      if (low.includes(t))
+        score += 1;
+    return { p, score };
+  });
+  scored.sort((a, b) => b.score - a.score);
+  const out = [];
+  let used = 0;
+  for (const s of scored.slice(0, maxItems * 2)) {
+    if (out.length >= maxItems)
+      break;
+    const remaining = budget - used;
+    if (remaining <= 0)
+      break;
+    const excerpt = truncateByTokens(s.p, remaining);
+    if (excerpt.length < 20)
+      continue;
+    out.push({ title, url, excerpt, score: s.score });
+    used += countTokens(excerpt);
+  }
+  if (!out.length && paras[0]) {
+    out.push({
+      title,
+      url,
+      excerpt: truncateByTokens(paras[0], budget),
+      score: 0.1
+    });
+  }
+  return out;
+}
+function scaleDefaultTokens(pageCount) {
+  return Math.min(MAX_TOKENS_OUT_CEILING, Math.max(DEFAULT_MAX_TOKENS_OUT, PER_PAGE_TOKENS * Math.max(1, pageCount)));
+}
+
+// ../web-brain/src/crawl.ts
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+function extractLinks(html, baseUrl) {
+  const out = [];
+  const re = /<a\b[^>]+href=["']([^"'#][^"']*)["']/gi;
+  let m;
+  while ((m = re.exec(html)) !== null) {
+    const href = m[1].trim();
+    if (!href || href.startsWith("mailto:") || href.startsWith("javascript:")) {
+      continue;
+    }
+    if (href.startsWith("tel:") || href.startsWith("data:"))
+      continue;
+    try {
+      const abs = new URL(href, baseUrl);
+      if (abs.protocol !== "http:" && abs.protocol !== "https:")
+        continue;
+      abs.hash = "";
+      out.push(abs.toString());
+    } catch {}
+  }
+  return [...new Set(out)];
+}
+async function loadRobots(origin, opts) {
+  const robotsUrl = `${origin}/robots.txt`;
+  const res = await fetchHtml(robotsUrl, { ...opts, forceRefresh: true });
+  if (!res.ok) {
+    return {
+      rules: { disallows: [], allows: [], crawlDelayMs: null },
+      raw: null
+    };
+  }
+  return { rules: parseRobotsTxt(res.html), raw: res.html };
+}
+function hashContent2(s) {
+  return createHash5("sha256").update(s).digest("hex");
+}
+async function fetchPage(url, opts) {
+  const cacheKey = url;
+  if (opts.cache && !opts.fetchOpts.forceRefresh) {
+    const hit = opts.cache.get(cacheKey);
+    if (hit) {
+      return {
+        ok: true,
+        url: hit.url,
+        finalUrl: hit.finalUrl,
+        title: hit.title,
+        markdown: hit.markdown,
+        html: "",
+        fromCache: true,
+        links: []
+      };
+    }
+  }
+  const htmlRes = await fetchHtml(url, opts.fetchOpts);
+  if (!htmlRes.ok) {
+    return { ok: false, reason: htmlRes.error.message };
+  }
+  const extracted = extractFromHtml(htmlRes.html, opts.maxChars);
+  const links = extractLinks(htmlRes.html, htmlRes.finalUrl);
+  const fetchedAt = new Date().toISOString();
+  const contentHash = hashContent2(extracted.markdown);
+  if (opts.cache) {
+    opts.cache.put({
+      url: cacheKey,
+      finalUrl: htmlRes.finalUrl,
+      title: extracted.title,
+      markdown: extracted.markdown,
+      contentType: "text/html",
+      httpStatus: 200,
+      fetchedAt,
+      contentHash
+    });
+  }
+  return {
+    ok: true,
+    url: cacheKey,
+    finalUrl: htmlRes.finalUrl,
+    title: extracted.title,
+    markdown: extracted.markdown,
+    html: htmlRes.html,
+    fromCache: false,
+    links
+  };
+}
+async function webCrawl(seedUrl, opts = {}) {
+  const strategy = opts.strategy ?? "bfs";
+  const maxDepth = Math.min(Math.max(opts.maxDepth ?? 2, 0), 3);
+  const maxPages = Math.min(Math.max(opts.maxPages ?? 20, 1), 50);
+  const sameHost = opts.sameHost !== false;
+  const respectRobots = opts.respectRobots !== false;
+  const minDelayMs = Math.max(opts.minDelayMs ?? 250, 0);
+  const allowPrivate = opts.fetchOpts?.allowPrivateNetwork ?? false;
+  const fetchImpl = opts.fetchImpl ?? opts.fetchOpts?.fetchImpl ?? fetch;
+  const maxChars = opts.maxChars ?? 30000;
+  const includePatterns = opts.includePatterns;
+  const excludePatterns = opts.excludePatterns;
+  const extractLinksGraph = opts.extractLinksGraph === true;
+  const useAuth = opts.useAuth === true || process.env.PHNEAKNGAR_USE_AUTH === "1";
+  const dedupeBoilerplate = opts.dedupeBoilerplate !== false;
+  const maxTotalChars = opts.maxTotalChars ?? DEFAULT_MAX_TOTAL_CHARS;
+  const includeFullMarkdown = opts.includeFullMarkdown !== false;
+  const doIndex = opts.indexPages === true || isIndexingEnabled();
+  const seedSafe = assertSafeHttpUrl(seedUrl, {
+    allowPrivateNetwork: allowPrivate
+  });
+  if (!seedSafe.ok)
+    return toWebError(seedSafe.code, seedSafe.message);
+  const seed = seedSafe.url;
+  const origin = seed.origin;
+  const host = seed.hostname.toLowerCase();
+  const fetchOpts = {
+    ...opts.fetchOpts,
+    fetchImpl,
+    cache: opts.cache ?? opts.fetchOpts?.cache,
+    allowPrivateNetwork: allowPrivate,
+    useAuth,
+    authStatePath: opts.authStatePath ?? opts.fetchOpts?.authStatePath
+  };
+  const cache = opts.cache ?? opts.fetchOpts?.cache ?? null;
+  let robots = { disallows: [], allows: [], crawlDelayMs: null };
+  let robotsRaw = null;
+  let robotsFetched = false;
+  if (respectRobots) {
+    const loaded = await loadRobots(origin, fetchOpts);
+    robots = loaded.rules;
+    robotsRaw = loaded.raw;
+    robotsFetched = true;
+  }
+  const delayMs = Math.max(minDelayMs, robots.crawlDelayMs ?? 0);
+  const lightFetch = async (url) => {
+    const r = await fetchHtml(url, { ...fetchOpts, forceRefresh: true });
+    if (!r.ok)
+      return { ok: false };
+    return { ok: true, body: r.html, status: 200 };
+  };
+  if (strategy === "map") {
+    return runMapStrategy({
+      seed: seed.toString(),
+      origin,
+      host,
+      sameHost,
+      maxDepth,
+      maxPages,
+      includePatterns,
+      excludePatterns,
+      respectRobots,
+      robots,
+      robotsRaw,
+      robotsFetched,
+      delayMs,
+      lightFetch,
+      fetchOpts,
+      allowPrivate
+    });
+  }
+  let strategyUsed = strategy;
+  let sitemapUrls = [];
+  let sitemapFound = false;
+  if (strategy === "sitemap" || strategy === "auto") {
+    sitemapUrls = await discoverSitemapUrls(origin, lightFetch, robotsRaw);
+    sitemapFound = sitemapUrls.length > 0;
+    if (sitemapFound) {
+      strategyUsed = "sitemap";
+    } else if (strategy === "sitemap") {
+      strategyUsed = "bfs";
+    } else {
+      strategyUsed = "bfs";
+    }
+  }
+  const pages = [];
+  const skipped = [];
+  const linkEdges = [];
+  const seenEdges = new Set;
+  let lastFetchAt = 0;
+  const seedCanon = canonicalForCrawl(seed.toString());
+  const allowUrl = (url, opts2) => {
+    const safe = assertSafeHttpUrl(url, { allowPrivateNetwork: allowPrivate });
+    if (!safe.ok)
+      return safe.message;
+    if (sameHost && safe.url.hostname.toLowerCase() !== host)
+      return "off-host";
+    const isSeed = opts2?.isSeed === true || canonicalForCrawl(url) === seedCanon;
+    if (!isSeed && !matchesPatterns(url, includePatterns, excludePatterns)) {
+      return "pattern-filter";
+    }
+    if (isSeed && excludePatterns?.length && !matchesPatterns(url, undefined, excludePatterns)) {
+      return "pattern-filter";
+    }
+    if (respectRobots && !isUrlAllowedByRobots(url, robots)) {
+      return "robots-disallow";
+    }
+    return null;
+  };
+  const pace = async () => {
+    const wait = delayMs - (Date.now() - lastFetchAt);
+    if (wait > 0)
+      await sleep(wait);
+  };
+  const recordEdge = (from, to) => {
+    if (!extractLinksGraph)
+      return;
+    const key = `${from}\x00${stripFragment(to)}`;
+    if (seenEdges.has(key))
+      return;
+    seenEdges.add(key);
+    linkEdges.push({ from, to: stripFragment(to) });
+  };
+  if (strategyUsed === "sitemap") {
+    const seenCanon = new Set;
+    const ordered = [];
+    for (const u of sitemapUrls) {
+      const c = canonicalForCrawl(u);
+      if (seenCanon.has(c))
+        continue;
+      seenCanon.add(c);
+      if (allowUrl(u))
+        continue;
+      ordered.push(u);
+    }
+    const totalFound = ordered.length;
+    for (const url of ordered.slice(0, maxPages)) {
+      await pace();
+      const page = await fetchPage(url, { fetchOpts, maxChars, cache });
+      lastFetchAt = Date.now();
+      if (!page.ok) {
+        skipped.push({ url, reason: page.reason });
+        continue;
+      }
+      pages.push({
+        url: canonicalForOutput(page.finalUrl),
+        finalUrl: page.finalUrl,
+        title: page.title,
+        markdown: page.markdown,
+        depth: 0,
+        fromCache: page.fromCache
+      });
+      if (extractLinksGraph) {
+        for (const l of page.links)
+          recordEdge(url, l);
+      }
+    }
+    return finalizeCrawl({
+      seed: seed.toString(),
+      strategyUsed,
+      pages,
+      totalFound,
+      skipped,
+      robotsFetched,
+      sitemapFound: true,
+      links: extractLinksGraph ? linkEdges : undefined,
+      dedupeBoilerplate,
+      maxTotalChars,
+      maxTokensOut: opts.maxTokensOut,
+      includeFullMarkdown,
+      doIndex,
+      useAuth
+    });
+  }
+  const traversal = strategyUsed === "dfs" ? "dfs" : "bfs";
+  const queue = [
+    { url: seed.toString(), depth: 0 }
+  ];
+  const visited = new Set([canonicalForCrawl(seed.toString())]);
+  while (queue.length && pages.length < maxPages) {
+    const item = traversal === "dfs" ? queue.pop() : queue.shift();
+    const deny = allowUrl(item.url);
+    if (deny) {
+      skipped.push({ url: item.url, reason: deny });
+      continue;
+    }
+    await pace();
+    const page = await fetchPage(item.url, { fetchOpts, maxChars, cache });
+    lastFetchAt = Date.now();
+    if (!page.ok) {
+      skipped.push({ url: item.url, reason: page.reason });
+      continue;
+    }
+    let links = page.links;
+    if (page.fromCache && item.depth < maxDepth && pages.length < maxPages && links.length === 0) {
+      const htmlRes = await fetchHtml(item.url, {
+        ...fetchOpts,
+        forceRefresh: true
+      });
+      lastFetchAt = Date.now();
+      if (htmlRes.ok) {
+        links = extractLinks(htmlRes.html, htmlRes.finalUrl);
+      }
+    }
+    pages.push({
+      url: canonicalForOutput(page.finalUrl),
+      finalUrl: page.finalUrl,
+      title: page.title,
+      markdown: page.markdown,
+      depth: item.depth,
+      fromCache: page.fromCache
+    });
+    if (item.depth >= maxDepth || pages.length >= maxPages)
+      continue;
+    const filtered = prioritizeDocLinks(links.filter((link) => {
+      if (visited.has(canonicalForCrawl(link)))
+        return false;
+      if (allowUrl(link))
+        return false;
+      return true;
+    }));
+    for (const link of filtered) {
+      const c = canonicalForCrawl(link);
+      if (visited.has(c))
+        continue;
+      visited.add(c);
+      queue.push({ url: link, depth: item.depth + 1 });
+      recordEdge(item.url, link);
+    }
+  }
+  return finalizeCrawl({
+    seed: seed.toString(),
+    strategyUsed: traversal,
+    pages,
+    totalFound: visited.size,
+    skipped,
+    robotsFetched,
+    sitemapFound,
+    links: extractLinksGraph ? linkEdges : undefined,
+    dedupeBoilerplate,
+    maxTotalChars,
+    maxTokensOut: opts.maxTokensOut,
+    includeFullMarkdown,
+    doIndex,
+    useAuth
+  });
+}
+async function finalizeCrawl(args) {
+  let pages = args.pages;
+  if (args.dedupeBoilerplate && pages.length > 1) {
+    let domain;
+    try {
+      domain = new URL(args.seed).hostname;
+    } catch {
+      domain = undefined;
+    }
+    const deduped = deduplicatePages(pages.map((p) => ({ url: p.url, markdown: p.markdown })), domain);
+    pages = pages.map((p, i) => ({
+      ...p,
+      markdown: deduped[i]?.markdown ?? p.markdown
+    }));
+  }
+  let droppedOverBudget = 0;
+  {
+    const budgeted = [];
+    let charCount = 0;
+    for (const page of pages) {
+      if (charCount + page.markdown.length > args.maxTotalChars && budgeted.length > 0) {
+        droppedOverBudget += 1;
+        continue;
+      }
+      let md = page.markdown;
+      if (charCount + md.length > args.maxTotalChars) {
+        md = truncateByChars(md, Math.max(0, args.maxTotalChars - charCount));
+      }
+      budgeted.push({ ...page, markdown: md });
+      charCount += md.length;
+    }
+    pages = budgeted;
+  }
+  const maxTokensOut = args.maxTokensOut ?? scaleDefaultTokens(pages.length);
+  for (const page of pages) {
+    if (!page.markdown)
+      continue;
+    page.evidence = buildEvidenceFromMarkdown(args.seed, page.title || page.url, page.url, page.markdown, { maxTokensOut: Math.min(400, maxTokensOut), maxItems: 1 });
+  }
+  let indexed = 0;
+  if (args.doIndex) {
+    for (const page of pages) {
+      const ok = await indexCrawlResult({
+        url: page.url,
+        title: page.title,
+        markdown: page.markdown
+      });
+      if (ok)
+        indexed += 1;
+    }
+  }
+  if (!args.includeFullMarkdown) {
+    for (const page of pages) {
+      if (!page.evidence?.length && page.markdown) {
+        page.excerpt = page.markdown.slice(0, 600);
+      }
+      page.markdown = "";
+    }
+  } else {
+    applyAggregateMarkdownBudget(pages, (p) => p.markdown, (p, body) => {
+      p.markdown = body;
+    }, { maxTokensOut, minTokensPerItem: MIN_TOKENS_PER_PAGE });
+  }
+  return {
+    ok: true,
+    seed: args.seed,
+    strategyUsed: args.strategyUsed,
+    pages,
+    totalFound: args.totalFound,
+    crawled: pages.length,
+    skipped: args.skipped,
+    robotsFetched: args.robotsFetched,
+    sitemapFound: args.sitemapFound,
+    ...args.links ? { links: args.links } : {},
+    ...droppedOverBudget > 0 ? { droppedOverBudget } : {},
+    ...indexed > 0 ? { indexed } : {},
+    authUsed: args.useAuth
+  };
+}
+async function runMapStrategy(ctx) {
+  const discovered = [];
+  const seen = new Set;
+  let sitemapFound = false;
+  const pushUrl = (url) => {
+    if (discovered.length >= ctx.maxPages)
+      return;
+    const c = canonicalForCrawl(url);
+    if (seen.has(c))
+      return;
+    if (ctx.sameHost) {
+      try {
+        if (new URL(url).hostname.toLowerCase() !== ctx.host)
+          return;
+      } catch {
+        return;
+      }
+    }
+    if (!matchesPatterns(url, ctx.includePatterns, ctx.excludePatterns))
+      return;
+    if (ctx.respectRobots && !isUrlAllowedByRobots(url, ctx.robots))
+      return;
+    const safe = assertSafeHttpUrl(url, {
+      allowPrivateNetwork: ctx.allowPrivate
+    });
+    if (!safe.ok)
+      return;
+    seen.add(c);
+    discovered.push(canonicalForOutput(url));
+  };
+  pushUrl(ctx.seed);
+  const sm = await discoverSitemapUrls(ctx.origin, ctx.lightFetch, ctx.robotsRaw);
+  if (sm.length > 0) {
+    sitemapFound = true;
+    for (const u of sm)
+      pushUrl(u);
+  }
+  const queue = [{ url: ctx.seed, depth: 0 }];
+  const queued = new Set([canonicalForCrawl(ctx.seed)]);
+  let last = 0;
+  while (queue.length && discovered.length < ctx.maxPages) {
+    const item = queue.shift();
+    if (item.depth >= ctx.maxDepth)
+      continue;
+    const wait = ctx.delayMs - (Date.now() - last);
+    if (wait > 0)
+      await sleep(wait);
+    const htmlRes = await fetchHtml(item.url, {
+      ...ctx.fetchOpts,
+      forceRefresh: item.depth === 0
+    });
+    last = Date.now();
+    if (!htmlRes.ok)
+      continue;
+    for (const link of extractLinks(htmlRes.html, htmlRes.finalUrl)) {
+      pushUrl(link);
+      const c = canonicalForCrawl(link);
+      if (queued.has(c))
+        continue;
+      if (item.depth + 1 > ctx.maxDepth)
+        continue;
+      if (ctx.sameHost) {
+        try {
+          if (new URL(link).hostname.toLowerCase() !== ctx.host)
+            continue;
+        } catch {
+          continue;
+        }
+      }
+      if (ctx.respectRobots && !isPathAllowed(new URL(link).pathname, ctx.robots)) {
+        continue;
+      }
+      queued.add(c);
+      queue.push({ url: link, depth: item.depth + 1 });
+    }
+  }
+  return {
+    ok: true,
+    seed: ctx.seed,
+    strategyUsed: "map",
+    pages: [],
+    totalFound: discovered.length,
+    crawled: 0,
+    skipped: [],
+    robotsFetched: ctx.robotsFetched,
+    sitemapFound,
+    urls: discovered
+  };
+}
+
+// ../web-brain/src/diff.ts
+function diffLines(oldText, newText) {
+  const a = oldText.replace(/\r\n/g, `
+`).split(`
+`);
+  const b = newText.replace(/\r\n/g, `
+`).split(`
+`);
+  const n = a.length;
+  const m = b.length;
+  if (n * m > 2000000) {
+    return roughDiff(a, b);
+  }
+  const dp = Array.from({ length: n + 1 }, () => Array.from({ length: m + 1 }, () => 0));
+  for (let i2 = n - 1;i2 >= 0; i2--) {
+    for (let j2 = m - 1;j2 >= 0; j2--) {
+      if (a[i2] === b[j2])
+        dp[i2][j2] = dp[i2 + 1][j2 + 1] + 1;
+      else
+        dp[i2][j2] = Math.max(dp[i2 + 1][j2], dp[i2][j2 + 1]);
+    }
+  }
+  const ops = [];
+  let i = 0;
+  let j = 0;
+  while (i < n && j < m) {
+    if (a[i] === b[j]) {
+      ops.push({ t: "eq", line: a[i] });
+      i++;
+      j++;
+    } else if (dp[i + 1][j] >= dp[i][j + 1]) {
+      ops.push({ t: "del", line: a[i] });
+      i++;
+    } else {
+      ops.push({ t: "add", line: b[j] });
+      j++;
+    }
+  }
+  while (i < n) {
+    ops.push({ t: "del", line: a[i++] });
+  }
+  while (j < m) {
+    ops.push({ t: "add", line: b[j++] });
+  }
+  return coalesceOps(ops);
+}
+function roughDiff(a, b) {
+  const setA = new Set(a);
+  const setB = new Set(b);
+  const removed = a.filter((l) => !setB.has(l));
+  const added = b.filter((l) => !setA.has(l));
+  const hunks = [];
+  if (removed.length)
+    hunks.push({ type: "remove", lines: removed });
+  if (added.length)
+    hunks.push({ type: "add", lines: added });
+  return hunks;
+}
+function coalesceOps(ops) {
+  const hunks = [];
+  for (const op of ops) {
+    const type = op.t === "eq" ? "equal" : op.t === "add" ? "add" : "remove";
+    const last = hunks[hunks.length - 1];
+    if (last && last.type === type)
+      last.lines.push(op.line);
+    else
+      hunks.push({ type, lines: [op.line] });
+  }
+  return hunks;
+}
+function summarizeHunks(hunks, oldHash, newHash, opts = {}) {
+  const maxUnifiedChars = opts.maxUnifiedChars ?? 12000;
+  const maxHunks = opts.maxHunks ?? 40;
+  let addedLines = 0;
+  let removedLines = 0;
+  for (const h of hunks) {
+    if (h.type === "add")
+      addedLines += h.lines.length;
+    if (h.type === "remove")
+      removedLines += h.lines.length;
+  }
+  const changed = oldHash !== newHash;
+  const outHunks = hunks.filter((h) => h.type !== "equal").slice(0, maxHunks);
+  const unifiedParts = [];
+  for (const h of hunks) {
+    if (h.type === "equal") {
+      continue;
+    }
+    const prefix = h.type === "add" ? "+" : "-";
+    for (const line of h.lines) {
+      unifiedParts.push(`${prefix}${line}`);
+    }
+  }
+  let unified = unifiedParts.join(`
+`);
+  if (unified.length > maxUnifiedChars) {
+    unified = unified.slice(0, maxUnifiedChars) + `
+… [unified diff truncated]`;
+  }
+  return {
+    changed: changed || addedLines > 0 || removedLines > 0,
+    oldHash,
+    newHash,
+    addedLines,
+    removedLines,
+    unified,
+    hunks: outHunks
+  };
+}
+async function webDiff(opts) {
+  let oldMd = opts.oldMarkdown;
+  let oldTitle = opts.oldTitle ?? "";
+  let oldFetchedAt = null;
+  let oldFromCache = false;
+  let newMd = opts.newMarkdown;
+  let newTitle = opts.newTitle ?? "";
+  let newFetchedAt = new Date().toISOString();
+  let newFromCache = false;
+  let url = opts.url ?? null;
+  if (opts.url && oldMd == null) {
+    const cached = opts.cache?.get(opts.url) ?? null;
+    if (!cached) {
+      const first = await webFetch(opts.url, {
+        ...opts.fetchOpts,
+        cache: opts.cache ?? opts.fetchOpts?.cache,
+        forceRefresh: true
+      });
+      if (!first.ok)
+        return first;
+      return {
+        ok: true,
+        url: opts.url,
+        summary: {
+          changed: false,
+          oldHash: "",
+          newHash: first.contentHash,
+          addedLines: 0,
+          removedLines: 0,
+          unified: "",
+          hunks: []
+        },
+        old: { title: "", fetchedAt: null, fromCache: false },
+        new: {
+          title: first.title,
+          fetchedAt: first.fetchedAt,
+          fromCache: false
+        }
+      };
+    }
+    oldMd = cached.markdown;
+    oldTitle = cached.title;
+    oldFetchedAt = cached.fetchedAt;
+    oldFromCache = true;
+    url = cached.url;
+  }
+  if (opts.url && newMd == null) {
+    const fresh = await webFetch(opts.url, {
+      ...opts.fetchOpts,
+      cache: opts.cache ?? opts.fetchOpts?.cache,
+      forceRefresh: true
+    });
+    if (!fresh.ok)
+      return fresh;
+    newMd = fresh.markdown;
+    newTitle = fresh.title;
+    newFetchedAt = fresh.fetchedAt;
+    newFromCache = false;
+    url = fresh.url;
+  }
+  if (oldMd == null || newMd == null) {
+    return toWebError("invalid_url", "Provide url (with cache) or both oldMarkdown and newMarkdown");
+  }
+  const { createHash: createHash6 } = await import("node:crypto");
+  const oldHash = createHash6("sha256").update(oldMd).digest("hex");
+  const newHash = createHash6("sha256").update(newMd).digest("hex");
+  if (oldHash === newHash) {
+    return {
+      ok: true,
+      url,
+      summary: {
+        changed: false,
+        oldHash,
+        newHash,
+        addedLines: 0,
+        removedLines: 0,
+        unified: "",
+        hunks: []
+      },
+      old: { title: oldTitle, fetchedAt: oldFetchedAt, fromCache: oldFromCache },
+      new: { title: newTitle, fetchedAt: newFetchedAt, fromCache: newFromCache }
+    };
+  }
+  const hunks = diffLines(oldMd, newMd);
+  const summary = summarizeHunks(hunks, oldHash, newHash, {
+    maxUnifiedChars: opts.maxUnifiedChars,
+    maxHunks: opts.maxHunks
+  });
+  return {
+    ok: true,
+    url,
+    summary,
+    old: { title: oldTitle, fetchedAt: oldFetchedAt, fromCache: oldFromCache },
+    new: { title: newTitle, fetchedAt: newFetchedAt, fromCache: newFromCache }
+  };
+}
+
+// ../web-brain/src/mcp-server.ts
+function openCache() {
+  if (process.env.PHNEAKNGAR_WEB_CACHE_DIR) {
+    return new WebCache({ dir: process.env.PHNEAKNGAR_WEB_CACHE_DIR });
+  }
+  const root = process.env.PHNEAKNGAR_PROJECT_ROOT || join5(homedir4(), ".phneakngar");
+  return new WebCache({ dir: defaultCacheDir(root) });
+}
+var TOOLS = [
+  {
+    name: "web_search",
+    description: "Search the public web (DDG lite → HTML fallback). Returns title/url/snippet plus provider telemetry. Empty results set degraded=true and error.code=empty_provider_results (not silent success). Prefer over inventing URLs.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string" },
+        max_results: { type: "number" },
+        time_range: {
+          type: "string",
+          enum: ["day", "week", "month", "year"],
+          description: "Recency filter (DDG df=) when supported"
+        },
+        mock: { type: "boolean", description: "Offline mock results" }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "web_fetch",
+    description: "Fetch a public http(s) URL as clean markdown. SSRF-guarded. Uses local cache unless force_refresh.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        url: { type: "string" },
+        force_refresh: { type: "boolean" },
+        max_chars: { type: "number" }
+      },
+      required: ["url"]
+    }
+  },
+  {
+    name: "web_cache",
+    description: "Search or stats on the local web-brain cache (no network).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: { type: "string", enum: ["search", "stats", "clear"] },
+        query: { type: "string" },
+        limit: { type: "number" }
+      },
+      required: ["action"]
+    }
+  },
+  {
+    name: "web_extract",
+    description: "Structured extract: metadata, HTML tables, and/or JSON-LD from a URL or raw html.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        url: { type: "string" },
+        html: { type: "string" },
+        mode: {
+          type: "string",
+          enum: ["metadata", "tables", "jsonld", "all"]
+        }
+      }
+    }
+  },
+  {
+    name: "web_crawl",
+    description: "Multi-page crawl: strategy bfs|dfs|sitemap|auto|map. Sitemap-first for docs, pattern filters, robots.txt, canonical URL dedup. Caps: depth≤3, pages≤50. Prefer sitemap/auto for doc sites; map for URL discovery only.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        url: { type: "string" },
+        strategy: {
+          type: "string",
+          enum: ["bfs", "dfs", "sitemap", "auto", "map"],
+          description: "bfs (default) | dfs | sitemap | auto (sitemap if found else bfs) | map (URLs only)"
+        },
+        max_depth: { type: "number" },
+        max_pages: { type: "number" },
+        same_host: { type: "boolean" },
+        include_patterns: {
+          type: "array",
+          items: { type: "string" },
+          description: "Regex whitelist on full URL"
+        },
+        exclude_patterns: {
+          type: "array",
+          items: { type: "string" },
+          description: "Regex blacklist on full URL"
+        },
+        extract_links: {
+          type: "boolean",
+          description: "Include inter-page link graph"
+        },
+        use_auth: {
+          type: "boolean",
+          description: "Send cookies from auth state / env"
+        },
+        max_total_chars: { type: "number" },
+        max_tokens_out: { type: "number" },
+        include_full_markdown: { type: "boolean" },
+        index_pages: {
+          type: "boolean",
+          description: "Embed pages into local vector store (or PHNEAKNGAR_CRAWL_INDEX=1)"
+        },
+        dedupe_boilerplate: { type: "boolean" }
+      },
+      required: ["url"]
+    }
+  },
+  {
+    name: "web_find_similar",
+    description: "Find similar pages from the local crawl vector index (hash embeddings). Prefer after crawl with index_pages / PHNEAKNGAR_CRAWL_INDEX=1.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "URL previously indexed or free-text concept"
+        },
+        limit: { type: "number" }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "web_diff",
+    description: "Diff a URL's cached snapshot against a fresh fetch (or two markdown strings). Reports changed, line counts, unified patch.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        url: { type: "string" },
+        old_markdown: { type: "string" },
+        new_markdown: { type: "string" }
+      }
+    }
+  }
+];
+var frameMode = "ndjson";
+function send(msg) {
+  const body = JSON.stringify(msg);
+  if (frameMode === "ndjson") {
+    writeSync(1, `${body}
+`);
+    return;
+  }
+  const frame = `Content-Length: ${Buffer.byteLength(body, "utf-8")}\r
+\r
+${body}`;
+  writeSync(1, frame);
+}
+var SUPPORTED_PROTOCOL = "2025-06-18";
+async function callTool(name, args) {
+  const cache = openCache();
+  switch (name) {
+    case "web_search": {
+      const query = String(args.query ?? "");
+      const maxResults = Number(args.max_results) || 5;
+      const tr = args.time_range != null ? String(args.time_range) : undefined;
+      const timeRange = tr === "day" || tr === "week" || tr === "month" || tr === "year" ? tr : undefined;
+      const provider = args.mock ? createMockSearchProvider([
+        {
+          title: `Mock: ${query}`,
+          url: "https://example.com/",
+          snippet: "mock"
+        }
+      ]) : undefined;
+      return webSearch(query, { maxResults, provider, timeRange });
+    }
+    case "web_fetch": {
+      return webFetch(String(args.url ?? ""), {
+        forceRefresh: !!args.force_refresh,
+        maxChars: Number(args.max_chars) || 30000,
+        cache
+      });
+    }
+    case "web_cache": {
+      const action = String(args.action ?? "stats");
+      if (action === "clear") {
+        cache.clear();
+        return { ok: true, cleared: true, path: cache.dir };
+      }
+      if (action === "search") {
+        return {
+          ok: true,
+          hits: cache.search(String(args.query ?? ""), Number(args.limit) || 20)
+        };
+      }
+      return { ok: true, ...cache.stats() };
+    }
+    case "web_extract": {
+      return structuredExtract({
+        url: args.url != null ? String(args.url) : undefined,
+        html: args.html != null ? String(args.html) : undefined,
+        mode: args.mode || "all",
+        fetchOpts: { cache }
+      });
+    }
+    case "web_crawl": {
+      const strat = args.strategy != null ? String(args.strategy) : "bfs";
+      const strategy = strat === "dfs" || strat === "sitemap" || strat === "auto" || strat === "map" || strat === "bfs" ? strat : "bfs";
+      const include = Array.isArray(args.include_patterns) ? args.include_patterns.map(String) : undefined;
+      const exclude = Array.isArray(args.exclude_patterns) ? args.exclude_patterns.map(String) : undefined;
+      return webCrawl(String(args.url ?? ""), {
+        strategy,
+        maxDepth: args.max_depth != null ? Number(args.max_depth) : 2,
+        maxPages: args.max_pages != null ? Number(args.max_pages) : 20,
+        sameHost: args.same_host !== false,
+        includePatterns: include,
+        excludePatterns: exclude,
+        extractLinksGraph: args.extract_links === true,
+        useAuth: args.use_auth === true,
+        maxTotalChars: args.max_total_chars != null ? Number(args.max_total_chars) : undefined,
+        maxTokensOut: args.max_tokens_out != null ? Number(args.max_tokens_out) : undefined,
+        includeFullMarkdown: args.include_full_markdown !== false,
+        indexPages: args.index_pages === true || isIndexingEnabled(),
+        dedupeBoilerplate: args.dedupe_boilerplate !== false,
+        cache
+      });
+    }
+    case "web_find_similar": {
+      return {
+        ok: true,
+        indexingEnabled: isIndexingEnabled(),
+        results: findSimilar(String(args.query ?? ""), {
+          limit: Number(args.limit) || 5
+        })
+      };
+    }
+    case "web_diff": {
+      return webDiff({
+        url: args.url != null ? String(args.url) : undefined,
+        oldMarkdown: args.old_markdown != null ? String(args.old_markdown) : undefined,
+        newMarkdown: args.new_markdown != null ? String(args.new_markdown) : undefined,
+        cache
+      });
+    }
+    default:
+      throw new Error(`Unknown tool: ${name}`);
+  }
+}
+async function handleMcpMessage(msg) {
+  const id = msg.id ?? null;
+  const method = msg.method ?? "";
+  if (method === "initialize") {
+    const requested = typeof msg.params?.protocolVersion === "string" ? msg.params.protocolVersion : SUPPORTED_PROTOCOL;
+    const protocolVersion = requested === "2024-11-05" || requested === "2025-03-26" || requested === "2025-06-18" ? requested : SUPPORTED_PROTOCOL;
+    return {
+      jsonrpc: "2.0",
+      id,
+      result: {
+        protocolVersion,
+        capabilities: { tools: {} },
+        serverInfo: { name: "phneakngar-web-brain", version: "0.0.2" }
+      }
+    };
+  }
+  if (method === "notifications/initialized" || method === "initialized") {
+    return;
+  }
+  if (method === "ping") {
+    return { jsonrpc: "2.0", id, result: {} };
+  }
+  if (method === "tools/list") {
+    return { jsonrpc: "2.0", id, result: { tools: TOOLS } };
+  }
+  if (method === "tools/call") {
+    const params = msg.params ?? {};
+    const name = String(params.name ?? "");
+    const args = params.arguments ?? {};
+    try {
+      const result = await callTool(name, args);
+      const isError = typeof result === "object" && result != null && "ok" in result && result.ok === false;
+      return {
+        jsonrpc: "2.0",
+        id,
+        result: {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+          structuredContent: result,
+          isError
+        }
+      };
+    } catch (e) {
+      return {
+        jsonrpc: "2.0",
+        id,
+        error: {
+          code: -32000,
+          message: e instanceof Error ? e.message : String(e)
+        }
+      };
+    }
+  }
+  if (id !== null && id !== undefined) {
+    return {
+      jsonrpc: "2.0",
+      id,
+      error: { code: -32601, message: `Method not found: ${method}` }
+    };
+  }
+  return;
+}
+function takeJsonObject(text) {
+  const start = text.search(/\{/);
+  if (start < 0)
+    return null;
+  let depth = 0;
+  let inString = false;
+  let escape = false;
+  for (let i = start;i < text.length; i++) {
+    const ch = text[i];
+    if (inString) {
+      if (escape) {
+        escape = false;
+        continue;
+      }
+      if (ch === "\\") {
+        escape = true;
+        continue;
+      }
+      if (ch === '"')
+        inString = false;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      continue;
+    }
+    if (ch === "{")
+      depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0) {
+        return {
+          json: text.slice(start, i + 1),
+          rest: text.slice(i + 1)
+        };
+      }
+    }
+  }
+  return null;
+}
+async function runMcpStdio() {
+  let buffer = Buffer.alloc(0);
+  let draining = false;
+  const onData = (chunk) => {
+    buffer = Buffer.concat([buffer, chunk]);
+    drain();
+  };
+  async function drain() {
+    if (draining)
+      return;
+    draining = true;
+    try {
+      while (true) {
+        const asText = buffer.toString("utf-8");
+        const trimmedStart = asText.replace(/^\s+/, "");
+        if (/^Content-Length\s*:/i.test(trimmedStart)) {
+          const headerEnd = buffer.indexOf(`\r
+\r
+`);
+          if (headerEnd < 0)
+            return;
+          const header = buffer.slice(0, headerEnd).toString("utf-8");
+          const match = header.match(/Content-Length:\s*(\d+)/i);
+          if (!match) {
+            buffer = buffer.slice(headerEnd + 4);
+            continue;
+          }
+          frameMode = "content-length";
+          const len = Number(match[1]);
+          const bodyStart = headerEnd + 4;
+          if (buffer.length < bodyStart + len)
+            return;
+          const body = buffer.slice(bodyStart, bodyStart + len).toString("utf-8");
+          buffer = buffer.slice(bodyStart + len);
+          try {
+            const msg = JSON.parse(body);
+            const resp = await handleMcpMessage(msg);
+            if (resp !== undefined)
+              send(resp);
+          } catch {}
+          continue;
+        }
+        const nl = buffer.indexOf(`
+`);
+        if (nl >= 0) {
+          const line = buffer.slice(0, nl).toString("utf-8").trim();
+          buffer = buffer.slice(nl + 1);
+          if (line.startsWith("{")) {
+            frameMode = "ndjson";
+            try {
+              const msg = JSON.parse(line);
+              const resp = await handleMcpMessage(msg);
+              if (resp !== undefined)
+                send(resp);
+            } catch {}
+          }
+          continue;
+        }
+        const text = buffer.toString("utf-8");
+        const taken = takeJsonObject(text.trimStart());
+        if (!taken)
+          return;
+        frameMode = "ndjson";
+        buffer = Buffer.from(taken.rest, "utf-8");
+        try {
+          const msg = JSON.parse(taken.json);
+          const resp = await handleMcpMessage(msg);
+          if (resp !== undefined)
+            send(resp);
+        } catch {}
+      }
+    } finally {
+      draining = false;
+      if (buffer.length > 0)
+        drain();
+    }
+  }
+  if (typeof process.stdin.resume === "function")
+    process.stdin.resume();
+  process.stdin.on("data", onData);
+  await new Promise((resolve) => {
+    process.stdin.on("end", () => resolve());
+    process.stdin.on("close", () => resolve());
+  });
+}
+
+// ../web-brain/src/bin-mcp.ts
+runMcpStdio();