fh-library 0.2.16 → 0.2.17

package/CHANGELOG.md

@@ -1,137 +1,5 @@
 # FH Library — Change Log
 
-### v0.2.12 — 2026-11-08
+### v0.2.17 — 2026-11-08
 
-* **`library_pubmed_search_articles(query, max_results?, sort?, years?)`:** a PubMed search in PubMed's own syntax — esearch for the total and the IDs, one esummary for the rows (PMID, title, first author, year, journal, publication types, PMCID, library level), cached under `search/`. With the batch fetch and `library_read` this covers what the AI4L models used of the PubMed MCP server (#27).
-* **`FH_LIBRARY_SEARCH_CACHE_DAYS` (7):** days a PubMed or registry search is cached; was a constant.
-* **An ID no service knows is remembered** for `FH_LIBRARY_RETRY_AFTER_DAYS` (1): a PMID PubMed has no record for, a DOI neither Crossref nor doi.org resolves, a set ID without a label, an NCT ID without a study. A marker (`<entry>-missing.md`, date and reason, no meta) in the entry's directory; `library_add`, `library_status`, `library_read`, `library_verify` and the batch tool answer from it ("pmid not found (checked 2026-11-08; asked again after 1 day)"), the service is asked again after the cooldown, a real entry replaces the marker. Network errors are never remembered. The same cooldown a failed page or a transient tier failure already had.
-* **`library_pubmed_fetch_articles(pmids)`:** title, first author, year, publication types, retracted and level for up to 200 PMIDs in one call, rows in `columns` order (~120 characters a paper against the PubMed MCP server's ~2,500). Stored PMIDs from disk; the rest in one efetch, stored at abstract level as `library_add`'s first stage, so the cascade runs later as on an untried entry. The first of the PubMed tools (#27); `library_info`'s `cache` and `.servers/` count `pubmed` hits and misses per PMID.
-
-### v0.2.9 — 2026-11-08
-
-* TUI v82: the `url` row shows library_fetch hits and misses from the servers' counters; `/status` carries `fetches`. Counts right-aligned in a 5-character column.
-* 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.
-* **Each server publishes its cache counters:** hits and misses of `library_verify` and `library_fetch` since it started, in memory, written to `<library>/.servers/<host>-<pid>.json` on every change and every 5 min as a heartbeat, removed on exit, swept by the next starting server when older than 20 min; `library_info` reports them as `cache`. The server also logs a `startup` line.
-* TUI v79: a `verify` row — stored verdicts ("queries cached"), then hits and misses summed over the servers alive on the library, read from `.servers/`, not from the log; `/status` carries `verdicts`. Resolves `.env` and `library/` from the caller's working directory, as the server does (#31) — `npm run --prefix <repo> tui` from a project root shows that project's library.
-
-### v0.2.6 — 2026-11-08
-
-* **`library_fetch(url, max_length?, start_index?, raw?)`:** the standard MCP `fetch` tool, served from the library. Same answer as the reference server — `Contents of <url>:`, the page as Markdown with its title as the first heading, the truncation note, the raw-content prefix, the `Failed to fetch …` errors — so a model keeps its fetch habits. Underneath, the page is fetched up the download ladder (plain fetch, Playwright and Chrome rungs, Bright Data) when a plain fetch is refused, and stored under `url/`: the same URL within `FH_LIBRARY_REFRESH_AFTER_DAYS` is served from disk, a failed fetch is not repeated within `FH_LIBRARY_RETRY_AFTER_DAYS`. A PDF comes back as Markdown. `library_info` counts web pages as type `url`; the log line says `cached` or `fetched`.
-* **Script shells climb the ladder:** a page answered 200 whose converted text is under 100 words with a loading/JavaScript phrase (or under 10 words at all) is treated like a wall page — the browser rungs, then Bright Data; a browser rung with so little text waits for the network to go quiet and the text to grow (at most 8 s) before reading the page. When no rung renders more, the shell is served, as fetch would (lifeextension.com's search is such a page: nothing renders it).
-* **Bright Data's 407 is reported:** a token's IP allowlist refusing this host used to surface as a bare "fetch failed" (Node's fetch treats a 407 as a network error); the unlocker now requests over node:https and the log alerts `!! brightdata: unlocker HTTP 407: You are not allowed to access our API via this IP (…)`.
-* TUI v74: a `url` row (web pages, failed fetches); fetch log lines coloured — `cached` green, rung outcomes green/red; `/status` counts `fetches` and `cached`; `(u)pdate` also rescans the library.
-* README: `library_version` returns the package "version", not "library_version" (one more word the prefix rename caught).
-
-### v0.2.5 — 2026-11-08
-
-* **Tool descriptions** (issue #30): `library_info` names its key `verify`, not `library_verify`; `library_status` answers for one ID of any kind, not "one paper ID"; `library_verify`'s `claim` asks for a complete statement built from the review's words, not a verbatim fragment.
-
-### v0.2.4 — 2026-11-08
-
-* **Fix: `library_status` on a stored entry and `library_info` failed** with "library_status is not defined" / "library_info is not defined" in 0.2.2 and 0.2.3: the rename that restored the `library_` prefix also renamed two local variables. `library_version`'s log line printed "undefined" for the same reason. The Playwright download rung lacked a `readFileSync` import. Prose in the server instructions and READMEs that had "read" or "status" turned into tool names is plain English again.
-
-### v0.2.3 — 2026-11-08
-
-* **Every key is an `FH_LIBRARY_*` variable:** `FH_LIBRARY_NCBI_API_KEY`, `FH_LIBRARY_BRIGHTDATA_API_TOKEN`, `FH_LIBRARY_BRIGHTDATA_ZONE` replace the bare `NCBI_API_KEY`, `BRIGHTDATA_API_TOKEN`, `BRIGHTDATA_ZONE` the library used to share with other MCP servers. Hard cut: a deployment that still runs those servers keeps the bare lines for them and adds the prefixed ones for the library. The direction: fetching and PubMed move into the library, the separate servers go, and the double configuration with them.
-
-### v0.2.2 — 2026-11-08
-
-* **Tool names carry the `library_` prefix again**, all of them: `library_add`, `library_status`, `library_read`, `library_verify`, `library_info`, `library_version` (0.2.0 and 0.2.1 had the bare names, and `version`). A model that sees many servers' tools should never have to guess what `add` or `read` belongs to. Client permissions and prompts name them with the prefix.
-* **Browser rungs by kind:** `FH_LIBRARY_PLAYWRIGHT_1`, `_2`, … (Playwright servers, port 8932) and `FH_LIBRARY_CHROME_1`, `_2`, … (a Chrome with `--remote-debugging-port`, port 9222) replace `FH_LIBRARY_BROWSER_1..3`. Values are hostnames (host or host:port); the kind is the variable's name, the protocol the library's. `FH_LIBRARY_PLAYWRIGHT_HEADLESS` (was `_BROWSER_HEADLESS`) belongs to the Playwright family; a Chrome rung is whatever it is. Order is fixed: Playwright servers, then Chrome rungs. The in-process "local" Chromium rung is gone — the library never launches a browser. `library_info` splits `download` into `playwright: {version, servers}` and `chrome`. Hard cut: every `.env` must move its browser lines.
-
-### v0.2.0 — 2026-11-08
-
-* **Renamed to FH Library.** The npm packages are `fh-library` (public) and `fh-library-dev` (dev), the MCP Registry entry `io.github.forever-healthy/fh-library`, the repos `forever-healthy/fh-library` and `fh-library-dev`; the server announces itself as `fh-library`, and client configs use the keys `fh-library`, `fh-library-dev`, `fh-library-local` (the `d-` prefix is for MCP servers Forever Healthy did not write). The `ai4l-library` packages are deprecated and point here.
-* **Tools lose the `library_` prefix:** `add`, `status`, `read`, `verify`, `info`, `version` (was `get_version`). The server name namespaces them in every client.
-* **Environment variables are `FH_LIBRARY_*`** (was `AI4L_LIBRARY_*`), hard cut: every `.env` must follow. Keys other servers share (`NCBI_API_KEY`, `BRIGHTDATA_API_TOKEN`, `BRIGHTDATA_ZONE`) are unchanged. The browser helper is `fh-chrome` (service, window class, `~/.fh-chrome` profile), the browser server container `fh-browser`.
-* Entries in the changelog below this line use the old names; they describe the versions that carried them.
-
-### v0.1.12 — 2026-11-07
-
-* Server instructions after the AI4L review (#21): calls may run in parallel — add, read and verify — and two calls on the same missing record share one add (said once, under Hints, instead of "reads may run in parallel"); `corrections` is named as the status's field; the stale `config.json` clause gives way to the proxy URL template from the configuration.
-
-### v0.1.11 — 2026-11-07
-
-* `library_verify`: the verdict `na` is `unverifiable` again, now only for a paper whose abstract is stored and does not state the claim (the full text may). A title-only record — no abstract text, no full text — is a `fail`: nothing to read can back a claim; no model call, `score` null. Both carry `reason`, one fixed sentence each; `reason` is null otherwise. Audit tables map `unverifiable` where they mapped `na`. The log line pads the verdict to 12 characters.
-* A record with nothing to read is not citable: `citable` false with `comment` "no abstract and no full text: nothing to verify" (retraction still comes first). `library_info.not_citable` counts them. A full text dropped into the inbox makes the record citable again.
-* The server instructions rewritten as one short bullet document (3.9 K chars instead of 11 K): IDs, tools, rules, verify, read, status fields, sources. New guidance from the dev fleet run: no add or status before read or verify; one source, only what that source reports (a two-intervention finding cited to two papers is two claims; a statement about the literature becomes the figure this paper gives); what to do after each verdict (`fail` → read with a query, then reword or drop; `na` → "abstract only", no retry); `partial` → replace the `missing_terms`, keep the rest; a wrong ID is not retried. The `library_read` and `library_verify` descriptions shrunk to what the tool and its parameters do; the guidance lives in the instructions once.
-
-### v0.1.10 — 2026-11-07
-
-* `library_read` and `library_verify` on a paper not in the library add it first, as `library_add` would (its lines in the log), then read or judge it; the read answer carries `added: true`, and a paper the add cannot build is the error. Parallel reads of one missing paper share a single add.
-* The `query` parameter says how to search: 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. The creators were sending 5–8 keyword dumps, which no paragraph holds whole.
-
-### v0.1.9 — 2026-11-07
-
-* `library_info` shows the Playwright version the package pins as `download.playwright`; the fleet TUI's `/status` carries the same as `playwright`. A browser server of another version is logged in words as an alert — `!! browser hetzner: Playwright version mismatch — server ws://hetzner:8932 must run playwright-core 1.65.0` — instead of the raw `428 Precondition Required` (#19).
-
-### v0.1.8 — 2026-11-07
-
-* `playwright-core` pinned to 1.65.0 (was `^1.58.1`), and `browser/Dockerfile` moved to the same version. A Playwright server refuses a client of another version with `428 Precondition Required`; a fresh install of the range had drifted to 1.65.0 while the browser servers ran 1.58.1, so the browser rungs never ran on the evipedia fleet. Package and servers must carry the same exact version.
-
-### v0.1.7 — 2026-11-07
-
-`library_read`, from watching the creators use it (#18):
-
-* `query` answers windows, not paragraphs: each passage is at most 1000 chars around the matches (`clipped: true` when cut; a table row comes with its header row). A PDF-sourced section used to come back whole — up to 468 KB in one passage.
-* When no passage holds every term, the best partial matches come back with `partial: true` and the `matched` terms per passage, the rare term ranked first; `missing_terms` names the terms the text never uses in any form.
-* Matching forgives case, accents, hyphen/slash, Markdown markup (`t~max~` is tmax), plural and -ed/-ing/-ation forms.
-* `section` and `query` together search inside that section.
-* A parent heading answers its own text plus its `subsections` (heading, words) instead of the subtree cut at `max_chars`; a cut section reports `returned_words` against `words`.
-* A heading the text uses several times is listed as `Participants [3/12]` and named that way; the bare name lists the candidates.
-* `section "Abstract"` on a full text without one answers from the stored abstract; `section "Declarations"` on a text without one assembles the funding / conflict / acknowledgement / ethics sections.
-* PDF → Markdown: paragraphs from the page layout (extra leading, a first-line indent, a bullet, a change of type size, a short line ending a sentence), across columns and pages — not only from blank lines, which journal PDFs rarely have. Cochrane's section names are recognised as headings. Stored PDF-sourced texts keep their old structure until re-added.
-* JATS: a blank inside `<sub>`/`<sup>` moves outside the markers (`t~max~ around`, not `t~max ~around`).
-
-### v0.1.6 — 2026-11-07
-
-* No change to the server. The fleet TUI (dev repo, not in the package) pulls its checkout with each rescan (`AI4L_LIBRARY_TUI_PULL=1`) instead of on its own timer.
-
-### v0.1.5 — 2026-11-07
-
-* `library.log`: a message starting with `!!` is an alert — a service refused the deployment itself (Bright Data's reason from its `x-brd-err-msg` header, e.g. a token not allowed from this IP; a verify model failure; an unknown tier name at startup).
-* Fixed: `AI4L_LIBRARY_DIR` set in `.env` was ignored (the library directory was resolved before `.env` was loaded); only the environment worked.
-
-### v0.1.4 — 2026-11-07
-
-* `.env` is the whole configuration: every value an environment variable, the tier set and the defaults built in. `library/config.json` and `AI4L_LIBRARY_CONFIG` are gone, and with them `${NAME}` references and the per-tier `description`.
-* Renamed, no aliases — `CONTACT_EMAIL` → `AI4L_LIBRARY_CONTACT_EMAIL`; `ELSEVIER_API_KEY` → `AI4L_LIBRARY_ELSEVIER_API_KEY`; `WILEY_TDM_TOKEN` → `AI4L_LIBRARY_WILEY_TDM_TOKEN`; `CORE_API_KEY` → `AI4L_LIBRARY_CORE_API_KEY`; `PERPLEXITY_URL` / `PERPLEXITY_API_KEY` / `PERPLEXITY_MODEL` → `AI4L_LIBRARY_VERIFY_URL` / `_API_KEY` / `_MODEL`; config.json's `threshold`, `timeout_seconds`, `retry_after_days`, `retry_blocked`, `refresh_after_days`, `download.headless` → `AI4L_LIBRARY_VERIFY_THRESHOLD`, `AI4L_LIBRARY_VERIFY_TIMEOUT_SECS`, `AI4L_LIBRARY_RETRY_AFTER_DAYS`, `AI4L_LIBRARY_RETRY_BLOCKED`, `AI4L_LIBRARY_REFRESH_AFTER_DAYS`, `AI4L_LIBRARY_BROWSER_HEADLESS`. `NCBI_API_KEY`, `BRIGHTDATA_API_TOKEN`, `BRIGHTDATA_ZONE` and `AI4L_LIBRARY_BROWSER_n` unchanged.
-* `AI4L_LIBRARY_TIERS` is the whole ladder: the listed tiers in exactly that order, a tier not listed is off (an unlisted tier no longer runs after the listed ones).
-* One proxy tier, `proxy`, instead of url tiers: `AI4L_LIBRARY_PROXY_URL` (template with `{doi}` `{pmid}` `{pmcid}`) and `AI4L_LIBRARY_PROXY_HEADERS`; `PROXY_TOKEN` and the `my-proxy` example are gone.
-* `library_info`: `config` replaces `tiers_config` — the cascade's settings, problems with `AI4L_LIBRARY_TIERS`, and per variable where its value came from (environment, `.env`, default), never the value; `tiers` in run order without descriptions (the README describes them).
-* The container's working directory is `/library`; the configuration arrives as its environment.
-
-### v0.1.3 — 2026-11-07
-
-* IDs: `pmid:` (bare digits count as one), `doi:` for papers PubMed does not index (a DOI PubMed indexes is stored under its PMID and copied under the DOI, so every tool takes either), `dailymed:<set ID>` drug labels, `nct:` trial records.
-* `library_add(id)`: full text through a configurable cascade (`config.json`: inbox, pmc, europepmc, tdm, unpaywall, openalex, core, url tiers) and a download ladder (plain fetch, browser rungs, Bright Data); every text checked (title, methods and results, no wall page) before it counts; failed tiers recorded in `attempts`, transient ones retried after `retry_after_days`; PubMed record re-read after `refresh_after_days` for correction notices and retractions (`citable`, `corrections`).
-* `library_read(id, section?, query?, max_chars?, max_hits?)`: the outline, one section, or the paragraphs matching a query — never the whole paper.
-* `library_verify(claim, id)`: is one finding stated by one source, judged on the stored text by the Perplexity Decisions API; `superseded` when a stored correction replaced the figure; `glyphs_unresolved` for symbols a PDF font gave no character for.
-* `library_info(ids?)`: the library's directory, tiers, download ladder, verify model health, entries by type and level.
-* PDF conversion: symbols restored from the font's glyph names (minus, ±, ≤, Greek letters), words broken at line ends joined back.
-* `library.log`: one line per action, host-prefixed.
-* Environment variables renamed `LIBRARY_*` → `AI4L_LIBRARY_*` (`AI4L_LIBRARY_DIR`, `AI4L_LIBRARY_CONFIG`, `AI4L_LIBRARY_ENV`, `AI4L_LIBRARY_TIERS`, `AI4L_LIBRARY_BROWSER_n`, `AI4L_LIBRARY_TUI_STATUS_SECS`); the old names are not read.
-* `.env` is also looked for in the library directory when neither `AI4L_LIBRARY_ENV` nor `./.env` names one.
-* Entry files are written to a temporary name and renamed into place (several servers may share one library); `library.log` rotates to `library.log.1` past 50 MB.
-
-### v0.1.1 — 2026-10-26
-
-* `library_add(id)` and `library_status(id)` for `pmid:` IDs.
-
-### v0.0.1 — 2026-10-26
-
-* Project skeleton.
+* **`library_fetch` answers record URLs from the library:** a PubMed, ClinicalTrials.gov, DailyMed or doi.org link is answered from the library entry (a missing PubMed record is stored at abstract level in one request, no full-text cascade; a DOI PubMed indexes goes through its PMID) in fetch's format — the abstract record for PubMed, the trial record, the label, the full text or abstract for a DOI; `title_only` the title line. No script shell, no browser.

package/README.md

@@ -1,4 +1,4 @@
-![Version 0.1.3](https://img.shields.io/badge/Version-0.2.16-green.svg)
+![Version 0.1.3](https://img.shields.io/badge/Version-0.2.17-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)
@@ -7,7 +7,9 @@
 
 ![AI4L – AI for Practical Longevity](https://raw.githubusercontent.com/forever-healthy/fh-library/main/docs/AI4L-Header.png)
 
-**FH Library** - MCP server that builds a local library of the scientific papers an evidence review cites, part of [AI4L](https://github.com/forever-healthy/AI4L)
+# FH Library MCP
+
+MCP server that builds a local library of the scientific papers an evidence review cites, part of [AI4L](https://github.com/forever-healthy/AI4L)
 
 A [Model Context Protocol](https://modelcontextprotocol.io) server that builds a local library of the scientific papers an evidence review cites. Given a paper ID (`type:value`, e.g. `pmid:30955454`), it fetches the paper's metadata, abstract and — where obtainable — full text through a configurable cascade of retrieval services (PubMed, PMC, Europe PMC, Unpaywall, OpenAlex, …), converts everything to Markdown, and stores it under a mounted `library/` directory. Nothing flows through the model's context: the server writes to disk itself and returns only a small status per call.
 
@@ -73,8 +75,9 @@ FH_LIBRARY_PROXY_HEADERS=Authorization: Bearer <token>
 ```
 
 * The URL is a template. Placeholders: `{doi}` (`10.1056/NEJMoa042274`), `{pmid}` (`15516696`), `{pmcid}` (`PMC6728809`, with its prefix). Each is URL-encoded when filled — the slash in a DOI becomes `%2F` — so put a placeholder in a path segment or a query value. A template may use several. The tier applies only to a paper for which every placeholder it uses is known; otherwise it is skipped as `no doi` (or `no pmcid`, …), a permanent reason. A template without any placeholder never runs (`template has no placeholder`).
+
 * The headers are optional request headers for credentials (`Authorization`, an API-key header, a cookie), as `Name: value; Name: value`.
-* Unset URL: no proxy tier. `FH_LIBRARY_TIERS` places `proxy` in the order like any built-in tier.
+
 
 **What the proxy tier expects back.** The tier sends one GET to the filled template, with a desktop Chrome User-Agent and the headers; redirects are followed. The service answers the paper as one of two formats, read from the response bytes, not the URL or the Content-Type:
 
@@ -151,6 +154,8 @@ PubMed's book records — National Academies reports, NTP monographs, StatPearls
 
 **PubMed in batches.** `library_pubmed_fetch_articles(pmids)` answers what an auditor asks of a list of PubMed IDs — does each resolve, what is its title, year and type, is it retracted, does the library hold its full text — as rows in `columns` order, about 120 characters per paper. A PMID already in the library is read from disk. The others go to PubMed in one efetch request (up to 200), and each record is stored exactly as `library_add` stores its first stage: the XML, the abstract Markdown, the meta with its correction and retraction notices, no retrieval attempts yet — so a later `library_add` or `library_read` runs the full-text cascade as on an untried entry, and the library fills at abstract level in batches instead of one paper at a time. An entry is checked again right before writing, so a concurrent `library_add` that already stored a full text is never overwritten. Level `not found` marks a PMID PubMed does not know, `invalid` a value that is not a PMID. `library_pubmed_search_articles(query, max_results?, sort?, years?)` is the search: the query goes to PubMed as written, field tags and all; esearch gives the total and the IDs, one esummary the rows — PMID, title, first author, year, journal, publication types (Journal Article left out), PMCID when a free full text exists, and the library's level when the paper is already stored, so the model knows what `library_read` can answer at once. Cached under `search/` like the trial search.
 
+**Record URLs.** `library_fetch` answers a PubMed, ClinicalTrials.gov, DailyMed or doi.org link from the library instead of the web page, in fetch's format: the abstract record for a PubMed link, the trial record, the label, the full text or abstract for a DOI; `title_only` the title line. A missing PubMed record is stored at abstract level in one request, no full-text cascade (a DOI PubMed indexes goes through its PMID); a trial or label is added as `library_add` adds it. PubMed's own page is a script shell a browser must render; the record answers in half a second, and in milliseconds once stored.
+
 **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 `FH_LIBRARY_SEARCH_CACHE_DAYS` (7) — 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`.

package/dist/index.js

@@ -1480,41 +1480,6 @@ function europepmcCandidates(r, pmcid) {
   return out;
 }
 
-// src/tiers/inbox.ts
-import { existsSync as existsSync4, readdirSync, readFileSync as readFileSync3, unlinkSync } from "fs";
-import { join as join4 } from "path";
-var INBOX_DIR = join4(FH_LIBRARY_DIR, "inbox");
-var EXT = { ".pdf": "application/pdf", ".xml": "text/xml", ".html": "text/html", ".htm": "text/html" };
-function findInboxFile(dir, pmid) {
-  if (!existsSync4(dir)) return null;
-  const re = new RegExp(`(^|[^0-9])${pmid}([^0-9]|$)`);
-  for (const name of readdirSync(dir).sort()) {
-    const ext = name.slice(name.lastIndexOf(".")).toLowerCase();
-    if (ext in EXT && re.test(name.slice(0, -ext.length))) return join4(dir, name);
-  }
-  return null;
-}
-function inboxTier(dir = INBOX_DIR) {
-  return {
-    name: "inbox",
-    always: true,
-    applies: (p) => p.pmid ? true : "no pmid",
-    async run(p, ctx) {
-      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(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(file2);
-      return { ok: true, tier: "inbox", format: r.format, raw: r.format === "pdf" ? bytes : bytes.toString("utf8"), md: r.md, version: "published" };
-    }
-  };
-}
-var inbox = inboxTier();
-
 // src/tiers/openalex.ts
 var openalex = {
   name: "openalex",
@@ -1675,7 +1640,6 @@ function unpaywallCandidates(d) {
 
 // src/tiers/index.ts
 var BUILTIN = [
-  { name: "inbox", make: () => inbox },
   { name: "pmc", make: () => pmc },
   { name: "europepmc", make: () => europepmc },
   { name: "tdm", make: (o) => tdmTier(o.tokens ?? {}) },
@@ -1774,9 +1738,9 @@ function resolveTiers(env = process.env) {
 // src/log.ts
 import { appendFileSync, mkdirSync as mkdirSync2, renameSync, statSync } from "fs";
 import { hostname } from "os";
-import { join as join5 } from "path";
+import { join as join4 } from "path";
 var HOST = hostname();
-var LOG_FILE = join5(FH_LIBRARY_DIR, "library.log");
+var LOG_FILE = join4(FH_LIBRARY_DIR, "library.log");
 function stamp() {
   const d = /* @__PURE__ */ new Date();
   const p = (n) => String(n).padStart(2, "0");
@@ -1811,12 +1775,12 @@ function log(tool, id, message) {
 }
 
 // src/stats.ts
-import { mkdirSync as mkdirSync4, readdirSync as readdirSync3, readFileSync as readFileSync5, statSync as statSync2, unlinkSync as unlinkSync3 } from "fs";
-import { join as join7 } from "path";
+import { mkdirSync as mkdirSync4, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync2, unlinkSync as unlinkSync2 } from "fs";
+import { join as join6 } from "path";
 
 // src/entry.ts
-import { copyFileSync, existsSync as existsSync5, mkdirSync as mkdirSync3, readdirSync as readdirSync2, readFileSync as readFileSync4, renameSync as renameSync2, rmSync, unlinkSync as unlinkSync2, writeFileSync } from "fs";
-import { join as join6 } from "path";
+import { copyFileSync, existsSync as existsSync4, mkdirSync as mkdirSync3, readdirSync, readFileSync as readFileSync3, renameSync as renameSync2, rmSync, unlinkSync, writeFileSync } from "fs";
+import { join as join5 } from "path";
 import { basename, dirname } from "path";
 
 // src/pubmed.ts
@@ -2440,7 +2404,7 @@ ${body}
 }
 function readHeadLine(p) {
   try {
-    const lines = readFileSync4(p.md, "utf8").split("\n").filter((l) => l.trim());
+    const lines = readFileSync3(p.md, "utf8").split("\n").filter((l) => l.trim());
     return lines[1] ?? "";
   } catch {
     return "";
@@ -2562,28 +2526,28 @@ function splitPublicationTypes(v) {
 }
 function abstractMissing(p) {
   try {
-    return readFileSync4(p.md, "utf8").includes("_No abstract available._");
+    return readFileSync3(p.md, "utf8").includes("_No abstract available._");
   } catch {
     return false;
   }
 }
 function correctionsFromXml(p) {
   try {
-    return parsePubmedXml(readFileSync4(p.xml, "utf8"))?.corrections ?? [];
+    return parsePubmedXml(readFileSync3(p.xml, "utf8"))?.corrections ?? [];
   } catch {
     return [];
   }
 }
 function declarationsFromXml(p) {
   try {
-    const r = parsePubmedXml(readFileSync4(p.xml, "utf8"));
+    const r = parsePubmedXml(readFileSync3(p.xml, "utf8"));
     return { coi: r?.coi ?? null, funding: r?.funding ?? [] };
   } catch {
     return { coi: null, funding: [] };
   }
 }
 function readMeta(p) {
-  const { fm, all } = parseFrontmatter(readFileSync4(p.meta, "utf8"));
+  const { fm, all } = parseFrontmatter(readFileSync3(p.meta, "utf8"));
   let title = fm.title ?? "";
   if (title.startsWith('"')) {
     try {
@@ -2639,7 +2603,7 @@ function writeAtomic(file2, data) {
 function writeMeta(p, m) {
   writeAtomic(p.meta, renderMeta(m));
   try {
-    unlinkSync2(join6(p.entryDir, `${p.entry}-missing.md`));
+    unlinkSync(join5(p.entryDir, `${p.entry}-missing.md`));
   } catch {
   }
 }
@@ -2648,12 +2612,12 @@ function copyEntry(from, to) {
   rmSync(tmp, { recursive: true, force: true });
   mkdirSync3(tmp, { recursive: true });
   const rename = (n) => n.startsWith(from.entry) ? to.entry + n.slice(from.entry.length) : n;
-  for (const n of readdirSync2(from.entryDir)) if (join6(from.entryDir, n) !== from.meta && !n.endsWith(".tmp")) copyFileSync(join6(from.entryDir, n), join6(tmp, rename(n)));
+  for (const n of readdirSync(from.entryDir)) if (join5(from.entryDir, n) !== from.meta && !n.endsWith(".tmp")) copyFileSync(join5(from.entryDir, n), join5(tmp, rename(n)));
   const m = readMeta(from);
   const copy = { ...m, files: m.files.map(rename) };
-  writeFileSync(join6(tmp, basename(to.meta)), renderMeta(copy));
+  writeFileSync(join5(tmp, basename(to.meta)), renderMeta(copy));
   mkdirSync3(dirname(to.entryDir), { recursive: true });
-  if (existsSync5(to.entryDir)) renameSync2(to.entryDir, old);
+  if (existsSync4(to.entryDir)) renameSync2(to.entryDir, old);
   renameSync2(tmp, to.entryDir);
   rmSync(old, { recursive: true, force: true });
   return copy;
@@ -2675,7 +2639,7 @@ function citability(m) {
   return { citable: true, comment: notes.length ? notes.join("; ") : null };
 }
 function statusFromMeta(p, m, base) {
-  const full = existsSync5(p.fulltextMd) ? readFileSync4(p.fulltextMd, "utf8") : null;
+  const full = existsSync4(p.fulltextMd) ? readFileSync3(p.fulltextMd, "utf8") : null;
   const cit = citability(m);
   if (full?.includes(`
 ${CORRECTED_HEADING}
@@ -2717,7 +2681,7 @@ function readStatus(p, base) {
   return statusFromMeta(p, readMeta(p), base);
 }
 function entryExists(p) {
-  return existsSync5(p.meta);
+  return existsSync4(p.meta);
 }
 function writeEntry(p, r, xml, converter) {
   mkdirSync3(p.entryDir, { recursive: true });
@@ -2800,15 +2764,15 @@ ${sentences.join("\n\n")}
 `;
 }
 function syncCorrectedBlock(p) {
-  if (!existsSync5(p.fulltextMd) || !existsSync5(p.xml)) return;
+  if (!existsSync4(p.fulltextMd) || !existsSync4(p.xml)) return;
   let r;
   try {
-    r = parsePubmedXml(readFileSync4(p.xml, "utf8"));
+    r = parsePubmedXml(readFileSync3(p.xml, "utf8"));
   } catch {
     return;
   }
   if (!r) return;
-  const md = readFileSync4(p.fulltextMd, "utf8");
+  const md = readFileSync3(p.fulltextMd, "utf8");
   const next = withCorrectedBlock(md, correctedSentences(r));
   if (next !== md) writeAtomic(p.fulltextMd, next);
 }
@@ -2924,13 +2888,13 @@ 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 }, pubmed: { hits: 0, misses: 0 } };
-  file = join7(libraryDir, ".servers", `${HOST}-${process.pid}.json`);
-  sweep(join7(libraryDir, ".servers"));
+  file = join6(libraryDir, ".servers", `${HOST}-${process.pid}.json`);
+  sweep(join6(libraryDir, ".servers"));
   publish();
   setInterval(publish, HEARTBEAT_MS).unref();
   const stop = () => {
     try {
-      if (file) unlinkSync3(file);
+      if (file) unlinkSync2(file);
     } catch {
     }
   };
@@ -2942,16 +2906,16 @@ function sweep(dir, staleMs = STALE_MS) {
   let n = 0;
   let names;
   try {
-    names = readdirSync3(dir);
+    names = readdirSync2(dir);
   } catch {
     return 0;
   }
   for (const name of names) {
     if (!name.endsWith(".json")) continue;
-    const p = join7(dir, name);
+    const p = join6(dir, name);
     try {
       if (Date.now() - statSync2(p).mtimeMs > staleMs) {
-        unlinkSync3(p);
+        unlinkSync2(p);
         n++;
       }
     } catch {
@@ -2968,14 +2932,14 @@ var currentStats = () => stats;
 function publish() {
   if (!stats || !file) return;
   try {
-    mkdirSync4(join7(file, ".."), { recursive: true });
+    mkdirSync4(join6(file, ".."), { recursive: true });
     writeAtomic(file, JSON.stringify(stats, null, 2) + "\n");
   } catch {
   }
 }
 
 // src/tools.ts
-import { existsSync as existsSync13, readFileSync as readFileSync13 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync12 } from "fs";
 import { z } from "zod";
 
 // src/cascade.ts
@@ -3008,7 +2972,7 @@ async function fulltextCascade(p, attempts, onEvent, tiers = resolveTiers().tier
   const misses = [];
   const tried = /* @__PURE__ */ new Set();
   for (const tier of tiers) {
-    if (!tier.always && shouldSkip(attempts, tier.name, retryAfterDays, /* @__PURE__ */ new Date(), retryBlocked)) continue;
+    if (shouldSkip(attempts, tier.name, retryAfterDays, /* @__PURE__ */ new Date(), retryBlocked)) continue;
     const applies = tier.applies(p);
     const ctx = { tried, onTry: (message) => onEvent?.({ ok: "try", tier: tier.name, message }), onAlert: (message) => onEvent?.({ ok: "alert", tier: tier.name, message }) };
     const r = applies === true ? await tier.run(p, ctx) : { ...miss(tier.name, applies), skipped: true };
@@ -3050,11 +3014,11 @@ function parseId(raw) {
 }
 
 // src/info.ts
-import { existsSync as existsSync7, readdirSync as readdirSync4, readFileSync as readFileSync7, statSync as statSync3 } from "fs";
-import { dirname as dirname2, join as join8 } from "path";
+import { existsSync as existsSync6, readdirSync as readdirSync3, readFileSync as readFileSync6, statSync as statSync3 } from "fs";
+import { dirname as dirname2, join as join7 } from "path";
 
 // src/verify.ts
-import { existsSync as existsSync6, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync5 } 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) {
@@ -3156,10 +3120,10 @@ async function readPaper(raw, libraryDir = FH_LIBRARY_DIR) {
   if (p.error) return { id: p.requested, error: p.error };
   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: readFileSync6(paths.fulltextMd, "utf8") };
+  const full = existsSync5(paths.fulltextMd);
+  if (full) return { id: p.requested, basis: "full_text", text: readFileSync5(paths.fulltextMd, "utf8") };
   const meta = readMeta(paths);
-  return { id: p.requested, basis: meta.has_abstract ? "abstract" : "title", text: readFileSync6(paths.md, "utf8") };
+  return { id: p.requested, basis: meta.has_abstract ? "abstract" : "title", text: readFileSync5(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 };
@@ -3200,9 +3164,9 @@ async function verifyClaim(claim, id, cfg, decide, read = readPaper) {
 
 // src/info.ts
 function* metaFiles(dir) {
-  if (!existsSync7(dir)) return;
-  for (const name of readdirSync4(dir)) {
-    const p = join8(dir, name);
+  if (!existsSync6(dir)) return;
+  for (const name of readdirSync3(dir)) {
+    const p = join7(dir, name);
     if (statSync3(p).isDirectory()) yield* metaFiles(p);
     else if (name.endsWith("-meta.md")) yield p;
   }
@@ -3241,11 +3205,11 @@ function libraryInfo(libraryDir, host, withIds, tiers = resolveTiers()) {
     updates: 0
   };
   const ids = [];
-  for (const type of existsSync7(libraryDir) ? readdirSync4(libraryDir) : []) {
-    const typeDir = join8(libraryDir, type);
+  for (const type of existsSync6(libraryDir) ? readdirSync3(libraryDir) : []) {
+    const typeDir = join7(libraryDir, type);
     if (!statSync3(typeDir).isDirectory()) continue;
     for (const meta of metaFiles(typeDir)) {
-      const md = readFileSync7(meta, "utf8");
+      const md = readFileSync6(meta, "utf8");
       const raw = field(md, "level") || "unknown";
       const level = raw === "abstract" && field(md, "has_abstract") === "no" ? "title" : raw;
       info.entries++;
@@ -3255,9 +3219,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 readdirSync4(dir)) {
+      for (const f of readdirSync3(dir)) {
         try {
-          const st = statSync3(join8(dir, f));
+          const st = statSync3(join7(dir, f));
           if (st.isFile()) info.size_bytes += st.size;
         } catch {
         }
@@ -3286,7 +3250,7 @@ function noticeTypes(md, metaPath) {
     return out;
   }
   try {
-    const xml = readFileSync7(metaPath.replace(/-meta\.md$/, "-abstract.xml"), "utf8");
+    const xml = readFileSync6(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 {
   }
@@ -3665,8 +3629,8 @@ 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";
+import { existsSync as existsSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync7 } from "fs";
+import { join as join8 } from "path";
 var TRACKING = /^(utm_[a-z]+|fbclid|gclid|dclid|msclkid|mc_cid|mc_eid|igshid|ref_src)$/i;
 function normalizeUrl(raw) {
   let u;
@@ -3688,8 +3652,8 @@ var urlHash = (normalized2) => createHash2("sha1").update(normalized2).digest("h
 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}`) };
+  const entryDir = join8(libraryDir, "url", hash.slice(0, 2), hash.slice(0, 4), hash);
+  return { hash, entry, entryDir, meta: join8(entryDir, `${entry}-meta.md`), md: join8(entryDir, `${entry}-page.md`), raw: (ext) => join8(entryDir, `${entry}-page.${ext}`) };
 }
 function renderUrlMeta(m) {
   const lines = [
@@ -3708,8 +3672,8 @@ function renderUrlMeta(m) {
   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");
+  if (!existsSync7(p.meta)) return null;
+  const md = readFileSync7(p.meta, "utf8");
   const f = (k) => {
     const m = new RegExp(`^${k}:[ \\t]*(.*)$`, "m").exec(md);
     return m ? m[1].trim() : "";
@@ -3793,7 +3757,7 @@ var climb = async (url, onTry, onAlert) => {
     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`);
+    onTry?.("shell kept: no rung rendered the page, the script shell is served");
     return shell;
   }
   return r.ok || r.via === "fetch" ? r : { ...r, first: firstReason };
@@ -3886,6 +3850,25 @@ function logId(url) {
   const bare2 = url.replace(/^https?:\/\//i, "");
   return bare2.length > ID_WIDTH ? bare2.slice(0, ID_WIDTH - 1) + "\u2026" : bare2;
 }
+function libraryIdForUrl(raw) {
+  let u;
+  try {
+    u = new URL(raw.trim());
+  } catch {
+    return null;
+  }
+  const host = u.hostname.toLowerCase().replace(/^www\./, ""), path = u.pathname;
+  let m;
+  if (host === "pubmed.ncbi.nlm.nih.gov" && (m = /^\/(\d{1,8})\/?$/.exec(path))) return `pmid:${m[1]}`;
+  if (host === "ncbi.nlm.nih.gov" && (m = /^\/pubmed\/(\d{1,8})\/?$/.exec(path))) return `pmid:${m[1]}`;
+  if (host === "clinicaltrials.gov" && (m = /^\/(?:study|ct2\/show)\/(NCT\d{8})\/?$/i.exec(path))) return `nct:${m[1].slice(3)}`;
+  if (host === "dailymed.nlm.nih.gov" && /\/(drugInfo|lookup)\.cfm$/i.test(path)) {
+    const id = u.searchParams.get("setid");
+    if (id && /^[0-9a-f-]{36}$/i.test(id)) return `dailymed:${id.toLowerCase()}`;
+  }
+  if ((host === "doi.org" || host === "dx.doi.org") && (m = /^\/(10\.\S+)$/.exec(decodeURIComponent(path)))) return `doi:${m[1]}`;
+  return null;
+}
 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}`;
@@ -3898,14 +3881,14 @@ function titleLine(m, md) {
 }
 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") : "";
+  const read = (file2) => existsSync7(file2) ? readFileSync7(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);
+    body = rawFile ? read(join8(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);
@@ -3954,8 +3937,8 @@ async function libraryFetch(libraryDir, requested, args, converter, logs = {}, f
 
 // 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";
+import { existsSync as existsSync8, mkdirSync as mkdirSync6, readFileSync as readFileSync8 } from "fs";
+import { dirname as dirname3, join as join9 } from "path";
 var sha = (s) => createHash3("sha1").update(s).digest("hex");
 var normalizeClaim = (claim) => claim.replace(/\s+/g, " ").trim();
 function foldClaim(claim) {
@@ -3967,11 +3950,11 @@ ${id}
 ${model}
 ${threshold}
 ${text3}`).slice(0, 16);
-var verdictFile = (libraryDir, key) => join10(libraryDir, "verify", key.slice(0, 2), key.slice(0, 4), `${key}.json`);
+var verdictFile = (libraryDir, key) => join9(libraryDir, "verify", key.slice(0, 2), key.slice(0, 4), `${key}.json`);
 function readVerdict(file2) {
-  if (!existsSync9(file2)) return null;
+  if (!existsSync8(file2)) return null;
   try {
-    return JSON.parse(readFileSync9(file2, "utf8"));
+    return JSON.parse(readFileSync8(file2, "utf8"));
   } catch {
     return null;
   }
@@ -4021,8 +4004,8 @@ 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";
+import { existsSync as existsSync9, mkdirSync as mkdirSync7, readFileSync as readFileSync9 } from "fs";
+import { dirname as dirname4, join as join10 } from "path";
 var searchCacheDays = () => settings().search_cache_days;
 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"];
@@ -4060,7 +4043,7 @@ function normalizeQuery(q) {
   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`);
+var searchFile = (libraryDir, key) => join10(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);
@@ -4112,9 +4095,9 @@ async function searchTrials(raw, libraryDir = FH_LIBRARY_DIR, fetchImpl = liveFe
   const q = normalizeQuery(raw);
   if ("error" in q) return { ok: false, error: q.error };
   const file2 = searchFile(libraryDir, searchKey(q));
-  if (existsSync10(file2)) {
+  if (existsSync9(file2)) {
     try {
-      const r = JSON.parse(readFileSync10(file2, "utf8"));
+      const r = JSON.parse(readFileSync9(file2, "utf8"));
       if (daysSince(r.searched) < searchCacheDays()) return { ok: true, result: r, cached: true };
     } catch {
     }
@@ -4146,7 +4129,7 @@ function trialsLogId(q) {
 
 // src/pubmedsearch.ts
 import { createHash as createHash5 } from "crypto";
-import { existsSync as existsSync11, mkdirSync as mkdirSync8, readFileSync as readFileSync11 } from "fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync8, readFileSync as readFileSync10 } from "fs";
 import { dirname as dirname5 } from "path";
 var MAX_RESULTS2 = 100;
 var DEFAULT_RESULTS2 = 20;
@@ -4227,9 +4210,9 @@ async function searchArticles(raw, libraryDir = FH_LIBRARY_DIR, fetchImpl = live
   const q = normalizeQuery2(raw);
   if ("error" in q) return { ok: false, error: q.error };
   const file2 = searchFile(libraryDir, searchKey2(q));
-  if (existsSync11(file2)) {
+  if (existsSync10(file2)) {
     try {
-      const r = JSON.parse(readFileSync11(file2, "utf8"));
+      const r = JSON.parse(readFileSync10(file2, "utf8"));
       if (daysSince(r.searched) < searchCacheDays()) return { ok: true, result: r, cached: true };
     } catch {
     }
@@ -4333,13 +4316,13 @@ function resultsText(nct, md, maxChars) {
 }
 
 // src/missing.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync9, readFileSync as readFileSync12 } from "fs";
-import { join as join12 } from "path";
-var missingFile = (p) => join12(p.entryDir, `${p.entry}-missing.md`);
+import { existsSync as existsSync11, mkdirSync as mkdirSync9, readFileSync as readFileSync11 } from "fs";
+import { join as join11 } from "path";
+var missingFile = (p) => join11(p.entryDir, `${p.entry}-missing.md`);
 function readMissing(p) {
   const f = missingFile(p);
-  if (!existsSync12(f)) return null;
-  const md = readFileSync12(f, "utf8");
+  if (!existsSync11(f)) return null;
+  const md = readFileSync11(f, "utf8");
   const get = (k) => /^$/.test(k) ? "" : (new RegExp(`^${k}:[ \\t]*(.*)$`, "m").exec(md)?.[1] ?? "").trim();
   const checked = get("checked"), reason = get("reason");
   return checked ? { checked, reason: reason || "not found" } : null;
@@ -4445,7 +4428,7 @@ async function fetchArticles(ids, libraryDir = FH_LIBRARY_DIR, converter = "fh-l
 // src/tools.ts
 var pkg = (() => {
   try {
-    return JSON.parse(readFileSync13(new URL("../package.json", import.meta.url), "utf8"));
+    return JSON.parse(readFileSync12(new URL("../package.json", import.meta.url), "utf8"));
   } catch {
     return { name: "fh-library", version: "0.0.0" };
   }
@@ -4504,7 +4487,7 @@ Reading a document
 
 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.`;
+Where records come from: PubMed for the record and abstract; the full text from 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: leanJson(s) }] });
@@ -4841,8 +4824,8 @@ function registerTools(server2) {
         }
         added = true;
       }
-      const full = existsSync13(paths.fulltextMd);
-      const md = readFileSync13(full ? paths.fulltextMd : paths.md, "utf8");
+      const full = existsSync12(paths.fulltextMd);
+      const md = readFileSync12(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;
@@ -4862,8 +4845,8 @@ function registerTools(server2) {
         const cap = max_chars ?? 6e3;
         let sec = readSection(md, section2, cap);
         let via = "";
-        if (!sec && /abstract/i.test(section2) && full && existsSync13(paths.md)) {
-          sec = readSection(readFileSync13(paths.md, "utf8"), "abstract", cap);
+        if (!sec && /abstract/i.test(section2) && full && existsSync12(paths.md)) {
+          sec = readSection(readFileSync12(paths.md, "utf8"), "abstract", cap);
           via = " (from the abstract file)";
         }
         if (!sec && /declaration/i.test(section2)) {
@@ -4938,7 +4921,7 @@ function registerTools(server2) {
   );
   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.`,
+    `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. A PubMed, ClinicalTrials.gov, DailyMed or doi.org URL is answered from the library's record of it.`,
     {
       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."),
@@ -4949,6 +4932,39 @@ function registerTools(server2) {
     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}`);
+      let rid = raw ? null : libraryIdForUrl(url);
+      if (rid?.startsWith("doi:") && !entryExists(entryPaths(FH_LIBRARY_DIR, "doi", parseId(rid).id))) {
+        try {
+          const pm = await pmidForDoi(parseId(rid).id);
+          if (pm) rid = `pmid:${pm}`;
+        } catch {
+        }
+      }
+      if (rid) {
+        const pid = parseId(rid);
+        const paths = entryPaths(FH_LIBRARY_DIR, pid.type, pid.id);
+        const had = entryExists(paths);
+        if (!had && pid.type === "pmid") {
+          const b = await fetchArticles([pid.id], FH_LIBRARY_DIR, `${pkg.name} ${pkg.version}`);
+          if (b.rows[0]?.[6] === "not found" || !entryExists(paths)) {
+            put(`library ${rid} error: pmid not found`);
+            return { content: [{ type: "text", text: `Failed to fetch ${url}: pmid not found` }], isError: true };
+          }
+        } else if (!had) {
+          const added = JSON.parse((await addEntry(rid)).content[0].text);
+          if (added.error) {
+            put(`library ${rid} error: ${added.error}`);
+            return { content: [{ type: "text", text: `Failed to fetch ${url}: ${added.error}` }], isError: true };
+          }
+        }
+        const file2 = pid.type === "pmid" ? paths.md : existsSync12(paths.fulltextMd) ? paths.fulltextMd : paths.md;
+        const md = existsSync12(file2) ? readFileSync12(file2, "utf8") : "";
+        const text3 = title_only ? `Contents of ${url}:
+${(md.split("\n").find((l) => l.trim()) ?? "").trim()}` : fetchAnswer(url, md, "", max_length, start_index);
+        bump("fetch", had);
+        put(`library ${rid} ${had ? "cached" : "added"} chars=${text3.length}${title_only ? " title" : ""}${start_index ? ` start=${start_index}` : ""}`);
+        return { content: [{ type: "text", text: text3 }] };
+      }
       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}`)
@@ -5049,7 +5065,7 @@ function registerTools(server2) {
         return { content: [{ type: "text", text: compact2({ error: e.error }) }], isError: true };
       }
       const raw = e.paths.fulltextRaw("json");
-      const r = existsSync13(raw) ? recordSummary(readFileSync13(raw, "utf8")) : null;
+      const r = existsSync12(raw) ? recordSummary(readFileSync12(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 };
@@ -5068,7 +5084,7 @@ function registerTools(server2) {
         log("library_trials", nct, `results error: ${e.error}`);
         return { content: [{ type: "text", text: compact2({ error: e.error }) }], isError: true };
       }
-      const md = existsSync13(e.paths.fulltextMd) ? readFileSync13(e.paths.fulltextMd, "utf8") : "";
+      const md = existsSync12(e.paths.fulltextMd) ? readFileSync12(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) }] };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fh-library",
-  "version": "0.2.16",
+  "version": "0.2.17",
   "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",