fh-library 0.2.7 → 0.2.11

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # FH Library — Change Log
 
+### v0.2.9 — 2026-11-08
+
+* TUI v80: a `search` row — cached registry searches, hits and misses from the servers' counters; the decision-model row is labelled `decider`; `/status` carries `searches`.
+* ClinicalTrials tool descriptions and server instructions one statement each.
+
+### v0.2.8 — 2026-11-08
+
+* **`library_clinicaltrials_get_study_record(nct)` and `library_clinicaltrials_get_study_results(nct, max_chars?)`:** thin answers over the stored `nct:` entry (added first when missing) — the review's detail of one trial, and its posted results as Markdown with the outcome titles for `library_read`. With the search, the three tools map one to one onto what the AI4L models used of the ClinicalTrials.gov MCP server (#28).
+* `library_verify` cache key folds the claim's typography (#33): case, whitespace and non-breaking spaces, curly quotes, en/em dashes, "+/-" for "±", a trailing period — never a word. The claim is judged and stored as written.
+* `library_verify`: a claim that opens with an odds ratio ("OR 2.15 (95% CI 1.06 to 4.34) for …") is a statement, not a fragment starting with the conjunction "or" (seen in an AI4L audit, pmid:25358826).
+* **Smaller answers (#32):** every tool answers compact JSON (no indentation); `library_add`, `library_status`, `library_read` and `library_clinicaltrials_search_studies` leave out null values, empty lists and the entry's paths and file names (`entry_dir`, `library_dir`, `files`). `library_verify` keeps its nulls (`score`, `reason` null carry meaning). A status answer is about 30% smaller, a 20-row trial search about 25%.
+* **`library_fetch(…, title_only)`:** the title line alone (`Contents of <url>:` and `# Title`); the page is fetched and stored in full as usual. For verifying a link at a few tokens instead of a page (#32).
+* **`library_clinicaltrials_search_studies(query | intervention | condition, status?, sort?, max_results?)`:** a ClinicalTrials.gov search (API v2, no key) — total count and rows as arrays in `columns` order (nct, title, status with why stopped, phase, enrollment, start, primary_completion, primary_outcome, conditions, interventions, has_results — the names once, not per row); `status` ongoing / completed / all; `sort` relevance / newest / largest / completion. Cached under `search/<2>/<4>/<key>.json` for 7 days. With `library_add("nct:…")` and `library_read` for the record and posted results, this covers what the AI4L models asked the ClinicalTrials.gov MCP server for (#28). `library_info`'s `cache` and the `.servers/` files count `search` hits and misses.
+
 ### v0.2.7 — 2026-11-08
 
 * **Verdicts are cached** (#26): `library_verify` keeps each judgement as `verify/<2>/<4>/<key>.json` — the file system as the database, laid out like `url/` — and answers the same claim on the same stored text from disk for `FH_LIBRARY_REFRESH_AFTER_DAYS`; a new full text, model or threshold is judged afresh, errors are never kept. The result is unchanged; the log line says `cached`. One atomic file per judgement: several servers on one library need no lock.

package/README.md

@@ -1,4 +1,4 @@
-![Version 0.1.3](https://img.shields.io/badge/Version-0.2.7-green.svg)
+![Version 0.1.3](https://img.shields.io/badge/Version-0.2.11-green.svg)
 ![License MIT](https://img.shields.io/badge/License-MIT-yellow.svg)
 [![Forever Healthy](https://img.shields.io/badge/(c)_2026-Forever_Healthy-573D7D.svg)](https://forever-healthy.org)
 [![npm](https://img.shields.io/badge/npm-fh--library-cb3837.svg)](https://www.npmjs.com/package/fh-library)
@@ -23,11 +23,16 @@ A [Model Context Protocol](https://modelcontextprotocol.io) server that builds a
 * `library_info(ids?)` → the whole library, everything the TUI shows: the library directory and host, the decision model with its endpoint and whether it answers right now (`verify`), this server's cache hits and misses since it started (`cache`), the entries and their size on disk (`size`), per entry type (`types`: pmid, doi, dailymed, nct) the entries with their levels — `full_text`, `abstract`, `title` — and retractions; entry counts by type and level, counts of retracted and not-citable entries and of entries with errata, expressions of concern and updates, the configured tiers, library directory and host; `ids: true` also lists every entry ID
 * `library_verify(claim, id)` → is one finding of a review stated by one paper it cites? `claim` is the finding alone, verbatim, without its citations; `id` one paper (`pmid:`, or any `doi:`), drug label or trial record the review cites for it — a finding cited to three papers is three calls with the same claim; a claim that names a source or carries citations is refused. The server reads the paper (full text, else abstract) and asks a decision model; nothing of the paper enters the model's context. `verdict` **pass** (`score` the probability), **fail** (the full text does not state it; or only the title is in the library — `reason` says so), **unverifiable** (only the abstract is in the library and does not state it — `reason`) or **error**; `basis` full_text, abstract or title. See "Verifying claims" below.
 * `library_read(id, section?, query?, max_chars?, max_hits?)` → one small piece of a stored paper's Markdown, never the whole paper: without `section`/`query` the **outline** (headings with word counts, and whether the full text or only the abstract is stored; a heading the paper uses several times is listed as `Participants [3/12]`); `section` → that section's **own text** (heading matched as case-insensitive substring, capped at `max_chars`, default 6000, with `returned_words` against `words` when cut) and, for a parent heading, its `subsections` with word counts to pick from — a duplicated heading named bare lists the candidates instead; `query` — two or three distinctive terms the paper itself would use (a measure and a unit, an outcome and a group, a compound name), not the claim — → **passages** holding every term, each a window of at most 1000 chars around the matches (`clipped: true` when cut; a table row with its header row), with its section, best first (at most `max_hits`, default 5); matching forgives case, accents, hyphens, Markdown markup, plural and -ed/-ing forms; when no passage holds every term the best **partial** matches come back (`partial: true`, the `matched` terms per passage, the rare term first), and `missing_terms` names the terms the text never uses in any form — those are the ones to rephrase. `section` and `query` together search inside that section. `section: "Abstract"` on a full text without one answers from the stored abstract. Every full text converted from JATS XML (PMC, Europe PMC, Elsevier) has a **Declarations** section — funding, conflicts of interest, author notes, gathered from wherever the XML keeps them — and on a text without one `section: "Declarations"` assembles the sections headed funding, conflicts, acknowledgements, ethics, contributions, so it answers who paid and who declares what on every source alike; a paper with neither states nothing. Outline first, then pick. A paper not in the library is added first, as `library_add` would (its lines in the log), then library_read; the answer carries `added: true`. Reads may run in parallel.
-* `library_fetch(url, max_length?, start_index?, raw?)` → a web page as Markdown, exactly as the standard MCP `fetch` tool returns it (see "Web pages"): the one tool whose document enters the model's context
+* `library_clinicaltrials_search_studies(query | intervention | condition, status?, sort?, max_results?)` → a ClinicalTrials.gov search (see "Trial search"): the total count and compact rows, cached for a week
+* `library_clinicaltrials_get_study_record(nct)` → one trial as a review needs it (title, status, phase, design, enrollment, dates, sponsor, conditions, interventions, primary outcomes, eligibility, sites, result publications, has_results, brief summary), from the stored record
+* `library_clinicaltrials_get_study_results(nct, max_chars?)` → a trial's posted results as Markdown, capped, with the outcome measure titles for `library_read`
+* `library_fetch(url, max_length?, start_index?, raw?, title_only?)` → a web page as Markdown, exactly as the standard MCP `fetch` tool returns it (see "Web pages"): the one tool whose document enters the model's context
 * `library_version()` → the running server's package name, version, host and library directory
 
 IDs follow the `type:value` form: `pmid:`, `doi:`, `dailymed:`, `nct:`; bare digits count as `pmid:`, a bare NCT number as `nct:`.
 
+**Context budget.** Every answer is sized to what a model does with it in an evidence review, because every character comes out of the model's context. Answers are compact JSON; a status answer leaves out what carries nothing (null values, empty lists, the entry's paths and file names), while `library_verify` keeps its nulls, because a null `score` or `reason` means something there. A link is verified with `library_fetch(url, title_only: true)`, one line instead of a page; the page is stored in full for a later read. The ClinicalTrials.gov tools follow the same rule: `library_clinicaltrials_search_studies` returns rows as arrays under one `columns` list, so the field names are sent once, not per trial, and carries only what a review's Emerging Research item states about a trial — the rest of a record is one `library_clinicaltrials_get_study_record` call away, and the posted results one `library_clinicaltrials_get_study_results` call, capped by `max_chars`; measured against the ClinicalTrials.gov MCP server on the same calls, the search matches its compact index in size while carrying the primary outcome and interventions it lacks, the record is an eighth of its size, the results half. Searches and verdicts are cached, so a repeated audit pays no second answer. The PubMed tools to come (search, fetch) are built the same way: the parameters the live audits actually use, rows shaped for the review's sections on evidence, benefits, risks and interactions, cached.
+
 ### Retrieval tiers
 
 | Tier | Does | Needs |
@@ -96,7 +101,7 @@ Every full text is checked before it counts: title present, methods and results
 
 **The call.** `claim` is one finding, verbatim from the review, with markdown links reduced to their text and its citations removed: `IPSS fell 2.3 points more than placebo in men with ED`. Section labels such as `**Magnitude:**` and list bullets may stay. `id` is one paper the review cites for that finding, as `pmid:<PMID>`, already in the library (`library_add` first). One claim, one paper per call: a finding cited to three papers is three calls with the same claim text, and each answer stands on its own — a source that does not carry the finding is named by its own row, so it can be dropped without touching the others. The server never aggregates over papers. A sentence that joins two findings, each with its own citation, is two claims: the text before each citation group, without the group. A sentence without a citation is not a claim.
 
-**Verdicts are kept.** The answer to one claim against one stored text is written to `verify/<2>/<4>/<key>.json` — one file per judgement, laid out like `url/` — and served from there for `FH_LIBRARY_REFRESH_AFTER_DAYS` (30): an audit that runs twice over the same review pays the model once. The key hashes the claim (whitespace aside), the source ID, the model, the threshold and the stored text, so a paper that gains its full text, a changed model or a changed threshold is judged afresh; errors are never kept. The result JSON is the same either way; the log line carries `cached`. Several servers may share the library: a file appears whole or not at all, no lock.
+**Verdicts are kept.** The answer to one claim against one stored text is written to `verify/<2>/<4>/<key>.json` — one file per judgement, laid out like `url/` — and served from there for `FH_LIBRARY_REFRESH_AFTER_DAYS` (30): an audit that runs twice over the same review pays the model once. The key hashes the claim with its typography folded (case, whitespace, curly quotes, dashes, "±" forms, a trailing period — never a word: a reworded claim is another statement), the source ID, the model, the threshold and the stored text, so a paper that gains its full text, a changed model or a changed threshold is judged afresh; errors are never kept. The result JSON is the same either way; the log line carries `cached`. Several servers may share the library: a file appears whole or not at all, no lock.
 
 **How to build the claim.** The decision model answers exactly the statement it is given, so the statement must be one the paper could make:
 
@@ -142,7 +147,9 @@ PubMed's book records — National Academies reports, NTP monographs, StatPearls
 
 **Clinical trial records.** `library_add("nct:05173896")` stores the current record of one trial from [ClinicalTrials.gov](https://clinicaltrials.gov/): the ID is the eight digits of the NCT number in the review's link (`…/study/NCT05173896`); `nct:NCT05173896` and a bare `NCT05173896` are accepted and read the same. The API's JSON is converted to Markdown, one section per module: identification with secondary IDs such as EudraCT, status with every date and its actual/estimated type, sponsor and collaborators, description, conditions, design (phase, allocation, masking, enrollment with its type), arms and interventions with doses, primary and secondary outcomes with time frames, eligibility, locations as a country list, references; and, when results are posted, the participant flow, baseline characteristics, every outcome measure with its group values and analyses, and the adverse events, all as tables. Values are written in plain words, "Phase 2", "Active, not recruiting", "100 (estimated)", so a figure the review states can be found as stated. The status carries `nctid`, `publications` (the results publications the record lists, as `pmid:…`, so whether a trial has been published is one status away), the brief title, the lead sponsor as `first_author`, the first-posted year as `year`, the last-update-posted date as `version`, and `publication_types` `["Trial Registration"]`. `library_read` and `library_verify` work on a record as on a paper. An entry older than `FH_LIBRARY_REFRESH_AFTER_DAYS` is re-fetched and rewritten when the record was updated since; a status the review states that has moved on then fails, which is right. Entries live under `nct/<digits 1–2>/<digits 1–4>/<digits>/` with the JSON and the Markdown as `nct-<digits>-fulltext.json` and `-fulltext.md`; the log line reads `library_add nct:05173896 ctgov fetched level=full_text updated 2024-12-09 active, not recruiting ETLAS2`.
 
-**Web pages.** `library_fetch(url, max_length?, start_index?, raw?)` is the standard MCP [fetch](https://github.com/modelcontextprotocol/servers/tree/main/src/fetch) tool, served from the library, for every link a review carries that is not a paper, label or trial record: a guideline, a product page, a news item. Its description tells the model to prefer it over a plain fetch or a browser tool, and says why: a page anyone fetched in the last 30 days comes from disk in milliseconds, and a page a plain fetch cannot get climbs the ladder in the same call. The answer is what `fetch` returns, so a model keeps its habits: `Contents of <url>:` and the page as Markdown with the page's title as the first heading, cut at `max_length` (default 5000) with the note `Content truncated. Call the fetch tool with a start_index of N to get more content`; `raw` gives the HTML; a `text/markdown` body comes back as is, any other non-HTML body with the `Content type … cannot be simplified to markdown` prefix; a failure is `Failed to fetch <url> - status code 404` or `Failed to fetch <url>: <reason>`. Two things happen underneath. The page is fetched up the same ladder as a paper — the plain fetch, then the browser rungs on a 403, 429 or bot wall, then Bright Data — so a page a plain fetch cannot reach is still read. And it is stored: `url/<2>/<4>/<16 hex of the URL's SHA-1>/url-<hash>-{meta.md, page.md, page.html|pdf|txt}`, the URL normalised first (host lowercased, fragment and tracking parameters dropped). The same URL within `FH_LIBRARY_REFRESH_AFTER_DAYS` (30) is served from disk, a failed fetch is not repeated within `FH_LIBRARY_RETRY_AFTER_DAYS` (1) — an audit that runs twice over one review reads its links once. A PDF comes back as Markdown (`fetch` would return its bytes as text). The log says which — `fetch example.com/… cached html … https://example.com/drugs/x` or `fetched 02.3s html retrieved_by=browser hetzner … <url>` (the ID column holds the URL without scheme, cut to a PubMed ID's width; the full URL ends the line); `library_info` counts the pages under `url`, a failed fetch as level `title`.
+**Trial search.** `library_clinicaltrials_search_studies(query?, intervention?, condition?, status?, sort?, max_results?)` asks the ClinicalTrials.gov API (v2, no key) what a review needs from the registry: the trials of an intervention, the ongoing ones (`status: "ongoing"` is recruiting, not yet recruiting, active not recruiting, enrolling by invitation), a free-text or condition search, sorted by relevance, newest, largest or completion date, up to 100 rows. The rows are arrays in the order of `columns` — the field names once, not per row — shaped for the review's Emerging Research item (what AI4L's prompt asks about an ongoing trial; the link is `https://clinicaltrials.gov/study/<NCT ID>`): NCT ID, title, status with why a trial stopped, phase, enrollment as "100 (estimated)", start and primary completion dates (whether "ongoing" still holds), the primary outcome with its time frame, conditions, interventions, `has_results`; the full detail of one row is `library_clinicaltrials_get_study_record`; `total` is the registry's count, for a "no trials found" statement. The same search is answered from `search/<2>/<4>/<key>.json` for 7 days — a registry listing a week old is current enough for a review, and an audit that runs again reads from disk. Two thin tools answer from the stored record of any row (added first when missing): `library_clinicaltrials_get_study_record(nct)` is the review's detail of one trial — official title, design, enrollment, dates, eligibility, sites, result publications as `pmid:` IDs, the brief summary — and `library_clinicaltrials_get_study_results(nct, max_chars?)` is the posted results part of the stored Markdown (participant flow, baseline, outcome measures, adverse events), with the outcome titles listed so `library_read("nct:…", section)` can return one measure whole. Together with the search they cover what the AI4L models asked the ClinicalTrials.gov MCP server for.
+
+**Web pages.** `library_fetch(url, max_length?, start_index?, raw?)` is the standard MCP [fetch](https://github.com/modelcontextprotocol/servers/tree/main/src/fetch) tool, served from the library, for every link a review carries that is not a paper, label or trial record: a guideline, a product page, a news item. Its description tells the model to prefer it over a plain fetch or a browser tool, and says why: a page anyone fetched in the last 30 days comes from disk in milliseconds, and a page a plain fetch cannot get climbs the ladder in the same call. The answer is what `fetch` returns, so a model keeps its habits: `Contents of <url>:` and the page as Markdown with the page's title as the first heading, cut at `max_length` (default 5000) with the note `Content truncated. Call the fetch tool with a start_index of N to get more content`; `raw` gives the HTML; a `text/markdown` body comes back as is, any other non-HTML body with the `Content type … cannot be simplified to markdown` prefix; a failure is `Failed to fetch <url> - status code 404` or `Failed to fetch <url>: <reason>`. Two things happen underneath. The page is fetched up the same ladder as a paper — the plain fetch, then the browser rungs on a 403, 429 or bot wall, then Bright Data — so a page a plain fetch cannot reach is still read. And it is stored: `url/<2>/<4>/<16 hex of the URL's SHA-1>/url-<hash>-{meta.md, page.md, page.html|pdf|txt}`, the URL normalised first (host lowercased, fragment and tracking parameters dropped). The same URL within `FH_LIBRARY_REFRESH_AFTER_DAYS` (30) is served from disk, a failed fetch is not repeated within `FH_LIBRARY_RETRY_AFTER_DAYS` (1) — an audit that runs twice over one review reads its links once. A PDF comes back as Markdown (`fetch` would return its bytes as text). `title_only` returns `Contents of <url>:` and the title line alone — the page is still fetched and stored in full — so a link check costs a few tokens instead of a page. The log says which — `fetch example.com/… cached html … https://example.com/drugs/x` or `fetched 02.3s html retrieved_by=browser hetzner … <url>` (the ID column holds the URL without scheme, cut to a PubMed ID's width; the full URL ends the line); `library_info` counts the pages under `url`, a failed fetch as level `title`.
 
 **Funding and conflicts of interest.** Every status carries `coi`, the paper's conflict-of-interest statement, and `funding`, who paid. Both come from PubMed's record at ingest (`CoiStatement`, the grant list's agencies; a quarter of records have each) and are refreshed with it; where PubMed has none and a full text was retrieved, they are taken from the paper's own text — its Declarations section, or a section headed Funding, Conflicts of interest, Competing interests or Disclosure — as the statement verbatim. `coi` null and `funding` empty therefore mean: neither PubMed nor the stored text states anything. For an abstract-only entry that is as far as the library can see. The full statements of a paper with full text are one call away: `library_read(id, section: "Declarations")` — the JATS section, or on a PDF- or HTML-sourced text the funding, conflict and acknowledgement sections assembled. In `-meta.md` they are the lines `coi:` (a JSON string) and `funding:` (a JSON array, one item per agency or statement).
 

package/dist/index.js

@@ -669,11 +669,11 @@ async function pdfToMarkdown(bytes, title, headLine2, stats2) {
   }
   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) {
@@ -687,7 +687,7 @@ async function pdfToMarkdown(bytes, title, headLine2, stats2) {
       out.push(`## ${h}`, "");
       continue;
     }
-    para2.push(line);
+    para3.push(line);
   }
   flush();
   return fixGlyphs(out.join("\n")).replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
@@ -880,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, "-");
 }
@@ -1797,8 +1797,8 @@ function rotateIfLarge(file2, max = LOG_MAX_BYTES) {
   }
 }
 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 });
@@ -2917,7 +2917,7 @@ 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 } };
+  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();
@@ -2969,7 +2969,7 @@ function publish() {
 }
 
 // src/tools.ts
-import { existsSync as existsSync10, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync11 } from "fs";
 import { z } from "zod";
 
 // src/cascade.ts
@@ -3112,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;
 }
@@ -3428,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++) {
@@ -3452,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;
@@ -3704,7 +3705,7 @@ function readUrlMeta(p) {
   if (!existsSync8(p.meta)) return null;
   const md = readFileSync8(p.meta, "utf8");
   const f = (k) => {
-    const m = new RegExp(`^${k}:\\s*(.*)$`, "m").exec(md);
+    const m = new RegExp(`^${k}:[ \\t]*(.*)$`, "m").exec(md);
     return m ? m[1].trim() : "";
   };
   let title = null;
@@ -3883,9 +3884,17 @@ 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);
@@ -3943,8 +3952,11 @@ import { existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as rea
 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(`${normalizeClaim(claim)}
+var cacheKey = (claim, id, model, threshold, text3) => sha(`${foldClaim(claim)}
 ${id}
 ${model}
 ${threshold}
@@ -3983,15 +3995,229 @@ async function verifyCached(claim, id, cfg, decide, libraryDir = FH_LIBRARY_DIR,
   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(readFileSync10(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 \u2014 except library_fetch, which is the standard fetch tool with a cache. 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.
@@ -4006,7 +4232,10 @@ Tools
 - 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_fetch(url, max_length?, start_index?, raw?) \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.
+- 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.
@@ -4015,6 +4244,7 @@ Hints
 - 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.
@@ -4037,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 = [
@@ -4343,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 });
@@ -4359,8 +4589,8 @@ function registerTools(server2) {
         }
         added = true;
       }
-      const full = existsSync10(paths.fulltextMd);
-      const md = readFileSync10(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;
@@ -4380,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 && existsSync10(paths.md)) {
-          sec = readSection(readFileSync10(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)) {
@@ -4429,7 +4659,7 @@ function registerTools(server2) {
       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}` : ""}${cached ? " cached" : ""} | ${claim}`);
-      return { content: [{ type: "text", text: JSON.stringify(r, null, 2) }] };
+      return { content: [{ type: "text", text: compact2(r) }] };
     }
   );
   server2.tool(
@@ -4450,36 +4680,111 @@ 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"}`);
       const s = currentStats();
-      const cache = s ? { since: s.started, verify: s.verify, fetch: s.fetch } : null;
-      return { content: [{ type: "text", text: JSON.stringify({ ...info, cache }, null, 2) }] };
+      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.`,
+    `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.")
+      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 }) => {
+    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 }, `${pkg.name} ${pkg.version}`, {
+      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" : ""}${start_index ? ` start=${start_index}` : ""}`);
+        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(
     "library_version",
     "Get the running fh-library MCP server's package name and version, and the resolved library directory. Useful to confirm which build is loaded.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fh-library",
-  "version": "0.2.7",
+  "version": "0.2.11",
   "mcpName": "io.github.forever-healthy/fh-library",
   "description": "MCP Server that builds a local Markdown library of the scientific papers cited by evidence reviews — fetches metadata, abstract and full text per PubMed ID through a configurable cascade of retrieval services",
   "type": "module",