fh-library 0.2.5 → 0.2.9

package/dist/index.js

@@ -11,10 +11,10 @@ function dotenvFile(env = process.env) {
   return join(resolve(lib), ".env");
 }
 var loadedFromDotenv = /* @__PURE__ */ new Set();
-function loadDotenv(file = dotenvFile()) {
-  if (!existsSync(file)) return [];
+function loadDotenv(file2 = dotenvFile()) {
+  if (!existsSync(file2)) return [];
   const loaded = [];
-  for (const raw of readFileSync(file, "utf8").split(/\r?\n/)) {
+  for (const raw of readFileSync(file2, "utf8").split(/\r?\n/)) {
     const line = raw.trim();
     if (!line || line.startsWith("#")) continue;
     const m = /^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/.exec(line);
@@ -60,6 +60,11 @@ var contactEmail = (env = process.env) => str("FH_LIBRARY_CONTACT_EMAIL", env) |
 // src/http.ts
 var TIMEOUT_MS = 3e4;
 var CHROME_UA = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36";
+var BROWSER_HEADERS = {
+  "User-Agent": CHROME_UA,
+  "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+  "Accept-Language": "en-US,en;q=0.9"
+};
 var LIBRARY_UA = `fh-library (+https://github.com/forever-healthy/fh-library; ${contactEmail()})`;
 function httpReason(status, body) {
   const m = body.length < 4e3 && /<statusCode>([A-Z_]+)<\/statusCode>|"statusCode"\s*:\s*"([A-Z_]+)"/.exec(body);
@@ -655,20 +660,20 @@ function headingOf(line) {
   if (bare2.length > 60 || !/^[A-Za-z][A-Za-z &'\u2019]*$/.test(bare2)) return null;
   return BY_SQUEEZED.get(squeeze(bare2)) ?? null;
 }
-async function pdfToMarkdown(bytes, title, headLine2, stats) {
+async function pdfToMarkdown(bytes, title, headLine2, stats2) {
   const pdf = await getDocumentProxy(new Uint8Array(bytes), { fontExtraProperties: true });
   const text3 = await extractPages(pdf);
-  if (stats) {
-    stats.pages = pdf.numPages;
-    stats.chars = text3.replace(/\s+/g, " ").trim().length;
+  if (stats2) {
+    stats2.pages = pdf.numPages;
+    stats2.chars = text3.replace(/\s+/g, " ").trim().length;
   }
   const lines = text3.split(/\r?\n/).map((l) => l.replace(/\s+/g, " ").trim());
   const out = [`# ${title}`, "", headLine2, ""];
-  let para2 = [];
+  let para3 = [];
   const flush = () => {
-    if (para2.length) {
-      out.push(para2.join(" "), "");
-      para2 = [];
+    if (para3.length) {
+      out.push(para3.join(" "), "");
+      para3 = [];
     }
   };
   for (const line of lines) {
@@ -682,7 +687,7 @@ async function pdfToMarkdown(bytes, title, headLine2, stats) {
       out.push(`## ${h}`, "");
       continue;
     }
-    para2.push(line);
+    para3.push(line);
   }
   flush();
   return fixGlyphs(out.join("\n")).replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
@@ -875,9 +880,9 @@ function dehyphenate(text3) {
   return text3.replace(/([A-Za-z]+)\u0000\n([A-Za-z]+)/g, (m, x, y) => {
     if (!/^[a-z]/.test(y)) return `${x}-${y}`;
     if (SUSPENDED.has(y.toLowerCase())) return `${x}- ${y}`;
-    const hyph = `${x}-${y}`.toLowerCase(), joined = `${x}${y}`.toLowerCase();
+    const hyph = `${x}-${y}`.toLowerCase(), joined3 = `${x}${y}`.toLowerCase();
     if (seen(hyph)) return `${x}-${y}`;
-    if (seen(joined)) return `${x}${y}`;
+    if (seen(joined3)) return `${x}${y}`;
     return COMPOUND_PREFIX.has(x.toLowerCase()) ? `${x}-${y}` : `${x}${y}`;
   }).replace(/\u0000\n/g, "-\n").replace(/\u0000/g, "-");
 }
@@ -1000,6 +1005,8 @@ var NAV_TIMEOUT_MS = 2e4;
 var CHALLENGE_WAIT_MS = 8e3;
 var DOWNLOAD_WAIT_MS = 1e4;
 var IDLE_CLOSE_MS = 12e4;
+var SETTLE_MS = 8e3;
+var SETTLE_WORDS = 100;
 var ctxs = /* @__PURE__ */ new Map();
 var idleTimer = null;
 var LAUNCH_ARGS = ["--disable-blink-features=AutomationControlled", "--window-size=1366,900"];
@@ -1141,6 +1148,12 @@ async function browserFetch(url, endpoint, cfg = browserConfig()) {
       if (!r.ok()) throw new Error(`HTTP ${r.status()} (pdf request)`);
       return { bytes: Buffer.from(await r.body()), contentType: "application/pdf", url: page.url(), via: "request" };
     }
+    const words2 = () => page.evaluate(() => (document.body?.innerText ?? "").split(/\s+/).filter(Boolean).length).catch(() => 0);
+    if (await words2() < SETTLE_WORDS) {
+      await page.waitForLoadState("networkidle", { timeout: SETTLE_MS }).catch(() => void 0);
+      const t2 = Date.now();
+      while (Date.now() - t2 < SETTLE_MS && await words2() < SETTLE_WORDS) await new Promise((r) => setTimeout(r, 1e3));
+    }
     const html = await page.content();
     return { bytes: Buffer.from(html, "utf8"), contentType: contentType || "text/html", url: page.url(), via: "page" };
   } finally {
@@ -1150,14 +1163,39 @@ async function browserFetch(url, endpoint, cfg = browserConfig()) {
 }
 
 // src/unlock.ts
+import { request as httpsRequest } from "https";
 var ENDPOINT = "https://api.brightdata.com/request";
 var TIMEOUT_MS2 = 6e4;
+function post(url, init) {
+  return new Promise((resolve3, reject) => {
+    const req = httpsRequest(url, { method: "POST", headers: { ...init.headers, "Content-Length": String(Buffer.byteLength(init.body)) }, signal: init.signal }, (res) => {
+      const chunks = [];
+      res.on("data", (c) => chunks.push(c));
+      res.on("error", reject);
+      res.on("end", () => {
+        const body = Buffer.concat(chunks);
+        const status = res.statusCode ?? 0;
+        resolve3({
+          ok: status >= 200 && status < 300,
+          status,
+          headers: { get: (name) => {
+            const v = res.headers[name.toLowerCase()];
+            return v == null ? null : Array.isArray(v) ? v.join(", ") : v;
+          } },
+          arrayBuffer: async () => body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength)
+        });
+      });
+    });
+    req.on("error", (e) => reject(e.name === "AbortError" || e.name === "TimeoutError" ? new Error("timeout") : e));
+    req.end(init.body);
+  });
+}
 var unlockerConfigured = () => !!process.env.FH_LIBRARY_BRIGHTDATA_API_TOKEN?.trim();
-async function unlock(url, fetchImpl = fetch) {
+async function unlock(url, postImpl = post) {
   const token = process.env.FH_LIBRARY_BRIGHTDATA_API_TOKEN?.trim();
   if (!token) throw new Error("unlocker not configured");
   const zone = process.env.FH_LIBRARY_BRIGHTDATA_ZONE?.trim() || "mcp_unlocker";
-  const res = await fetchImpl(ENDPOINT, {
+  const res = await postImpl(ENDPOINT, {
     method: "POST",
     headers: { "Authorization": `Bearer ${token}`, "Content-Type": "application/json" },
     body: JSON.stringify({ zone, url, format: "raw" }),
@@ -1264,13 +1302,13 @@ async function convertBytes(p, bytes, contentType = "") {
   let md;
   if (looksLikePdf(bytes)) {
     format = "pdf";
-    const stats = {};
+    const stats2 = {};
     try {
-      md = await pdfToMarkdown(bytes, p.title, p.headLine, stats);
+      md = await pdfToMarkdown(bytes, p.title, p.headLine, stats2);
     } catch (e) {
       return { ok: false, reason: `pdf: ${errMsg(e)}` };
     }
-    if ((stats.pages ?? 0) >= 1 && (stats.chars ?? 0) < 500 * (stats.pages ?? 1)) return { ok: false, reason: "scanned pdf", format };
+    if ((stats2.pages ?? 0) >= 1 && (stats2.chars ?? 0) < 500 * (stats2.pages ?? 1)) return { ok: false, reason: "scanned pdf", format };
   } else {
     const text3 = bytes.toString("utf8");
     if (isWallPage(text3)) return { ok: false, reason: "wall page" };
@@ -1462,15 +1500,15 @@ function inboxTier(dir = INBOX_DIR) {
     always: true,
     applies: (p) => p.pmid ? true : "no pmid",
     async run(p, ctx) {
-      const file = findInboxFile(dir, p.pmid);
-      if (!file) return { ...miss("inbox", "no file"), skipped: true, ephemeral: true };
-      const name = file.slice(file.lastIndexOf("/") + 1);
+      const file2 = findInboxFile(dir, p.pmid);
+      if (!file2) return { ...miss("inbox", "no file"), skipped: true, ephemeral: true };
+      const name = file2.slice(file2.lastIndexOf("/") + 1);
       const ext = name.slice(name.lastIndexOf(".")).toLowerCase();
-      const bytes = readFileSync3(file);
+      const bytes = readFileSync3(file2);
       const r = await convertBytes(p, bytes, EXT[ext]);
       if (!r.ok) return miss("inbox", `${name}: ${r.reason}`);
       ctx.onTry?.(`${name} ok, removed from the inbox`);
-      unlinkSync(file);
+      unlinkSync(file2);
       return { ok: true, tier: "inbox", format: r.format, raw: r.format === "pdf" ? bytes : bytes.toString("utf8"), md: r.md, version: "published" };
     }
   };
@@ -1743,24 +1781,24 @@ function stamp() {
   return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`;
 }
 var LOG_MAX_BYTES = 50 * 1024 * 1024;
-function rotateIfLarge(file, max = LOG_MAX_BYTES) {
+function rotateIfLarge(file2, max = LOG_MAX_BYTES) {
   let size = 0;
   try {
-    size = statSync(file).size;
+    size = statSync(file2).size;
   } catch {
     return false;
   }
   if (size <= max) return false;
   try {
-    renameSync(file, `${file}.1`);
+    renameSync(file2, `${file2}.1`);
     return true;
   } catch {
     return false;
   }
 }
 function log(tool, id, message) {
-  const clean = message.replace(/\x1b\[[0-9;]*m/g, "").replace(/\s*\n\s*/g, " | ");
-  const line = `${stamp()} ${HOST} ${tool.replace(/^library_/, "")} ${id ?? "-"} ${clean}
+  const clean2 = message.replace(/\x1b\[[0-9;]*m/g, "").replace(/\s*\n\s*/g, " | ");
+  const line = `${stamp()} ${HOST} ${tool.replace(/^library_/, "")} ${id ?? "-"} ${clean2}
 `;
   try {
     mkdirSync2(FH_LIBRARY_DIR, { recursive: true });
@@ -1770,9 +1808,9 @@ function log(tool, id, message) {
   }
 }
 
-// src/tools.ts
-import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
-import { z } from "zod";
+// src/stats.ts
+import { mkdirSync as mkdirSync4, readdirSync as readdirSync3, readFileSync as readFileSync5, statSync as statSync2, unlinkSync as unlinkSync2 } from "fs";
+import { join as join7 } from "path";
 
 // src/entry.ts
 import { copyFileSync, existsSync as existsSync5, mkdirSync as mkdirSync3, readdirSync as readdirSync2, readFileSync as readFileSync4, renameSync as renameSync2, rmSync, writeFileSync } from "fs";
@@ -2591,10 +2629,10 @@ function readMeta(p) {
     attempts: splitAttempts(fm.attempts)
   };
 }
-function writeAtomic(file, data) {
-  const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2, 8)}.tmp`;
+function writeAtomic(file2, data) {
+  const tmp = `${file2}.${process.pid}.${Math.random().toString(36).slice(2, 8)}.tmp`;
   writeFileSync(tmp, data);
-  renameSync2(tmp, file);
+  renameSync2(tmp, file2);
 }
 function writeMeta(p, m) {
   writeAtomic(p.meta, renderMeta(m));
@@ -2873,6 +2911,67 @@ function writeDoiEntry(p, r, json2, converter, abstractFrom = "crossref", record
   return meta;
 }
 
+// src/stats.ts
+var HEARTBEAT_MS = 5 * 6e4;
+var STALE_MS = 20 * 6e4;
+var stats = null;
+var file = null;
+function startStats(pkg2, libraryDir = FH_LIBRARY_DIR) {
+  stats = { host: HOST, pid: process.pid, package: pkg2.name, version: pkg2.version, started: (/* @__PURE__ */ new Date()).toISOString(), verify: { hits: 0, misses: 0 }, fetch: { hits: 0, misses: 0 }, search: { hits: 0, misses: 0 } };
+  file = join7(libraryDir, ".servers", `${HOST}-${process.pid}.json`);
+  sweep(join7(libraryDir, ".servers"));
+  publish();
+  setInterval(publish, HEARTBEAT_MS).unref();
+  const stop = () => {
+    try {
+      if (file) unlinkSync2(file);
+    } catch {
+    }
+  };
+  process.on("exit", stop);
+  for (const sig of ["SIGINT", "SIGTERM", "SIGHUP"]) process.on(sig, () => process.exit(0));
+  return stats;
+}
+function sweep(dir, staleMs = STALE_MS) {
+  let n = 0;
+  let names;
+  try {
+    names = readdirSync3(dir);
+  } catch {
+    return 0;
+  }
+  for (const name of names) {
+    if (!name.endsWith(".json")) continue;
+    const p = join7(dir, name);
+    try {
+      if (Date.now() - statSync2(p).mtimeMs > staleMs) {
+        unlinkSync2(p);
+        n++;
+      }
+    } catch {
+    }
+  }
+  return n;
+}
+function bump(kind, hit) {
+  if (!stats) return;
+  stats[kind][hit ? "hits" : "misses"]++;
+  publish();
+}
+var currentStats = () => stats;
+function publish() {
+  if (!stats || !file) return;
+  try {
+    mkdirSync4(join7(file, ".."), { recursive: true });
+    writeAtomic(file, JSON.stringify(stats, null, 2) + "\n");
+  } catch {
+  }
+}
+
+// src/tools.ts
+import { existsSync as existsSync11, readFileSync as readFileSync11 } from "fs";
+import { z } from "zod";
+
 // src/cascade.ts
 var PERMANENT = /^(no pmcid|no doi|no pmid|no pmid or doi|no body|closed|no oa copy|no free copy|not in core|no full text|xml without body|template has no placeholder|title missing|title not in text|no methods\/results|no article body|scanned pdf|not a pdf|only copies already tried|only pmc copies|nothing located|unknown content|no text-mining links|needs [a-z/]+ token)/i;
 var BLOCKED = /^(challenge not cleared|empty response)/i;
@@ -2945,11 +3044,11 @@ function parseId(raw) {
 }
 
 // src/info.ts
-import { existsSync as existsSync7, readdirSync as readdirSync3, readFileSync as readFileSync6, statSync as statSync2 } from "fs";
-import { dirname as dirname2, join as join7 } from "path";
+import { existsSync as existsSync7, readdirSync as readdirSync4, readFileSync as readFileSync7, statSync as statSync3 } from "fs";
+import { dirname as dirname2, join as join8 } from "path";
 
 // src/verify.ts
-import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync6 } from "fs";
 var DEFAULT_MODEL = "pplx-decider-flash-v1.2";
 var QUESTION = "Does the paper state this, in substance? Ignore section labels and definitions of terms in parentheses. Every fact and number of the statement must be stated in the paper or follow from its numbers; a rounded number counts. If any part of the statement is absent from the paper or contradicted by it, answer false.";
 function verifyConfig(env = process.env) {
@@ -3013,7 +3112,8 @@ function citationGroups(claim) {
 function fragment(claim) {
   const body = claim.trim().replace(/^[-*+]\s+/, "").replace(/^\*\*[^*]+:\*\*\s*/, "").replace(/^[("'\u201c]+/, "");
   const first = /^(\S+)/.exec(body)?.[1] ?? "";
-  if (/^(and|or|but|nor|which|whereas|while)$/i.test(first.replace(/[,;:]$/, ""))) return `claim is a fragment: starts with "${first}" \u2014 send a complete statement with its subject`;
+  const oddsRatio = first === "OR" && /^OR\s+(\d|=|\(|of\b|for\b)/.test(body);
+  if (!oddsRatio && /^(and|or|but|nor|which|whereas|while)$/i.test(first.replace(/[,;:]$/, ""))) return `claim is a fragment: starts with "${first}" \u2014 send a complete statement with its subject`;
   if (/^[a-z]/.test(body)) return `claim is a fragment: starts with "${first}" in lowercase \u2014 send a complete statement with its subject`;
   return null;
 }
@@ -3051,9 +3151,9 @@ async function readPaper(raw, libraryDir = FH_LIBRARY_DIR) {
   const paths = entryPaths(libraryDir, p.type, p.id);
   if (!entryExists(paths)) return { id: p.requested, error: "not in library" };
   const full = existsSync6(paths.fulltextMd);
-  if (full) return { id: p.requested, basis: "full_text", text: readFileSync5(paths.fulltextMd, "utf8") };
+  if (full) return { id: p.requested, basis: "full_text", text: readFileSync6(paths.fulltextMd, "utf8") };
   const meta = readMeta(paths);
-  return { id: p.requested, basis: meta.has_abstract ? "abstract" : "title", text: readFileSync5(paths.md, "utf8") };
+  return { id: p.requested, basis: meta.has_abstract ? "abstract" : "title", text: readFileSync6(paths.md, "utf8") };
 }
 async function verifyClaim(claim, id, cfg, decide, read = readPaper) {
   const out = { claim, id, verdict: "error", reason: null, score: null, basis: null, windows: 0, glyphs_unresolved: 0, superseded: null, model: cfg?.model ?? null };
@@ -3095,9 +3195,9 @@ async function verifyClaim(claim, id, cfg, decide, read = readPaper) {
 // src/info.ts
 function* metaFiles(dir) {
   if (!existsSync7(dir)) return;
-  for (const name of readdirSync3(dir)) {
-    const p = join7(dir, name);
-    if (statSync2(p).isDirectory()) yield* metaFiles(p);
+  for (const name of readdirSync4(dir)) {
+    const p = join8(dir, name);
+    if (statSync3(p).isDirectory()) yield* metaFiles(p);
     else if (name.endsWith("-meta.md")) yield p;
   }
 }
@@ -3135,11 +3235,11 @@ function libraryInfo(libraryDir, host, withIds, tiers = resolveTiers()) {
     updates: 0
   };
   const ids = [];
-  for (const type of existsSync7(libraryDir) ? readdirSync3(libraryDir) : []) {
-    const typeDir = join7(libraryDir, type);
-    if (!statSync2(typeDir).isDirectory()) continue;
+  for (const type of existsSync7(libraryDir) ? readdirSync4(libraryDir) : []) {
+    const typeDir = join8(libraryDir, type);
+    if (!statSync3(typeDir).isDirectory()) continue;
     for (const meta of metaFiles(typeDir)) {
-      const md = readFileSync6(meta, "utf8");
+      const md = readFileSync7(meta, "utf8");
       const raw = field(md, "level") || "unknown";
       const level = raw === "abstract" && field(md, "has_abstract") === "no" ? "title" : raw;
       info.entries++;
@@ -3149,9 +3249,9 @@ function libraryInfo(libraryDir, host, withIds, tiers = resolveTiers()) {
       t.entries++;
       if (level === "full_text" || level === "abstract" || level === "title") t[level]++;
       const dir = dirname2(meta);
-      for (const f of readdirSync3(dir)) {
+      for (const f of readdirSync4(dir)) {
         try {
-          const st = statSync2(join7(dir, f));
+          const st = statSync3(join8(dir, f));
           if (st.isFile()) info.size_bytes += st.size;
         } catch {
         }
@@ -3180,7 +3280,7 @@ function noticeTypes(md, metaPath) {
     return out;
   }
   try {
-    const xml = readFileSync6(metaPath.replace(/-meta\.md$/, "-abstract.xml"), "utf8");
+    const xml = readFileSync7(metaPath.replace(/-meta\.md$/, "-abstract.xml"), "utf8");
     for (const m of xml.matchAll(/<CommentsCorrections RefType="([A-Za-z]+)"/g)) if (XML_TYPES[m[1]]) out.add(XML_TYPES[m[1]]);
   } catch {
   }
@@ -3329,10 +3429,10 @@ function paragraphs(md, scope) {
     return h;
   };
   const out = [];
-  let para2 = [], paraStart = 0, header = null;
+  let para3 = [], paraStart = 0, header = null;
   const flush = () => {
-    const text3 = para2.join("\n").trim();
-    para2 = [];
+    const text3 = para3.join("\n").trim();
+    para3 = [];
     if (text3) out.push({ section: sectionAt(paraStart), text: text3 });
   };
   for (let i = from; i < to; i++) {
@@ -3353,8 +3453,8 @@ function paragraphs(md, scope) {
       continue;
     }
     header = null;
-    if (!para2.length) paraStart = i;
-    para2.push(l);
+    if (!para3.length) paraStart = i;
+    para3.push(l);
   }
   flush();
   return out;
@@ -3557,15 +3657,567 @@ function parseCsl(json2) {
   };
 }
 
+// src/urlfetch.ts
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync8 } from "fs";
+import { join as join9 } from "path";
+var TRACKING = /^(utm_[a-z]+|fbclid|gclid|dclid|msclkid|mc_cid|mc_eid|igshid|ref_src)$/i;
+function normalizeUrl(raw) {
+  let u;
+  try {
+    u = new URL(raw.trim());
+  } catch {
+    return null;
+  }
+  if (u.protocol !== "http:" && u.protocol !== "https:") return null;
+  u.hash = "";
+  u.hostname = u.hostname.toLowerCase();
+  if ([...u.searchParams.keys()].some((k) => TRACKING.test(k))) {
+    for (const k of [...u.searchParams.keys()]) if (TRACKING.test(k)) u.searchParams.delete(k);
+    if (![...u.searchParams.keys()].length) u.search = "";
+  }
+  return u.toString();
+}
+var urlHash = (normalized2) => createHash2("sha1").update(normalized2).digest("hex").slice(0, 16);
+function urlPaths(libraryDir, normalized2) {
+  const hash = urlHash(normalized2);
+  const entry = `url-${hash}`;
+  const entryDir = join9(libraryDir, "url", hash.slice(0, 2), hash.slice(0, 4), hash);
+  return { hash, entry, entryDir, meta: join9(entryDir, `${entry}-meta.md`), md: join9(entryDir, `${entry}-page.md`), raw: (ext) => join9(entryDir, `${entry}-page.${ext}`) };
+}
+function renderUrlMeta(m) {
+  const lines = [
+    ["url", m.url],
+    ["final_url", m.final_url],
+    ["title", m.title === null ? "" : JSON.stringify(m.title)],
+    ["format", m.format],
+    ["content_type", m.content_type],
+    ["level", m.level],
+    ["retrieved_by", m.retrieved_by],
+    ["fetched", m.fetched],
+    ["error", m.error ?? ""],
+    ["files", m.files.join(", ")],
+    ["converted_by", m.converted_by]
+  ];
+  return lines.map(([k, v]) => `${k}: ${v}`).join("\n") + "\n";
+}
+function readUrlMeta(p) {
+  if (!existsSync8(p.meta)) return null;
+  const md = readFileSync8(p.meta, "utf8");
+  const f = (k) => {
+    const m = new RegExp(`^${k}:[ \\t]*(.*)$`, "m").exec(md);
+    return m ? m[1].trim() : "";
+  };
+  let title = null;
+  try {
+    title = f("title") ? JSON.parse(f("title")) : null;
+  } catch {
+    title = f("title") || null;
+  }
+  return {
+    url: f("url"),
+    final_url: f("final_url"),
+    title,
+    format: f("format") || "failed",
+    content_type: f("content_type"),
+    level: f("level") === "full_text" ? "full_text" : "title",
+    retrieved_by: f("retrieved_by"),
+    fetched: f("fetched"),
+    error: f("error") || null,
+    files: f("files") ? f("files").split(",").map((s) => s.trim()).filter(Boolean) : [],
+    converted_by: f("converted_by")
+  };
+}
+function writeUrlMeta(p, m) {
+  mkdirSync5(p.entryDir, { recursive: true });
+  writeAtomic(p.meta, renderUrlMeta(m));
+}
+var SHELL_WORDS = 100;
+var EMPTY_WORDS = 10;
+var SHELL_PHRASE = /\bloading\b|javascript|enable it|connecting to|please wait|redirecting/i;
+function isScriptShell(markdownOrHtml) {
+  const text3 = markdownOrHtml.replace(/<script[\s\S]*?<\/script>|<style[\s\S]*?<\/style>|<noscript[\s\S]*?<\/noscript>/gi, " ").replace(/<[^>]+>/g, " ").replace(/&[a-z#0-9]+;/gi, " ").replace(/\]\([^)]*\)/g, ")");
+  const words2 = text3.split(/\s+/).filter((w) => /[\p{L}\p{N}]/u.test(w)).length;
+  return { shell: words2 < EMPTY_WORDS || words2 < SHELL_WORDS && SHELL_PHRASE.test(text3), words: words2 };
+}
+var viaName = (via) => typeof via === "object" ? `browser ${via.label}` : via;
+async function rung(url, via) {
+  const name = viaName(via);
+  let got;
+  try {
+    got = via === "brightdata" ? await unlock(url) : typeof via === "object" ? await browserFetch(url, via.browser) : await fetchBytes(url, BROWSER_HEADERS);
+  } catch (e) {
+    return { ok: false, reason: errMsg(e), url: e?.url, via: name };
+  }
+  if (via === "brightdata" && !got.bytes.length) return { ok: false, reason: "empty response", via: name };
+  const r = { ok: true, bytes: got.bytes, contentType: got.contentType, url: got.url ?? url, via: name };
+  if (!looksLikePdf(got.bytes)) {
+    const text3 = got.bytes.toString("utf8");
+    if (isHtml(got.contentType, text3)) {
+      if (isWallPage(text3)) return { ok: false, reason: "wall page", url: r.url, via: name };
+      let md = "";
+      try {
+        md = htmlToMarkdown(/<body[^>]*>([\s\S]*)<\/body>/i.exec(text3)?.[1] ?? text3);
+      } catch {
+      }
+      const s = isScriptShell(md || text3);
+      if (s.shell) return { ok: false, reason: `script shell (${s.words} words)`, url: r.url, via: name, shell: r };
+    }
+  }
+  return r;
+}
+var climb = async (url, onTry, onAlert) => {
+  let r = await rung(url, "fetch");
+  const firstReason = r.ok ? void 0 : r.reason;
+  const target = !r.ok && r.url && r.url !== url ? r.url : url;
+  if (target !== url) onTry?.(`\u2192 ${target}`);
+  onTry?.(r.ok ? "ok fetch" : `failed fetch: ${r.reason}`);
+  const escalates = (g) => !g.ok && (g.via !== "fetch" || /^(HTTP 403|HTTP 429|wall page|script shell)/.test(g.reason));
+  let shell = !r.ok ? r.shell : void 0;
+  for (const b of browserRungs()) {
+    if (!escalates(r)) break;
+    r = await rung(target, { browser: b.endpoint, label: b.label });
+    if (!r.ok && r.shell && !shell) shell = r.shell;
+    onTry?.(r.ok ? `ok browser ${b.label}` : `failed browser ${b.label}: ${r.reason}`);
+    if (!r.ok && r.reason.startsWith(MISMATCH)) onAlert?.(`browser ${b.label}: ${r.reason}`);
+  }
+  if (!r.ok && unlockerConfigured() && (r.via !== "fetch" || /^(HTTP 403|wall page|script shell)/.test(r.reason))) {
+    r = await rung(target, "brightdata");
+    onTry?.(r.ok ? "ok brightdata" : `failed brightdata: ${r.reason}`);
+    if (!r.ok && /^unlocker HTTP/.test(r.reason)) onAlert?.(`brightdata: ${r.reason}`);
+  }
+  if (!r.ok && shell) {
+    onTry?.(`script shell kept: no rung rendered the page`);
+    return shell;
+  }
+  return r.ok || r.via === "fetch" ? r : { ...r, first: firstReason };
+};
+var mediaType = (contentType) => contentType.split(";")[0].trim().toLowerCase();
+function isHtml(contentType, text3) {
+  const ct = contentType.toLowerCase();
+  if (/<html/i.test(text3.slice(0, 100))) return true;
+  if (ct.includes("text/html") || ct.includes("application/xhtml+xml")) return true;
+  return !ct && /^(<!doctype html|<html)/.test(text3.replace(/^\uFEFF/, "").trimStart().slice(0, 20).toLowerCase());
+}
+var ENTITIES = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'", nbsp: " ", ndash: "\u2013", mdash: "\u2014", hellip: "\u2026", copy: "\xA9", reg: "\xAE", trade: "\u2122" };
+var decode2 = (s) => s.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (m, e) => {
+  if (e[0] === "#") {
+    const n = e[1].toLowerCase() === "x" ? parseInt(e.slice(2), 16) : parseInt(e.slice(1), 10);
+    return Number.isFinite(n) ? String.fromCodePoint(n) : m;
+  }
+  return ENTITIES[e.toLowerCase()] ?? m;
+});
+var visibleText = (html) => decode2(html.replace(/<[^>]+>/g, " ")).replace(/\s+/g, " ").replace(/¶\s*$/, "").trim();
+var normalized = (text3) => {
+  const words2 = text3.toLowerCase().match(/[\p{L}\p{N}]+/gu);
+  return words2 ? ` ${words2.join(" ")} ` : "";
+};
+function pageTitle(html) {
+  const head = html.slice(0, 2e5);
+  const og = /<meta\b[^>]*\bproperty\s*=\s*["']og:title["'][^>]*>/i.exec(head)?.[0] ?? /<meta\b[^>]*\bcontent\s*=\s*["'][^"']*["'][^>]*\bproperty\s*=\s*["']og:title["'][^>]*>/i.exec(head)?.[0];
+  const ogTitle = og ? visibleText(/\bcontent\s*=\s*("([^"]*)"|'([^']*)')/i.exec(og)?.[2] ?? /\bcontent\s*=\s*'([^']*)'/i.exec(og)?.[1] ?? "") : "";
+  const title = visibleText(/<title[^>]*>([\s\S]*?)<\/title>/i.exec(head)?.[1] ?? "");
+  const h1 = visibleText(/<h1\b[^>]*>([\s\S]*?)<\/h1>/i.exec(html)?.[1] ?? "");
+  const headingInTitle = !!normalized(h1) && normalized(title).includes(normalized(h1));
+  if (ogTitle) return ogTitle;
+  if (headingInTitle) return h1;
+  return title || h1 || null;
+}
+var visibleLine = (line) => line.replace(/\]\([^)]*\)/g, " ").replace(/<[a-zA-Z/!?][^>]*>/g, " ");
+function opensWithTitle(content, title) {
+  const first = content.split("\n").find((l) => l.trim()) ?? "";
+  const line = normalized(visibleLine(first)), wanted = normalized(title);
+  if (!line || !wanted) return false;
+  if (line.includes(wanted)) return true;
+  return first.trimStart().startsWith("#") && wanted.includes(line);
+}
+function withPageTitle(html, content) {
+  if (content.startsWith("<error>")) return content;
+  const title = pageTitle(html);
+  if (title === null || opensWithTitle(content, title)) return content;
+  return `# ${title.replace(/([\\`*_\[\]<>#&|~])/g, "\\$1")}
+
+${content.trimStart()}`;
+}
+var SIMPLIFY_FAILED = "<error>Page failed to be simplified from HTML</error>";
+async function convert(bytes, contentType) {
+  if (looksLikePdf(bytes)) {
+    const md = (await pdfToMarkdown(bytes, "", "")).replace(/^# \n\n/, "");
+    return { format: "pdf", md, title: null, ext: "pdf" };
+  }
+  const text3 = bytes.toString("utf8");
+  if (mediaType(contentType) === "text/markdown") return { format: "markdown", md: text3, title: null, ext: "md" };
+  if (isHtml(contentType, text3)) {
+    const body = /<body[^>]*>([\s\S]*)<\/body>/i.exec(text3)?.[1] ?? text3;
+    let md;
+    try {
+      md = htmlToMarkdown(body);
+    } catch {
+      md = "";
+    }
+    md = md.trim() ? withPageTitle(text3, md) : SIMPLIFY_FAILED;
+    return { format: "html", md, title: pageTitle(text3), ext: "html" };
+  }
+  return { format: "text", md: null, title: null, ext: "txt" };
+}
+function fetchAnswer(url, body, prefix, maxLength, startIndex) {
+  const original = body.length;
+  let content;
+  if (startIndex >= original) content = "<error>No more content available.</error>";
+  else {
+    const cut = body.slice(startIndex, startIndex + maxLength);
+    content = cut;
+    const remaining = original - (startIndex + cut.length);
+    if (cut.length === maxLength && remaining > 0) content += `
+
+<error>Content truncated. Call the fetch tool with a start_index of ${startIndex + cut.length} to get more content.</error>`;
+  }
+  return `${prefix}Contents of ${url}:
+${content}`;
+}
+var ID_WIDTH = 13;
+function logId(url) {
+  const bare2 = url.replace(/^https?:\/\//i, "");
+  return bare2.length > ID_WIDTH ? bare2.slice(0, ID_WIDTH - 1) + "\u2026" : bare2;
+}
+var failureText = (url, reason) => {
+  const m = /^HTTP (\d{3})\b/.exec(reason);
+  return m ? `Failed to fetch ${url} - status code ${m[1]}` : `Failed to fetch ${url}: ${reason}`;
+};
+function titleLine(m, md) {
+  if (m.title) return `# ${m.title}`;
+  const first = md.split("\n").find((l) => l.trim());
+  if (first) return first.trim();
+  return `(${m.content_type || "no content type"}, no title)`;
+}
+function serve(requested, p, m, args, cached) {
+  const maxLength = args.max_length ?? 5e3, startIndex = args.start_index ?? 0;
+  const read = (file2) => existsSync8(file2) ? readFileSync8(file2, "utf8") : "";
+  if (args.title_only) return { ok: true, text: `Contents of ${requested}:
+${titleLine(m, read(p.md))}`, cached, meta: m };
+  const rawFile = m.files.find((f) => !f.endsWith("-meta.md") && !f.endsWith("-page.md"));
+  let body, prefix = "";
+  if (m.format === "markdown") body = read(p.md);
+  else if (m.format === "text" || args.raw) {
+    body = rawFile ? read(join9(p.entryDir, rawFile)) : read(p.md);
+    prefix = `Content type ${m.content_type || "(not declared)"} cannot be simplified to markdown, but here is the raw content:
+`;
+  } else body = read(p.md);
+  return { ok: true, text: fetchAnswer(requested, body, prefix, maxLength, startIndex), cached, meta: m };
+}
+var inflight = /* @__PURE__ */ new Map();
+async function libraryFetch(libraryDir, requested, args, converter, logs = {}, fetchImpl = climb) {
+  const url = normalizeUrl(requested);
+  if (!url) return { ok: false, error: `Failed to fetch ${requested}: invalid URL`, cached: false, meta: null };
+  const p = urlPaths(libraryDir, url);
+  const s = settings();
+  const fresh = (m2) => daysSince(m2.fetched) < (m2.format === "failed" ? s.retry_after_days : s.refresh_after_days);
+  const answer = (m2, cached) => m2.format === "failed" ? { ok: false, error: failureText(requested, m2.error ?? "unknown error"), cached, meta: m2 } : serve(requested, p, m2, args, cached);
+  const stored = readUrlMeta(p);
+  if (stored && fresh(stored)) return answer(stored, true);
+  let run = inflight.get(p.hash);
+  if (!run) {
+    run = (async () => {
+      const r = await fetchImpl(url, logs.onTry, logs.onAlert);
+      const base = { url, fetched: today(), converted_by: converter };
+      if (!r.ok) {
+        const error = r.first && /^HTTP \d{3}/.test(r.first) ? r.first : r.reason;
+        writeUrlMeta(p, { ...base, final_url: r.url ?? url, title: null, format: "failed", content_type: "", level: "title", retrieved_by: r.via, error, files: [`${p.entry}-meta.md`] });
+        return;
+      }
+      const page = await convert(r.bytes, r.contentType);
+      mkdirSync5(p.entryDir, { recursive: true });
+      const files = [`${p.entry}-meta.md`];
+      if (page.md !== null) {
+        writeAtomic(p.md, page.md);
+        files.push(`${p.entry}-page.md`);
+      }
+      if (page.ext !== "md") {
+        writeAtomic(p.raw(page.ext), r.bytes);
+        files.push(`${p.entry}-page.${page.ext}`);
+      }
+      writeUrlMeta(p, { ...base, final_url: r.url, title: page.title, format: page.format, content_type: mediaType(r.contentType), level: "full_text", retrieved_by: r.via, error: null, files });
+    })().finally(() => inflight.delete(p.hash));
+    inflight.set(p.hash, run);
+  }
+  await run;
+  const m = readUrlMeta(p);
+  if (!m) return { ok: false, error: `Failed to fetch ${requested}: nothing stored`, cached: false, meta: null };
+  return answer(m, false);
+}
+
+// src/verifycache.ts
+import { createHash as createHash3 } from "crypto";
+import { existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync9 } from "fs";
+import { dirname as dirname3, join as join10 } from "path";
+var sha = (s) => createHash3("sha1").update(s).digest("hex");
+var normalizeClaim = (claim) => claim.replace(/\s+/g, " ").trim();
+function foldClaim(claim) {
+  return claim.normalize("NFKC").toLowerCase().replace(/[\u2018\u2019\u201a\u201b\u2032]/g, "'").replace(/[\u201c\u201d\u201e\u201f\u2033]/g, '"').replace(/[\u2010-\u2015\u2212]/g, "-").replace(/\+\/-|\+-/g, "\xB1").replace(/\s+/g, " ").trim().replace(/[.;:,]+$/, "").trim();
+}
+var textHash = (text3) => sha(text3).slice(0, 16);
+var cacheKey = (claim, id, model, threshold, text3) => sha(`${foldClaim(claim)}
+${id}
+${model}
+${threshold}
+${text3}`).slice(0, 16);
+var verdictFile = (libraryDir, key) => join10(libraryDir, "verify", key.slice(0, 2), key.slice(0, 4), `${key}.json`);
+function readVerdict(file2) {
+  if (!existsSync9(file2)) return null;
+  try {
+    return JSON.parse(readFileSync9(file2, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function lookup(file2, maxDays) {
+  const c = readVerdict(file2);
+  return c && daysSince(c.date) < maxDays ? c : null;
+}
+function remember(file2, c) {
+  mkdirSync6(dirname3(file2), { recursive: true });
+  writeAtomic(file2, JSON.stringify(c, null, 2) + "\n");
+}
+async function verifyCached(claim, id, cfg, decide, libraryDir = FH_LIBRARY_DIR, read = readPaper) {
+  const paper = await read(id, libraryDir);
+  const once = () => paper;
+  if ("error" in paper || !cfg) return { ...await verifyClaim(claim, id, cfg, decide, once), cached: false };
+  const text3 = textHash(paper.text);
+  const file2 = verdictFile(libraryDir, cacheKey(claim, paper.id, cfg.model, cfg.threshold, text3));
+  const hit = lookup(file2, settings().refresh_after_days);
+  if (hit) {
+    return { claim, id: paper.id, verdict: hit.verdict, reason: hit.reason, score: hit.score, basis: hit.basis, windows: hit.windows, glyphs_unresolved: hit.glyphs_unresolved, superseded: hit.superseded, model: hit.model, cached: true };
+  }
+  const r = await verifyClaim(claim, id, cfg, decide, once);
+  if (!r.error && r.score !== null) {
+    remember(file2, { key: file2.slice(-21, -5), id: paper.id, claim: normalizeClaim(claim), model: cfg.model, threshold: cfg.threshold, text: text3, date: today(), verdict: r.verdict, reason: r.reason, score: r.score, basis: r.basis, windows: r.windows, glyphs_unresolved: r.glyphs_unresolved, superseded: r.superseded });
+  }
+  return { ...r, cached: false };
+}
+
+// src/json.ts
+var DROP = /* @__PURE__ */ new Set(["entry_dir", "library_dir", "files"]);
+var compact2 = (o) => JSON.stringify(o);
+function lean(o) {
+  if (Array.isArray(o)) return o.map((row2) => row2 && typeof row2 === "object" && !Array.isArray(row2) ? leanObject(row2) : row2);
+  if (o && typeof o === "object") return leanObject(o);
+  return o;
+}
+function leanObject(o) {
+  const out = {};
+  for (const [k, v] of Object.entries(o)) {
+    if (DROP.has(k) || v === null || v === void 0 || Array.isArray(v) && v.length === 0) continue;
+    out[k] = Array.isArray(v) ? lean(v) : v;
+  }
+  return out;
+}
+var leanJson = (o) => compact2(lean(o));
+
+// src/trials.ts
+import { createHash as createHash4 } from "crypto";
+import { existsSync as existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync10 } from "fs";
+import { dirname as dirname4, join as join11 } from "path";
+var SEARCH_AFTER_DAYS = 7;
+var API2 = "https://clinicaltrials.gov/api/v2/studies";
+var FIELDS = ["NCTId", "BriefTitle", "OverallStatus", "WhyStopped", "Phase", "StudyType", "EnrollmentCount", "EnrollmentType", "StartDate", "PrimaryCompletionDate", "CompletionDate", "LastUpdatePostDate", "PrimaryOutcomeMeasure", "PrimaryOutcomeTimeFrame", "Condition", "InterventionName", "LeadSponsorName", "HasResults"];
+var ONGOING = ["RECRUITING", "NOT_YET_RECRUITING", "ACTIVE_NOT_RECRUITING", "ENROLLING_BY_INVITATION"];
+var MAX_RESULTS = 100;
+var DEFAULT_RESULTS = 20;
+var SORTS = { relevance: null, newest: "LastUpdatePostDate:desc", largest: "EnrollmentCount:desc", completion: "CompletionDate:desc" };
+var COLUMNS = [
+  "nct",
+  "title",
+  "status",
+  // "Terminated — slow accrual": a trial past its completion date is not "ongoing" (ER.md 28.7)
+  "phase",
+  "enrollment",
+  // "100 (estimated)" / "48 (actual)" — participant count (28.5)
+  "start",
+  "primary_completion",
+  "primary_outcome",
+  // the first primary outcome with its time frame, cut at 80 characters — the primary endpoint (28.5)
+  "conditions",
+  "interventions",
+  // "IVF; Infertility, Female" — one string each
+  "has_results"
+  // posted results: get_study_results (28.8)
+];
+var clean = (s) => (s ?? "").replace(/\s+/g, " ").trim();
+function normalizeQuery(q) {
+  const out = { status: q.status ?? "all", sort: q.sort ?? "relevance", max_results: Math.min(MAX_RESULTS, Math.max(1, Math.floor(q.max_results ?? DEFAULT_RESULTS))) };
+  if (clean(q.query)) out.query = clean(q.query);
+  if (clean(q.intervention)) out.intervention = clean(q.intervention);
+  if (clean(q.condition)) out.condition = clean(q.condition);
+  if (!out.query && !out.intervention && !out.condition) return { error: "empty search: give query, intervention or condition" };
+  if (!["ongoing", "completed", "all"].includes(out.status)) return { error: `status must be ongoing, completed or all, not "${String(q.status)}"` };
+  if (!(out.sort in SORTS)) return { error: `sort must be relevance, newest, largest or completion, not "${String(q.sort)}"` };
+  return out;
+}
+var searchKey = (q) => createHash4("sha1").update(JSON.stringify(["clinicaltrials", q.query ?? "", q.intervention ?? "", q.condition ?? "", q.status, q.sort, q.max_results])).digest("hex").slice(0, 16);
+var searchFile = (libraryDir, key) => join11(libraryDir, "search", key.slice(0, 2), key.slice(0, 4), `${key}.json`);
+function searchUrl(q) {
+  const p = new URLSearchParams();
+  if (q.query) p.set("query.term", q.query);
+  if (q.intervention) p.set("query.intr", q.intervention);
+  if (q.condition) p.set("query.cond", q.condition);
+  if (q.status === "ongoing") p.set("filter.overallStatus", ONGOING.join(","));
+  if (q.status === "completed") p.set("filter.overallStatus", "COMPLETED");
+  if (SORTS[q.sort]) p.set("sort", SORTS[q.sort]);
+  p.set("fields", FIELDS.join(","));
+  p.set("pageSize", String(q.max_results));
+  p.set("countTotal", "true");
+  return `${API2}?${p.toString()}`;
+}
+var STATUS2 = { NOT_YET_RECRUITING: "Not yet recruiting", RECRUITING: "Recruiting", ENROLLING_BY_INVITATION: "Enrolling by invitation", ACTIVE_NOT_RECRUITING: "Active, not recruiting", SUSPENDED: "Suspended", TERMINATED: "Terminated", COMPLETED: "Completed", WITHDRAWN: "Withdrawn", UNKNOWN: "Unknown status", AVAILABLE: "Available", NO_LONGER_AVAILABLE: "No longer available", TEMPORARILY_NOT_AVAILABLE: "Temporarily not available", APPROVED_FOR_MARKETING: "Approved for marketing", WITHHELD: "Withheld" };
+var PHASE2 = { EARLY_PHASE1: "Early Phase 1", PHASE1: "Phase 1", PHASE2: "Phase 2", PHASE3: "Phase 3", PHASE4: "Phase 4", NA: "Not applicable" };
+var joined = (xs) => xs.length ? xs.map((x) => x.replace(/\s+/g, " ").trim()).filter(Boolean).join("; ") || null : null;
+function parseRows(json2) {
+  const d = JSON.parse(json2);
+  const rows = [];
+  for (const s of Array.isArray(d.studies) ? d.studies : []) {
+    const p = s.protocolSection ?? {};
+    const id = p.identificationModule ?? {}, st = p.statusModule ?? {}, des = p.designModule ?? {};
+    const phases = Array.isArray(des.phases) ? des.phases : [];
+    const nct = String(id.nctId ?? "");
+    const en = des.enrollmentInfo ?? {};
+    const outcomes = Array.isArray(p.outcomesModule?.primaryOutcomes) ? p.outcomesModule.primaryOutcomes : [];
+    const first = outcomes[0];
+    const cut = (t, n) => t.length > n ? t.slice(0, n - 1).trimEnd() + "\u2026" : t;
+    const primary = first?.measure ? cut(`${String(first.measure).replace(/\s+/g, " ").trim()}${first.timeFrame ? ` (${String(first.timeFrame).replace(/\s+/g, " ").trim()})` : ""}`, 80) + (outcomes.length > 1 ? ` +${outcomes.length - 1}` : "") : null;
+    const status = (STATUS2[st.overallStatus] ?? String(st.overallStatus ?? "")) + (st.whyStopped ? ` \u2014 ${String(st.whyStopped).replace(/\s+/g, " ").trim()}` : "");
+    rows.push([
+      nct,
+      String(id.briefTitle ?? ""),
+      status,
+      phases.length ? phases.map((x) => PHASE2[x] ?? x).join(" / ") : null,
+      typeof en.count === "number" ? `${en.count}${en.type ? ` (${String(en.type).toLowerCase()})` : ""}` : null,
+      st.startDateStruct?.date ?? null,
+      st.primaryCompletionDateStruct?.date ?? null,
+      primary,
+      joined(Array.isArray(p.conditionsModule?.conditions) ? p.conditionsModule.conditions.map(String) : []),
+      joined(Array.isArray(p.armsInterventionsModule?.interventions) ? p.armsInterventionsModule.interventions.map((i) => String(i?.name ?? "")).filter(Boolean) : []),
+      s.hasResults === true
+    ]);
+  }
+  return { total: typeof d.totalCount === "number" ? d.totalCount : rows.length, rows };
+}
+var liveFetch = (url) => fetchText(url, { "User-Agent": LIBRARY_UA, Accept: "application/json" });
+async function searchTrials(raw, libraryDir = FH_LIBRARY_DIR, fetchImpl = liveFetch) {
+  const q = normalizeQuery(raw);
+  if ("error" in q) return { ok: false, error: q.error };
+  const file2 = searchFile(libraryDir, searchKey(q));
+  if (existsSync10(file2)) {
+    try {
+      const r = JSON.parse(readFileSync10(file2, "utf8"));
+      if (daysSince(r.searched) < SEARCH_AFTER_DAYS) return { ok: true, result: r, cached: true };
+    } catch {
+    }
+  }
+  let json2;
+  try {
+    json2 = await fetchImpl(searchUrl(q));
+  } catch (e) {
+    return { ok: false, error: `clinicaltrials.gov: ${e instanceof Error ? e.message : String(e)}` };
+  }
+  let parsed;
+  try {
+    parsed = parseRows(json2);
+  } catch {
+    return { ok: false, error: "clinicaltrials.gov: not a studies answer" };
+  }
+  const result = { source: "clinicaltrials", query: q, total: parsed.total, columns: COLUMNS, rows: parsed.rows, searched: today() };
+  try {
+    mkdirSync7(dirname4(file2), { recursive: true });
+    writeAtomic(file2, JSON.stringify(result, null, 2) + "\n");
+  } catch {
+  }
+  return { ok: true, result, cached: false };
+}
+function trialsLogId(q) {
+  const s = (q.intervention ?? q.condition ?? q.query ?? "").replace(/\s+/g, " ");
+  return s.length > 10 ? s.slice(0, 9) + "\u2026" : s || "-";
+}
+
+// src/trialrecord.ts
+var list3 = (a) => Array.isArray(a) ? a : [];
+var para2 = (s, max = Infinity) => {
+  const t = String(s ?? "").replace(/\s+/g, " ").trim();
+  if (!t) return null;
+  return t.length > max ? t.slice(0, max - 1).trimEnd() + "\u2026" : t;
+};
+var joined2 = (xs) => {
+  const ys = xs.filter((x) => !!x);
+  return ys.length ? ys.join("; ") : null;
+};
+var dated2 = (d) => d?.date ? `${d.date}${d.type ? ` (${String(d.type).toLowerCase()})` : ""}` : null;
+function recordSummary(json2) {
+  let d;
+  try {
+    d = JSON.parse(json2);
+  } catch {
+    return null;
+  }
+  const ps = d?.protocolSection;
+  if (!ps) return null;
+  const idm = ps.identificationModule ?? {}, st = ps.statusModule ?? {}, sp = ps.sponsorCollaboratorsModule ?? {}, de = ps.descriptionModule ?? {};
+  const dm = ps.designModule ?? {}, ai = ps.armsInterventionsModule ?? {}, om = ps.outcomesModule ?? {}, el = ps.eligibilityModule ?? {}, cl = ps.contactsLocationsModule ?? {}, rf = ps.referencesModule ?? {};
+  const nct = String(idm.nctId ?? "").toUpperCase();
+  const title = para2(idm.briefTitle) ?? nct;
+  const official = para2(idm.officialTitle);
+  const di = dm.designInfo ?? {}, mi = di.maskingInfo ?? {};
+  const design = joined2([di.allocation ? words(di.allocation) : null, di.interventionModel ? words(di.interventionModel) : null, mi.masking ? `masking ${words(mi.masking).toLowerCase()}` : null, di.primaryPurpose ? `purpose ${words(di.primaryPurpose).toLowerCase()}` : null]);
+  const outcome = (o) => `${para2(o.measure) ?? ""}${o.timeFrame ? ` (${para2(o.timeFrame)})` : ""}`.trim();
+  const countries = [...new Set(list3(cl.locations).map((l) => l.country).filter(Boolean))];
+  const refs = list3(rf.references);
+  const age = el.minimumAge || el.maximumAge ? `${el.minimumAge ?? "no minimum"} to ${el.maximumAge ?? "no maximum"}` : null;
+  return {
+    nct,
+    title,
+    official_title: official && official !== title ? official : null,
+    acronym: para2(idm.acronym),
+    status: st.overallStatus ? words(st.overallStatus) : null,
+    why_stopped: para2(st.whyStopped),
+    phase: list3(dm.phases).length ? list3(dm.phases).map(words).join(" / ") : null,
+    study_type: dm.studyType ? words(dm.studyType) : null,
+    design,
+    enrollment: dm.enrollmentInfo?.count !== void 0 ? `${dm.enrollmentInfo.count}${dm.enrollmentInfo.type ? ` (${String(dm.enrollmentInfo.type).toLowerCase()})` : ""}` : null,
+    start: dated2(st.startDateStruct),
+    primary_completion: dated2(st.primaryCompletionDateStruct),
+    completion: dated2(st.completionDateStruct),
+    first_posted: st.studyFirstPostDateStruct?.date ?? null,
+    last_update: st.lastUpdatePostDateStruct?.date ?? null,
+    results_first_posted: st.resultsFirstPostDateStruct?.date ?? null,
+    sponsor: para2(sp.leadSponsor?.name),
+    collaborators: joined2(list3(sp.collaborators).map((c) => para2(c.name))),
+    conditions: joined2(list3(ps.conditionsModule?.conditions).map((c) => para2(c))),
+    interventions: joined2(list3(ai.interventions).map((i) => para2(`${i.type ? `${words(i.type)}: ` : ""}${i.name ?? ""}`))),
+    primary_outcomes: list3(om.primaryOutcomes).map(outcome).filter(Boolean),
+    secondary_outcomes: list3(om.secondaryOutcomes).length,
+    eligibility: joined2([el.sex ? `sex ${words(el.sex).toLowerCase()}` : null, age ? `age ${age}` : null, el.healthyVolunteers !== void 0 ? `healthy volunteers ${el.healthyVolunteers ? "yes" : "no"}` : null]),
+    locations: countries.length ? `${list3(cl.locations).length} site${list3(cl.locations).length === 1 ? "" : "s"} in ${countries.join(", ")}` : null,
+    publications: refs.filter((r) => r.pmid && ["RESULT", "DERIVED"].includes(String(r.type))).map((r) => `pmid:${r.pmid}`),
+    has_results: d.hasResults === true,
+    summary: para2(de.briefSummary, 400)
+  };
+}
+function resultsText(nct, md, maxChars) {
+  const i = md.search(/^## Results\s*$/m);
+  if (i < 0) return { nct, has_results: false, text: null, truncated: false, outcomes: [], note: "no posted results in the registry record" };
+  const part = md.slice(i).replace(/^## Results\s*\n/, "").trim();
+  const outcomes = [...part.matchAll(/^#### (.+)$/gm)].map((m) => m[1].trim());
+  const truncated = part.length > maxChars;
+  return { nct, has_results: true, text: truncated ? part.slice(0, maxChars).trimEnd() + "\n\n[truncated]" : part, truncated, outcomes, note: truncated ? "cut at max_chars; library_read(id, section: <an outcome title>) returns one measure whole" : null };
+}
+
 // src/tools.ts
 var pkg = (() => {
   try {
-    return JSON.parse(readFileSync7(new URL("../package.json", import.meta.url), "utf8"));
+    return JSON.parse(readFileSync11(new URL("../package.json", import.meta.url), "utf8"));
   } catch {
     return { name: "fh-library", version: "0.0.0" };
   }
 })();
-var INSTRUCTIONS = `fh-library keeps a local library of scientific papers, FDA drug labels and clinical trial records, so you can check what a source actually says. The server downloads each record, converts it to Markdown and stores it on disk. Every tool returns a small JSON answer; the document itself never enters your context. One ID per call.
+var INSTRUCTIONS = `fh-library keeps a local library of scientific papers, FDA drug labels, clinical trial records and web pages, so you can check what a source actually says, and searches ClinicalTrials.gov. The server downloads each record, converts it to Markdown and stores it on disk. Every tool returns a small JSON answer; the document itself never enters your context \u2014 except library_fetch, which is the standard fetch tool with a cache. One ID per call.
 
 IDs \u2014 always "type:value"
 - pmid:30955454 \u2014 a paper by PubMed ID. Bare digits are taken as a PMID.
@@ -3575,11 +4227,15 @@ IDs \u2014 always "type:value"
 
 Tools
 - library_version() \u2014 package name, version, library directory.
-- library_info(ids?) \u2014 the whole library: entry counts by type and level, the retrieval sources, browsers, the decision model, the configuration. ids=true lists every entry.
+- library_info(ids?) \u2014 the whole library: entry counts by type and level, the retrieval sources, browsers, the decision model, the configuration, this server's cache hits and misses since it started (cache). ids=true lists every entry.
 - library_add(id) \u2014 download and store one record; returns its status. A stored full text is returned without any download; an abstract-level record retries only the sources that failed transiently; a record older than 30 days gets its correction notices re-read.
 - library_status(id) \u2014 the status of one record without downloading; level "missing" when it is not stored.
 - library_read(id, section?, query?, max_chars?, max_hits?) \u2014 one small piece of a stored document: its outline, one section, or the passages matching a query.
 - library_verify(claim, id) \u2014 does this one source state this one finding? A decision model judges the stored text and returns a verdict.
+- library_clinicaltrials_search_studies(query | intervention | condition, status?, sort?, max_results?) \u2014 search ClinicalTrials.gov: the total and rows in columns order (NCT ID, title, status, phase, enrollment, dates, primary outcome, conditions, interventions, has_results). Cached a week.
+- library_clinicaltrials_get_study_record(nct) \u2014 one trial as a review needs it (status, design, enrollment, dates, outcomes, eligibility, result publications, summary), from the stored record; added first when missing.
+- library_clinicaltrials_get_study_results(nct, max_chars?) \u2014 a trial's posted results as Markdown, capped; the outcome titles listed for library_read.
+- library_fetch(url, max_length?, start_index?, raw?, title_only?) \u2014 a web page as Markdown, same call and same answer as the standard fetch tool ("Contents of <url>:" and the page, cut at max_length with a note on how to continue). Prefer it for every URL: a cached page answers from disk, a walled or script-rendered page climbs the browser and unlocker ladder in one call. PDFs as Markdown. title_only returns the title line alone \u2014 enough to verify a link, at a few tokens.
 
 Hints
 - library_read and library_verify store a missing record themselves; the library_read answer then carries added: true. No library_add necessary first.
@@ -3587,6 +4243,8 @@ Hints
 - level \u2014 what is stored: "full_text", "abstract" (no full text could be found; attempts names each source tried and why it failed) or "title" (not even an abstract; citable false).
 - error "pmid not found" or "invalid id" \u2014 the ID itself is wrong; the same call gives the same answer.
 - Calls may run in parallel: library_add, library_read and library_verify. Two calls on the same missing record share one add.
+- library_fetch takes any URL that is not a paper, label or trial record; those have IDs, and library_add, library_read and library_verify work on the stored document. A second pass over the same review reads every page from disk; a failed fetch is remembered for a day.
+- To verify that a web page exists and what it is: library_fetch(url, title_only: true). The answer is "Contents of <url>:" and the page's title line \u2014 a few tokens \u2014 or the fetch error; the page itself is stored in full, so a later library_fetch of the same URL reads from disk.
 
 Verifying a claim
 - library_verify judges one claim against one stored document. A finding backed by three papers takes three calls with the same claim.
@@ -3598,6 +4256,7 @@ Verifying a claim
 - verdict "unverifiable" \u2014 only the abstract is stored and it does not state the claim; the full text may (reason says so). A retry gives the same answer until a full text is stored.
 - glyphs_unresolved above 0 \u2014 the PDF font lost symbols (minus, \xB1, \u2264); a fail on a number may be the font. library_read shows the passage.
 - superseded true \u2014 a published correction replaced the figure the claim uses; the status's corrections holds the notice.
+- Verdicts are kept for 30 days: the same claim against the same stored text answers from disk, no model call. A paper that gains its full text is judged afresh.
 
 Reading a document
 - library_read with only the ID returns the outline: every heading with its word count, and whether the full text or only the abstract is stored.
@@ -3608,12 +4267,12 @@ Reading a document
 - section and query together search inside that section only.
 - section "Abstract" on a full text without one returns the stored abstract. section "Declarations" returns funding, conflicts of interest, acknowledgements and ethics statements, assembled when the document has no section of that name.
 
-Status fields: requested, type, id, entry, entry_dir, library_dir, pmid, pmcid, doi, setid, nctid, publications, title, first_author, year, publication_types, retracted, corrections, coi (conflict-of-interest statement), funding, citable, comment, has_abstract, level, version, retrieved_by, retrieved_date, pubmed_checked, attempts, files, glyphs_unresolved, error.
+Status fields: requested, type, id, entry, pmid, pmcid, doi, setid, nctid, publications, title, first_author, year, publication_types, retracted, corrections, coi (conflict-of-interest statement), funding, citable, comment, has_abstract, level, version, retrieved_by, retrieved_date, pubmed_checked, attempts, glyphs_unresolved, error. Answers are compact JSON; a field that is null or an empty list is left out (library_verify keeps its nulls: score and reason null mean something).
 
 Where records come from: PubMed for the record and abstract; the full text from a file you drop into <library>/inbox/ (PMID in the file name), PubMed Central, Europe PMC, publishers' text-mining links, Unpaywall, OpenAlex, CORE, and a proxy URL template from the configuration. Every action is appended as one line to <library>/library.log.`;
 var idSchema = z.string().describe('ID as "type:value": a paper "pmid:30955454" (bare digits count as pmid) or "doi:10.5812/asjsm.110753" (a paper PubMed does not index; a DOI PubMed indexes is taken as its PMID), a drug label "dailymed:<set ID>" (the set ID from its DailyMed page URL), or a trial record "nct:05173896" (the eight digits; nct:NCT05173896 and a bare NCT05173896 are accepted).');
 var levelWord = (m) => m.level === "abstract" && !m.has_abstract ? "title" : m.level;
-var json = (s) => ({ content: [{ type: "text", text: JSON.stringify(s, null, 2) }] });
+var json = (s) => ({ content: [{ type: "text", text: leanJson(s) }] });
 function noticeTag(m) {
   const n = (t) => m.corrections.filter((c) => c.type === t).length;
   const parts = [
@@ -3737,13 +4396,13 @@ function registerTools(server2) {
     { id: idSchema },
     ({ id }) => addEntry(id)
   );
-  const inflight = /* @__PURE__ */ new Map();
+  const inflight2 = /* @__PURE__ */ new Map();
   function addEntry(id) {
     const key = parseId(id).requested;
-    let p = inflight.get(key);
+    let p = inflight2.get(key);
     if (!p) {
-      p = addEntryNow(id).finally(() => inflight.delete(key));
-      inflight.set(key, p);
+      p = addEntryNow(id).finally(() => inflight2.delete(key));
+      inflight2.set(key, p);
     }
     return p;
   }
@@ -3914,7 +4573,7 @@ function registerTools(server2) {
     },
     async ({ id, section: section2, query, max_chars, max_hits }) => {
       const parsed = parseId(id);
-      const out = (o2) => ({ content: [{ type: "text", text: JSON.stringify(o2, null, 2) }] });
+      const out = (o2) => ({ content: [{ type: "text", text: leanJson(o2) }] });
       if (parsed.error) {
         log("library_read", parsed.requested, `error ${parsed.error}`);
         return out({ requested: parsed.requested, error: parsed.error });
@@ -3930,8 +4589,8 @@ function registerTools(server2) {
         }
         added = true;
       }
-      const full = existsSync8(paths.fulltextMd);
-      const md = readFileSync7(full ? paths.fulltextMd : paths.md, "utf8");
+      const full = existsSync11(paths.fulltextMd);
+      const md = readFileSync11(full ? paths.fulltextMd : paths.md, "utf8");
       const text3 = full ? "full_text" : "abstract";
       const base = added ? { requested: parsed.requested, entry: paths.entry, text: text3, added: true } : { requested: parsed.requested, entry: paths.entry, text: text3 };
       const headings2 = () => outline(md, text3).sections;
@@ -3951,8 +4610,8 @@ function registerTools(server2) {
         const cap = max_chars ?? 6e3;
         let sec = readSection(md, section2, cap);
         let via = "";
-        if (!sec && /abstract/i.test(section2) && full && existsSync8(paths.md)) {
-          sec = readSection(readFileSync7(paths.md, "utf8"), "abstract", cap);
+        if (!sec && /abstract/i.test(section2) && full && existsSync11(paths.md)) {
+          sec = readSection(readFileSync11(paths.md, "utf8"), "abstract", cap);
           via = " (from the abstract file)";
         }
         if (!sec && /declaration/i.test(section2)) {
@@ -3996,15 +4655,16 @@ function registerTools(server2) {
         log("library_verify", pid.requested, "missing adding first");
         await addEntry(id);
       }
-      const r = await verifyClaim(claim, id, cfg, cfg ? decider(cfg) : null);
+      const { cached, ...r } = await verifyCached(claim, id, cfg, cfg ? decider(cfg) : null, FH_LIBRARY_DIR);
+      if (!r.error && r.score !== null) bump("verify", cached);
       const secs = `${((Date.now() - t0) / 1e3).toFixed(1).padStart(4, "0")}s`;
-      log("library_verify", r.id, r.error ? `${modelFailure(r.error, cfg) ? "!! " : ""}${secs} verdict=${"error".padEnd(12)} ${r.error} | ${claim}` : `${secs} verdict=${r.verdict.padEnd(12)} basis=${r.basis.padEnd(9)} score=${r.score === null ? "-    " : r.score.toFixed(3)}${r.windows > 1 ? ` windows=${r.windows}` : ""}${r.superseded ? " superseded" : ""}${r.glyphs_unresolved ? ` glyphs=${r.glyphs_unresolved}` : ""} | ${claim}`);
-      return { content: [{ type: "text", text: JSON.stringify(r, null, 2) }] };
+      log("library_verify", r.id, r.error ? `${modelFailure(r.error, cfg) ? "!! " : ""}${secs} verdict=${"error".padEnd(12)} ${r.error} | ${claim}` : `${secs} verdict=${r.verdict.padEnd(12)} basis=${r.basis.padEnd(9)} score=${r.score === null ? "-    " : r.score.toFixed(3)}${r.windows > 1 ? ` windows=${r.windows}` : ""}${r.superseded ? " superseded" : ""}${r.glyphs_unresolved ? ` glyphs=${r.glyphs_unresolved}` : ""}${cached ? " cached" : ""} | ${claim}`);
+      return { content: [{ type: "text", text: compact2(r) }] };
     }
   );
   server2.tool(
     "library_info",
-    "The whole library as JSON: library directory and host; entry count and size on disk; per type (pmid, doi, dailymed, nct) the entries by level (full_text, abstract, title) and retractions; counts of retracted and not-citable entries and of errata, expressions of concern and updates; the retrieval sources in run order and which are off (tiers); the download ladder (download): the Playwright servers with the version they must run, the Chrome rungs, the Bright Data unlocker; the configuration and where each value came from \u2014 environment, .env or default, never the value (config); the decision model behind library_verify and whether it answers right now (verify). ids=true also lists every entry ID.",
+    "The whole library as JSON: library directory and host; entry count and size on disk; per type (pmid, doi, dailymed, nct) the entries by level (full_text, abstract, title) and retractions; counts of retracted and not-citable entries and of errata, expressions of concern and updates; the retrieval sources in run order and which are off (tiers); the download ladder (download): the Playwright servers with the version they must run, the Chrome rungs, the Bright Data unlocker; the configuration and where each value came from \u2014 environment, .env or default, never the value (config); the decision model behind library_verify and whether it answers right now (verify); this server's cache hits and misses for library_verify and library_fetch since it started (cache). ids=true also lists every entry ID.",
     { ids: z.boolean().optional().describe("Also list every entry ID (type:value).") },
     async ({ ids }) => {
       const info = libraryInfo(FH_LIBRARY_DIR, HOST, ids === true);
@@ -4019,7 +4679,110 @@ function registerTools(server2) {
         }
       }
       log("library_info", null, `entries=${info.entries}${info.verify ? ` verify ${info.verify.model} ${info.verify.ok ? `ok ${info.verify.ms} ms` : `down: ${info.verify.error}`}` : " verify not configured"}`);
-      return { content: [{ type: "text", text: JSON.stringify(info, null, 2) }] };
+      const s = currentStats();
+      const cache = s ? { since: s.started, verify: s.verify, fetch: s.fetch, search: s.search } : null;
+      return { content: [{ type: "text", text: compact2({ ...info, cache }) }] };
+    }
+  );
+  server2.tool(
+    "library_fetch",
+    `Fetch a web page as Markdown: the standard fetch tool, cached and hardened. Use it for any URL instead of a plain fetch or a browser. A page fetched in the last ${settings().refresh_after_days} days is answered from disk in milliseconds; a page a plain fetch cannot get (403, rate limit, bot wall, script-rendered) is fetched through the configured browsers and unlocker in this one call. PDFs come back as Markdown. To verify a link, title_only returns just its title line.`,
+    {
+      url: z.string().describe("URL to fetch"),
+      max_length: z.number().int().min(1).max(999999).default(5e3).describe("Maximum number of characters to return."),
+      start_index: z.number().int().min(0).default(0).describe("On return output starting at this character index, useful if a previous fetch was truncated and more context is required."),
+      raw: z.boolean().default(false).describe("Get the actual HTML content of the requested page, without simplification."),
+      title_only: z.boolean().default(false).describe("Return only the page's title line. The whole page is still fetched and stored; use this to verify that a link resolves and what it points to.")
+    },
+    async ({ url, max_length, start_index, raw, title_only }) => {
+      const t0 = Date.now();
+      const id = logId(url), put = (line) => log("library_fetch", id, `${line} ${url}`);
+      const r = await libraryFetch(FH_LIBRARY_DIR, url, { max_length, start_index, raw, title_only }, `${pkg.name} ${pkg.version}`, {
+        onTry: put,
+        onAlert: (line) => put(`!! ${line}`)
+      });
+      const secs = ((Date.now() - t0) / 1e3).toFixed(1).padStart(4, "0") + "s";
+      if (r.meta) bump("fetch", r.cached);
+      if (r.ok) {
+        put(`${r.cached ? "cached" : `fetched ${secs}`} ${r.meta.format} retrieved_by=${r.meta.retrieved_by} fetched=${r.meta.fetched} chars=${r.text.length}${raw ? " raw" : ""}${title_only ? " title" : ""}${start_index ? ` start=${start_index}` : ""}`);
+        return { content: [{ type: "text", text: r.text }] };
+      }
+      put(`${r.cached ? "cached failure" : `failed ${secs}`}: ${r.error.replace(url, "<url>")}`);
+      return { content: [{ type: "text", text: r.error }], isError: true };
+    }
+  );
+  server2.tool(
+    "library_clinicaltrials_search_studies",
+    `Search ClinicalTrials.gov by free text, intervention or condition; status ongoing | completed | all; sort relevance | newest | largest | completion. Returns the total and up to ${MAX_RESULTS} rows as arrays in columns order: NCT ID, title, status, phase, enrollment, start, primary completion, primary outcome, conditions, interventions, has_results. Link: https://clinicaltrials.gov/study/<NCT ID>. Cached ${SEARCH_AFTER_DAYS} days. One trial in detail: library_clinicaltrials_get_study_record.`,
+    {
+      query: z.string().optional().describe("Free-text search across all fields (title, conditions, interventions, summary, \u2026); AND / OR / NOT allowed."),
+      intervention: z.string().optional().describe('Intervention or treatment, e.g. "tadalafil", "cognitive behavioral therapy".'),
+      condition: z.string().optional().describe('Condition or disease, e.g. "hypertension", "type 2 diabetes".'),
+      status: z.enum(["ongoing", "completed", "all"]).default("all").describe("ongoing: recruiting, not yet recruiting, active not recruiting, enrolling by invitation. completed: completed. all: no filter."),
+      sort: z.enum(["relevance", "newest", "largest", "completion"]).default("relevance").describe("relevance (the registry's ranking), newest (last update first), largest (enrollment first), completion (completion date, latest first)."),
+      max_results: z.number().int().min(1).max(MAX_RESULTS).default(20).describe("Rows to return (1\u2013100).")
+    },
+    async (args) => {
+      const t0 = Date.now();
+      const r = await searchTrials(args, FH_LIBRARY_DIR);
+      const secs = ((Date.now() - t0) / 1e3).toFixed(1).padStart(4, "0") + "s";
+      if (!r.ok) {
+        log("library_search", "ct:-", `error: ${r.error}`);
+        return { content: [{ type: "text", text: compact2({ error: r.error }) }], isError: true };
+      }
+      bump("search", r.cached);
+      const q = r.result.query, parts = [q.intervention && `intervention=${q.intervention}`, q.condition && `condition=${q.condition}`, q.query && `query=${q.query}`].filter(Boolean).join(" ");
+      log("library_search", `ct:${trialsLogId(q)}`, `${r.cached ? "cached" : `searched ${secs}`} rows=${r.result.rows.length} total=${r.result.total} status=${q.status}${q.sort !== "relevance" ? ` sort=${q.sort}` : ""} | ${parts}`);
+      return { content: [{ type: "text", text: leanJson(r.result) }] };
+    }
+  );
+  const nctEntry = async (id) => {
+    const p = parseId(/^\d{8}$/.test(id.trim()) ? `nct:${id.trim()}` : id);
+    if (p.error) return { error: p.error };
+    if (p.type !== "nct") return { error: `not a trial ID: ${p.requested}` };
+    const paths = entryPaths(FH_LIBRARY_DIR, p.type, p.id);
+    if (!entryExists(paths)) {
+      const r = await addEntry(p.requested);
+      const s = JSON.parse(r.content[0].text);
+      if (s.error) return { error: s.error };
+    }
+    return { paths, requested: p.requested };
+  };
+  server2.tool(
+    "library_clinicaltrials_get_study_record",
+    'One ClinicalTrials.gov trial as a review needs it: titles, status and why stopped, phase, design, enrollment, dates, sponsor, conditions, interventions, primary outcomes, eligibility, sites, result publications as pmid: IDs, has_results, brief summary. From the stored record; a missing trial is added first. The whole record: library_read("nct:\u2026").',
+    { nct: z.string().describe('The NCT ID: "nct:05173896", "NCT05173896" or the eight digits.') },
+    async ({ nct }) => {
+      const t0 = Date.now();
+      const e = await nctEntry(nct);
+      if ("error" in e) {
+        log("library_trials", nct, `record error: ${e.error}`);
+        return { content: [{ type: "text", text: compact2({ error: e.error }) }], isError: true };
+      }
+      const raw = e.paths.fulltextRaw("json");
+      const r = existsSync11(raw) ? recordSummary(readFileSync11(raw, "utf8")) : null;
+      if (!r) {
+        log("library_trials", e.requested, "record error: no stored record");
+        return { content: [{ type: "text", text: compact2({ error: "no stored record" }) }], isError: true };
+      }
+      log("library_trials", e.requested, `record ${((Date.now() - t0) / 1e3).toFixed(1).padStart(4, "0")}s ${r.status ?? ""}${r.has_results ? " results" : ""} | ${r.title}`);
+      return { content: [{ type: "text", text: leanJson(r) }] };
+    }
+  );
+  server2.tool(
+    "library_clinicaltrials_get_study_results",
+    'The posted results of one ClinicalTrials.gov trial \u2014 participant flow, baseline, every outcome measure as a table, adverse events \u2014 as Markdown from the stored record, capped at max_chars, outcome titles listed; library_read("nct:\u2026", section: <title>) returns one measure whole. has_results false when the registry holds none. A missing trial is added first.',
+    { nct: z.string().describe('The NCT ID: "nct:05173896", "NCT05173896" or the eight digits.'), max_chars: z.number().int().min(200).max(6e4).default(6e3).describe("Cap for the results text (default 6000).") },
+    async ({ nct, max_chars }) => {
+      const e = await nctEntry(nct);
+      if ("error" in e) {
+        log("library_trials", nct, `results error: ${e.error}`);
+        return { content: [{ type: "text", text: compact2({ error: e.error }) }], isError: true };
+      }
+      const md = existsSync11(e.paths.fulltextMd) ? readFileSync11(e.paths.fulltextMd, "utf8") : "";
+      const r = resultsText(e.requested.replace(/^nct:/, "NCT"), md, max_chars);
+      log("library_trials", e.requested, `results ${r.has_results ? `${r.outcomes.length} outcomes${r.truncated ? " truncated" : ""}` : "none"}`);
+      return { content: [{ type: "text", text: leanJson(r) }] };
     }
   );
   server2.tool(
@@ -4039,6 +4802,8 @@ var server = new McpServer(
   { instructions: INSTRUCTIONS }
 );
 registerTools(server);
+startStats(pkg);
+log("startup", null, `${pkg.name} ${pkg.version}`);
 for (const problem of resolveTiers().problems) log("startup", null, `!! ${problem}`);
 var transport = new StdioServerTransport();
 await server.connect(transport);