@cyanheads/pubmed-mcp-server 2.10.19 → 2.10.21

package/dist/mcp-server/tools/definitions/fetch-fulltext.tool.js

@@ -1,7 +1,9 @@
 /**
  * @fileoverview Full-text fetch tool. Resolves full-text articles through a
  * three-stage chain: NCBI PMC EFetch → Europe PMC `fullTextXML` → Unpaywall.
- * Accepts three mutually-exclusive input shapes:
+ * Accepts three input fields, alone or together, naming at most 50 distinct
+ * identifiers between them. The first 10 in routing order are fetched; the rest
+ * are returned unfetched in `overLimit`, before any upstream request:
  *
  *   - `pmcids` — fetch directly by PMC ID, once per record however it is
  *     spelled (`PMC123`, `pmc123`, `123`, zero-padded `PMC0123`), and reported
@@ -16,6 +18,17 @@
  *     DOIs are case-insensitive: every casing of one DOI runs the chain once,
  *     and `unavailable[]` reports each casing as the caller wrote it.
  *
+ * The singular `pmcid`, `pmcId`, `pmid`, and `doi` are unadvertised aliases of
+ * these fields, and a lone string under any of them reads as a one-element
+ * array. (#221)
+ *
+ * Routing runs `pmcids`, then `pmids`, then `dois`. Every tier keys its work on
+ * the record — PMC on the PMCID, Europe PMC on the search hit's `source` + `id`,
+ * Unpaywall on the lowercased DOI — and the first id to reach a record owns it:
+ * a later id naming the same article joins the owner's chain as another caller
+ * id, so the article is fetched and returned once. Each `unavailable[]` entry,
+ * deferred id, and over-limit id carries the field its id was sent in.
+ *
  * Output uses a discriminated union on `source` (`pmc` | `unpaywall`) with an
  * extra `viaSource` discriminator that records which layer produced the
  * content. EPMC's JATS reuses the `pmc` schema shape because it's the same
@@ -30,7 +43,7 @@
  * @module src/mcp-server/tools/definitions/fetch-fulltext.tool
  */
 import { tool, z } from '@cyanheads/mcp-ts-core';
-import { serializationError } from '@cyanheads/mcp-ts-core/errors';
+import { JsonRpcErrorCode, serializationError } from '@cyanheads/mcp-ts-core/errors';
 import { htmlExtractor, pdfParser } from '@cyanheads/mcp-ts-core/utils';
 import { getServerConfig } from '../../../config/server-config.js';
 import { NCBI_SERVICE_ERRORS } from '../../../services/error-contracts.js';
@@ -46,6 +59,7 @@ import { fitWholeItems } from './_budget.js';
 import { conceptMeta, EDAM_DATA_RETRIEVAL, SCHEMA_SCHOLARLY_ARTICLE } from './_concepts.js';
 import { doiStringSchema, normalizePmid, pmcidStringSchema, pmidStringSchema } from './_schemas.js';
 import { escapeMarkdownInline, escapeMarkdownTableCell, sliceAtWordBoundary } from './_text.js';
+import { hasVisibleText } from './_visible-text.js';
 /**
  * Canonical digits of a PMC ID {@link pmcidStringSchema} accepted: the `PMC`
  * prefix dropped in any case, and leading zeros stripped the way
@@ -68,6 +82,31 @@ function matchesSectionFilter(title, lowerFilter) {
 function lowerCase(s) {
     return s.toLowerCase();
 }
+/**
+ * Split a `sections` filter into the terms it filters on and the paths of its
+ * blank elements. An exactly-empty element is skipped — form clients send one
+ * for a field left untouched — so `[""]` filters on nothing and `["Methods", ""]`
+ * on Methods alone. An element with no visible character (`hasVisibleText`)
+ * names no heading — as a substring, a single space matches every multi-word
+ * title and a zero-width space usually none — so it is reported by its index
+ * (`sections.1`) instead. A kept term is trimmed of surrounding whitespace, so
+ * `[" Methods"]` matches what `["Methods"]` does — as a substring, a padded
+ * term misses every heading the padding does not happen to fit. Whitespace
+ * inside a term and every other character are matched literally. (#186)
+ */
+function splitSectionFilter(sections = []) {
+    const blank = [];
+    const terms = [];
+    for (const [index, term] of sections.entries()) {
+        if (term === '')
+            continue;
+        if (hasVisibleText(term))
+            terms.push(term.trim());
+        else
+            blank.push(`sections.${index}`);
+    }
+    return { blank, terms };
+}
 /**
  * Prune a section tree to the branches a `sections` filter selects, matching
  * titles at every nesting depth rather than the top level alone. (#126)
@@ -252,6 +291,28 @@ function applyAssetFilters(article, filters) {
     const surviving = matchedSectionTitles(article.sections, filters.sections.map(lowerCase));
     return withAssets(article, assets.filter((a) => a.sectionTitle !== undefined && surviving.has(a.sectionTitle)));
 }
+/**
+ * The top-level sections the `sections` filter and the `maxSections` slice
+ * select, in order. Both act on each top-level section independently or cut a
+ * prefix, so applied to the body alone this returns exactly the body prefix of
+ * what it returns for body plus back matter — which is how {@link
+ * bodySectionCount} finds where the back matter starts.
+ */
+function selectSections(sections, filters) {
+    const pruned = filters.sections?.length
+        ? pruneSections(sections, filters.sections.map(lowerCase))
+        : sections;
+    return filters.maxSections === undefined ? pruned : pruned.slice(0, filters.maxSections);
+}
+/**
+ * How many leading entries of the filtered `sections` are body sections, the
+ * rest being back matter: the filter applied to the parsed body alone. The depth
+ * clamp that follows the filter maps sections one to one, so the count holds for
+ * the filtered article. (#206)
+ */
+function bodySectionCount(parsed, filters) {
+    return selectSections(parsed.sections, filters).length;
+}
 /**
  * Apply the requested section/reference/table/asset filters, then clamp the
  * section tree to the depth the output schema carries. All of it runs here so every path
@@ -269,13 +330,7 @@ function applyAssetFilters(article, filters) {
  * folded-away section survives in the text it was folded into. (#111, #130)
  */
 function applyPmcFilters(article, filters) {
-    let out = article;
-    if (filters.sections?.length) {
-        out = { ...out, sections: pruneSections(out.sections, filters.sections.map(lowerCase)) };
-    }
-    if (filters.maxSections !== undefined) {
-        out = { ...out, sections: out.sections.slice(0, filters.maxSections) };
-    }
+    let out = { ...article, sections: selectSections(article.sections, filters) };
     if (!filters.includeReferences) {
         const { references: _, ...rest } = out;
         out = rest;
@@ -285,11 +340,12 @@ function applyPmcFilters(article, filters) {
     return { ...out, sections: clampSectionDepth(out.sections) };
 }
 /**
- * True when a `sections` filter removed every body section from an article that
- * actually had sections upstream — the signal that the requested headings
- * matched nothing, as opposed to the article genuinely shipping no body. Only
- * the `sections` filter can zero a non-empty list: `maxSections` carries a
- * `.min(1)` floor, so it never reduces to zero. (#80)
+ * True when a `sections` filter removed every section, back matter included,
+ * from an article that actually had sections upstream — the signal that the
+ * requested headings matched nothing, as opposed to the article genuinely
+ * shipping no body. Only the `sections` filter can zero a non-empty list:
+ * `maxSections` carries a `.min(1)` floor, so it never reduces to zero. (#80,
+ * #206)
  */
 function isSectionFilterMiss(before, after, sectionFilter) {
     return (Boolean(sectionFilter?.length) && before.sections.length > 0 && after.sections.length === 0);
@@ -301,10 +357,21 @@ function isSectionFilterMiss(before, after, sectionFilter) {
  * while carrying nothing to read. Distinct from {@link isSectionFilterMiss},
  * which needs a non-empty pre-filter body: the two never overlap. Evaluated
  * against the *pre-filter* article so a `sections` filter can't be mistaken for
- * an upstream absence. (#86)
+ * an upstream absence, and before {@link withBackMatter}, so acknowledgments and
+ * a data-availability note alone are no body and the chain still moves on to the
+ * next tier. (#86, #206)
+ */
+function isBodylessArticle(parsed) {
+    return parsed.sections.length === 0;
+}
+/**
+ * The parsed article with its back-matter sections appended after the body
+ * ones, where every filter, slice, and budget downstream treats them as ordinary
+ * sections, and with no `backSections` field of its own left to reach the
+ * output. (#206)
  */
-function isBodylessArticle(before) {
-    return before.sections.length === 0;
+function withBackMatter({ backSections, ...article }) {
+    return backSections ? { ...article, sections: [...article.sections, ...backSections] } : article;
 }
 /** Pick the best human-readable identifier for an article, for recovery notices
  *  and character-budget accounting. Treats empty strings as absent — EPMC-only
@@ -325,7 +392,7 @@ function articleDisplayId(a) {
 function buildSectionFilterMissNotice(affectedIds, sectionFilter) {
     const terms = sectionFilter.join(', ');
     const subject = affectedIds.length === 1 ? `article ${affectedIds[0]}` : `articles ${affectedIds.join(', ')}`;
-    return `No section or subsection title, at any nesting depth, matched the requested section filter (${terms}) for ${subject}. The full text was retrieved but every body section was filtered out. Retry without \`sections\`, or filter on broader headings such as Introduction, Methods, Results, or Discussion.`;
+    return `No section or subsection title, at any nesting depth, matched the requested section filter (${terms}) for ${subject}. The full text was retrieved but every section, back matter included, was filtered out. Retry without \`sections\`, or filter on broader headings such as Introduction, Methods, Results, or Discussion.`;
 }
 /**
  * Compose the recovery notice for identifiers whose only retrievable record was
@@ -376,7 +443,7 @@ const SectionSchema = z
     text: z.string().describe('Section body text'),
     subsections: z.array(SubsectionSchema).optional().describe('Nested subsections'),
 })
-    .describe('Article body section');
+    .describe('Article section, from the body or from the back matter after it');
 const AuthorSchema = z
     .object({
     collectiveName: z.string().optional().describe('Group name'),
@@ -432,14 +499,17 @@ const TableSchema = z
     sectionTitle: z
         .string()
         .optional()
-        .describe('Title of the innermost section enclosing the table, wherever that section sits — body, `<back>` matter, or an appendix all count, and in back matter the section name is the only positional cue there is. Absent only for a table inside no section at all, such as a `<floats-group>` deposit.'),
+        .describe('Title of the innermost titled section enclosing the table — a body section or a back-matter one such as an appendix — as that section is titled in `sections`, or, for a heading nested deeper than `sections` carries, as its heading line inside the text of the section that contains it. A `sections` filter keeps the table with that section. In back matter the section name is the only positional cue there is. Absent for a table inside no titled section, such as a `<floats-group>` deposit.'),
     headerRowCount: z
         .number()
         .describe('How many leading `rows` entries are header rows — a `<thead>` block, or leading rows made entirely of `<th>`. 0 when the table declares none. Several header rows stack: read one column top to bottom for its full header path.'),
     rows: z
         .array(z.array(z.string()).describe('One row, as cell text by grid column'))
-        .describe('Cell text by row, in document order, one entry per grid column. `colspan` and `rowspan` are expanded, so a cell covering several columns or rows repeats its text across each cell it covers and a well-formed table is rectangular — align on position from the left, and read a repeated value as one spanning cell rather than several measurements. Empty when `unextractableReason` is set.'),
-    footnotes: z.string().optional().describe('`<table-wrap-foot>` text, flattened to one string'),
+        .describe('Cell text by row, in document order, one entry per grid column. `colspan` and `rowspan` are expanded, so a cell covering several columns or rows repeats its text across each cell it covers and a well-formed table is rectangular — align on position from the left, and read a repeated value as one spanning cell rather than several measurements. A line break in a cell — a `<break/>`, a paragraph, or a list item in the source — is kept as `\\n`, so `1.08\\n2.44` is two values; superscripts and other inline markup are never spaced (`0.108a`). Empty when `unextractableReason` is set.'),
+    footnotes: z
+        .string()
+        .optional()
+        .describe('`<table-wrap-foot>` text, one line per footnote or paragraph, joined by `\\n`. A footnote marker deposited as a `<label>` leads its line, followed by a space (`* No patient …`).'),
     unextractableReason: z
         .enum(['cals-tgroup', 'graphic-only', 'no-rows'])
         .optional()
@@ -477,7 +547,7 @@ const AssetSchema = z
     sectionTitle: z
         .string()
         .optional()
-        .describe('Title of the innermost section enclosing the asset, wherever that section sits — body, `<back>` matter, or an appendix all count. Absent for an asset inside no section at all, such as a `<floats-group>` deposit.'),
+        .describe('Title of the innermost titled section enclosing the asset — a body section or a back-matter one such as an appendix — as that section is titled in `sections`, or, for a heading nested deeper than `sections` carries, as its heading line inside the text of the section that contains it. Absent for an asset inside no titled section, such as a `<floats-group>` deposit.'),
     href: z
         .string()
         .optional()
@@ -518,7 +588,9 @@ const PmcArticleSchema = z
     keywords: z.array(z.string()).optional().describe('Keywords'),
     articleType: z.string().optional().describe('Article type'),
     publicationDate: PublicationDateSchema.optional(),
-    sections: z.array(SectionSchema).describe('Article body sections'),
+    sections: z
+        .array(SectionSchema)
+        .describe('Article sections in source order: the body, then the back matter — acknowledgments, notes and declarations, footnotes, glossary, appendices. A back-matter element with no heading of its own is titled by its kind, such as `Footnotes` or `Appendix`.'),
     tables: z
         .array(TableSchema)
         .optional()
@@ -526,7 +598,7 @@ const PmcArticleSchema = z
     assets: z
         .array(AssetSchema)
         .optional()
-        .describe('Every `<fig>` and `<supplementary-material>` the article carries, in document order — from the body and from `<floats-group>`, `<back>` and appendices alike. Each one lifted from the body leaves a `[Figure: <label>]` or `[Supplementary: <label>]` marker at its position in the section text, so reading order survives the lift. Absent when the article deposits none, when `includeAssets` is false, or when a `sections` filter left none standing.'),
+        .describe('Every `<fig>` and `<supplementary-material>` the article carries, in document order — from the body and from `<floats-group>`, `<back>` and appendices alike. Each one lifted from a section, body or back matter, leaves a `[Figure: <label>]` or `[Supplementary: <label>]` marker at its position in the section text, so reading order survives the lift. Absent when the article deposits none, when `includeAssets` is false, or when a `sections` filter left none standing.'),
     references: z.array(ReferenceSchema).optional().describe('Reference list'),
     epmcId: z
         .string()
@@ -552,11 +624,11 @@ const UnpaywallArticleSchema = z
     pmcId: z
         .string()
         .optional()
-        .describe('PMC ID this article was requested under, in `PMC<digits>` form — present for `pmcids` input, absent for `pmids` and `dois` input. Ties the article back to the requested identifier, which `unavailable[]` keys on for the ids that found nothing.'),
+        .describe('PMC ID this article was requested under, in `PMC<digits>` form — present when a `pmcids` entry named it, absent when it was requested under a PMID or DOI. When several identifiers name one article, it is requested under the first to reach it: `pmcids`, then `pmids`, then `dois`. Ties the article back to the requested identifier, which `unavailable[]` keys on for the ids that found nothing.'),
     pmid: z
         .string()
         .optional()
-        .describe('PubMed ID when input was `pmids`; absent for `pmcids` and `dois` input'),
+        .describe('PubMed ID this article was requested under — present when it was requested under a `pmids` entry, absent when under a PMC ID or DOI (see `pmcId` for which identifier an article several of them name is requested under)'),
     pubmedUrl: z.string().optional().describe('PubMed URL — present when `pmid` is set'),
     doi: z.string().describe('DOI used to locate the open-access copy'),
     sourceUrl: z.string().describe('URL the content was fetched from'),
@@ -638,7 +710,9 @@ const UnavailableSchema = z
     id: z
         .string()
         .describe('Identifier the chain could not resolve — PMID, PMCID, or DOI per `idType`'),
-    idType: z.enum(['pmid', 'pmcid', 'doi']).describe('Which input branch the id came from'),
+    idType: z
+        .enum(['pmid', 'pmcid', 'doi'])
+        .describe('Which input field the id was sent in — `pmids`, `pmcids`, or `dois` respectively'),
     reason: UnavailableReasonSchema,
     triedTiers: z
         .array(TriedTierSchema)
@@ -699,7 +773,7 @@ const TruncatedSectionSchema = z
         .optional()
         .describe('Per-subsection accounting for a shortened section, in document order, including subsections dropped for budget — where inside the section the cut landed. Absent when the section was returned whole or carries no subsections.'),
 })
-    .describe('Character accounting for one body section of a budgeted article');
+    .describe('Character accounting for one section of a budgeted article');
 const TruncatedArticleSchema = z
     .object({
     id: z
@@ -707,7 +781,7 @@ const TruncatedArticleSchema = z
         .describe('Identifier for the article — PMCID, PMID, DOI, or Europe PMC id, whichever the article carries first'),
     source: z
         .enum(['pmc', 'unpaywall'])
-        .describe('Which output shape was budgeted: `pmc` budgets body sections and subsections, `unpaywall` budgets the single `content` body'),
+        .describe('Which output shape was budgeted: `pmc` budgets sections and subsections, `unpaywall` budgets the single `content` body'),
     originalCharacters: z
         .number()
         .describe('Body characters this article carried before the budget pass'),
@@ -727,7 +801,7 @@ const TruncatedArticleSchema = z
     omittedAssets: z
         .number()
         .optional()
-        .describe('Figures and supplementary items this article dropped whole because the budget left no room once sections and tables were served. An asset is never returned with a truncated caption, so it is either returned complete or counted here. Absent when none were dropped.'),
+        .describe('Figures and supplementary items this article dropped whole because the budget left no room once body sections and tables were served. An asset is never returned with a truncated caption, so it is either returned complete or counted here. Absent when none were dropped.'),
     omittedAssetNames: z
         .array(z.string())
         .optional()
@@ -752,7 +826,7 @@ const TruncationSchema = z
         .describe('Body characters the shortened articles carry in this response'),
     omittedSections: z
         .number()
-        .describe('Body sections and subsections dropped entirely because an article budget was exhausted before reaching them. A dropped section counts once, together with its subsections. Always 0 in `outline` mode, which keeps every heading.'),
+        .describe('Sections and subsections, back matter included, dropped entirely because an article budget was exhausted before reaching them. Back matter is reached last, after tables and assets. A dropped section counts once, together with its subsections. Always 0 in `outline` mode, which keeps every heading.'),
     omittedTables: z
         .number()
         .optional()
@@ -779,15 +853,54 @@ const DeferredSchema = z
         .describe('Articles the chain resolved but withheld to stay under the ceiling'),
     idType: z
         .enum(['pmid', 'pmcid', 'doi'])
-        .describe('Which input branch the deferred ids belong to — re-submit them as `pmids`, `pmcids`, or `dois` respectively. Matches the `idType` on `unavailable` entries.'),
+        .optional()
+        .describe('The input field every deferred id was sent in — re-submit them as `pmids`, `pmcids`, or `dois` respectively. Matches the `idType` on `unavailable` entries. Absent when the deferred ids came from more than one field; `pmcids` / `pmids` / `dois` then group them.'),
     ids: z
         .array(z.string())
-        .describe('Identifiers of the deferred articles, in response order, keyed as they were requested (PMC IDs in `PMC<digits>` form). Re-call `pubmed_fetch_fulltext` with these under the `idType` branch and the same other inputs. Never contains an id from `unavailable`.'),
+        .describe('Identifiers of the deferred articles, in response order, keyed as they were requested (PMC IDs in `PMC<digits>` form). Re-call `pubmed_fetch_fulltext` with these under the `idType` field — or, when `idType` is absent, with the `pmcids` / `pmids` / `dois` lists below — and the same other inputs. Never contains an id from `unavailable`.'),
+    pmcids: z
+        .array(z.string())
+        .optional()
+        .describe('The deferred ids sent as PMC IDs, in response order — re-submit them as `pmcids`. Present only when the deferred ids came from more than one field (so `idType` is absent) and one of them was a PMC ID.'),
+    pmids: z
+        .array(z.string())
+        .optional()
+        .describe('The deferred ids sent as PMIDs, in response order — re-submit them as `pmids`. Present only when the deferred ids came from more than one field (so `idType` is absent) and one of them was a PMID.'),
+    dois: z
+        .array(z.string())
+        .optional()
+        .describe('The deferred ids sent as DOIs, in response order — re-submit them as `dois`. Present only when the deferred ids came from more than one field (so `idType` is absent) and one of them was a DOI.'),
     nextDeferredCharacters: z
         .number()
         .describe('Serialized size of the next deferred article — the first entry in `ids`, where the response stopped. Raise `maxResponseCharacters` to at least this to make progress; a smaller article further down `ids` cannot be reached until this one fits.'),
 })
     .describe('Continuation state for articles the whole-response budget withheld. Present only when `maxResponseCharacters` deferred at least one article.');
+const OverLimitSchema = z
+    .object({
+    limit: z
+        .number()
+        .describe('Distinct identifiers one call fetches. The first this many, in routing order — `pmcids`, then `pmids`, then `dois`, request order within each — were fetched; the ids below were not.'),
+    idType: z
+        .enum(['pmid', 'pmcid', 'doi'])
+        .optional()
+        .describe('The input field every over-limit id was sent in — re-submit them as `pmids`, `pmcids`, or `dois` respectively. Absent when the over-limit ids came from more than one field; `pmcids` / `pmids` / `dois` then group them.'),
+    ids: z
+        .array(z.string())
+        .describe('Identifiers past the per-call limit, none of them fetched, in routing order — each listed once, under the first spelling sent (PMC IDs in `PMC<digits>` form). Re-call `pubmed_fetch_fulltext` with these under the `idType` field — or, when `idType` is absent, with the `pmcids` / `pmids` / `dois` lists below — and the same other inputs, at most `limit` per call. Never contains an id from `unavailable` or `deferred`.'),
+    pmcids: z
+        .array(z.string())
+        .optional()
+        .describe('The over-limit ids sent as PMC IDs, in routing order — re-submit them as `pmcids`. Present only when the over-limit ids came from more than one field (so `idType` is absent) and one of them was a PMC ID.'),
+    pmids: z
+        .array(z.string())
+        .optional()
+        .describe('The over-limit ids sent as PMIDs, in routing order — re-submit them as `pmids`. Present only when the over-limit ids came from more than one field (so `idType` is absent) and one of them was a PMID.'),
+    dois: z
+        .array(z.string())
+        .optional()
+        .describe('The over-limit ids sent as DOIs, in routing order — re-submit them as `dois`. Present only when the over-limit ids came from more than one field (so `idType` is absent) and one of them was a DOI.'),
+})
+    .describe('Identifiers the call named past the per-call fetch limit, returned unfetched for a follow-up call. Present only when the call named more than `limit` distinct identifiers. Separate from `deferred`, which lists articles that were fetched but withheld by `maxResponseCharacters`.');
 /** True when the request asked for any budget at all. Without one, every budget
  *  helper returns its input untouched so the response is byte-identical. */
 function budgetRequested(budget) {
@@ -993,11 +1106,16 @@ function allotSectionBudgets(sizes, budget) {
  * or cut — the budget spends on body text and table content, keeping every
  * article citable.
  *
- * Body sections are served first, then tables, then assets, each spending what
- * `maxCharacters` has left, in document order: an item that does not fit is
- * dropped whole and counted, never truncated into a partial grid or a caption cut
- * short. With no `maxCharacters` — a bare `maxCharactersPerSection` request —
- * nothing bounds either list and every entry is kept. (#111, #130)
+ * Body sections are served first, then tables, then assets, then back-matter
+ * sections, each spending what `maxCharacters` has left, in document order. A
+ * table or asset that does not fit is dropped whole and counted, never
+ * truncated into a partial grid or a caption cut short. Back matter comes last
+ * so it never displaces a table or figure: it is shortened or dropped the way
+ * body sections are, from whatever the rest left. The first `bodySections`
+ * entries of `article.sections` are the body; spend order aside, `sections` and
+ * the ledger stay in document order. With no `maxCharacters` — a bare
+ * `maxCharactersPerSection` request — nothing bounds the tables or assets and
+ * every entry is kept. (#111, #130, #206)
  *
  * Returns the article untouched (same object identity) when no budget was
  * requested or nothing exceeded it. A section or subsection left with zero
@@ -1005,7 +1123,7 @@ function allotSectionBudgets(sizes, budget) {
  * keeps it as a heading-only entry. Dropped nodes still appear in the accounting
  * so the caller can see which headings exist. (#81, #143)
  */
-function applyPmcBudget(article, budget) {
+function applyPmcBudget(article, budget, bodySections) {
     const tables = article.tables ?? [];
     const assets = article.assets ?? [];
     if (!budgetRequested(budget) ||
@@ -1016,31 +1134,37 @@ function applyPmcBudget(article, budget) {
     const tablesOriginal = tables.reduce((sum, table) => sum + tableCharacters(table), 0);
     const assetsOriginal = assets.reduce((sum, asset) => sum + assetCharacters(asset), 0);
     const originalCharacters = sizes.reduce((sum, size) => sum + size, 0) + tablesOriginal + assetsOriginal;
-    const allowances = allotSectionBudgets(sizes, budget);
     const kept = [];
     const sectionReports = [];
     let returnedCharacters = 0;
-    article.sections.forEach((section, i) => {
-        const fitted = fitFields(sectionTextFields(section), allowances[i] ?? 0);
-        const fit = fitSectionTree(section, fitted, { i: 0 }, budget.overflowMode);
-        returnedCharacters += fit.entry.returnedCharacters;
-        sectionReports.push(fit.entry);
-        if (fit.kept)
-            kept.push(fit.kept);
-    });
-    const omittedSections = countDroppedSections(sectionReports, budget.overflowMode);
-    // Sections are served first, then tables, then assets — each spending whatever
-    // `maxCharacters` has left. A bare per-section budget sets no total, so nothing
-    // bounds either list.
+    // Each stage spends whatever `maxCharacters` has left. A bare per-section
+    // budget sets no total, so nothing bounds the tables or assets.
     const remainingAllowance = () => budget.maxCharacters === undefined
         ? Number.POSITIVE_INFINITY
         : Math.max(budget.maxCharacters - returnedCharacters, 0);
+    const fitSections = (sections, total) => {
+        const allowances = allotSectionBudgets(sections.map(sectionCharacters), {
+            ...budget,
+            maxCharacters: total,
+        });
+        sections.forEach((section, i) => {
+            const fitted = fitFields(sectionTextFields(section), allowances[i] ?? 0);
+            const fit = fitSectionTree(section, fitted, { i: 0 }, budget.overflowMode);
+            returnedCharacters += fit.entry.returnedCharacters;
+            sectionReports.push(fit.entry);
+            if (fit.kept)
+                kept.push(fit.kept);
+        });
+    };
+    fitSections(article.sections.slice(0, bodySections), budget.maxCharacters);
     const fittedTables = fitWholeNamed(tables, remainingAllowance(), tableCharacters, tableDisplayName);
     returnedCharacters += fittedTables.spent;
     const omittedTables = fittedTables.omittedNames.length;
     const fittedAssets = fitWholeNamed(assets, remainingAllowance(), assetCharacters, assetDisplayName);
     returnedCharacters += fittedAssets.spent;
     const omittedAssets = fittedAssets.omittedNames.length;
+    fitSections(article.sections.slice(bodySections), budget.maxCharacters === undefined ? undefined : remainingAllowance());
+    const omittedSections = countDroppedSections(sectionReports, budget.overflowMode);
     if (returnedCharacters === originalCharacters &&
         omittedSections === 0 &&
         omittedTables === 0 &&
@@ -1180,11 +1304,46 @@ function buildTruncationNotice(truncation) {
  */
 function buildDeferralNotice(deferred) {
     const spent = deferred.returnedCharacters === 0
-        ? `No article fits the requested maxResponseCharacters of ${deferred.maxResponseCharacters}, so none were returned.`
+        ? `The first article alone exceeds the requested maxResponseCharacters of ${deferred.maxResponseCharacters}, so none were returned.`
         : `Response character budget reached: ${deferred.returnedCharacters} of ${deferred.maxResponseCharacters} characters returned.`;
-    return `${spent} ${deferred.deferredCount} resolved article(s) were deferred whole: ${deferred.ids.join(', ')}. Re-call pubmed_fetch_fulltext with those ids under \`${deferred.idType}s\` to retrieve them, or raise maxResponseCharacters to at least ${deferred.nextDeferredCharacters} — the size of the next deferred article.`;
+    const resend = deferred.idType
+        ? `Re-call pubmed_fetch_fulltext with those ids under \`${deferred.idType}s\``
+        : `Re-call pubmed_fetch_fulltext with each id under its own field (${idFieldLists(deferred)})`;
+    return `${spent} ${deferred.deferredCount} resolved article(s) were deferred whole: ${deferred.ids.join(', ')}. ${resend} to retrieve them, or raise maxResponseCharacters to at least ${deferred.nextDeferredCharacters} — the size of the next deferred article.`;
+}
+/**
+ * Compose the recovery notice for identifiers past the per-call fetch limit:
+ * how many were left unfetched, which ones, and where to resend them — so a
+ * caller reading only `content[]` can retrieve the rest without inspecting
+ * `overLimit`. (#222)
+ */
+function buildOverLimitNotice(overLimit) {
+    const resend = overLimit.idType
+        ? `Re-call pubmed_fetch_fulltext with those ids under \`${overLimit.idType}s\``
+        : `Re-call pubmed_fetch_fulltext with each id under its own field (${idFieldLists(overLimit)})`;
+    return `This call fetched the first ${overLimit.limit} distinct identifiers; ${overLimit.ids.length} more were not fetched: ${overLimit.ids.join(', ')}. ${resend}, at most ${overLimit.limit} per call, to retrieve them.`;
+}
+/**
+ * The per-field lists of ids handed back across fields, in field order —
+ * `` `pmcids`: PMC1; `dois`: 10.1/x `` — or `''` when `idType` covers them all.
+ */
+function idFieldLists(group) {
+    return ['pmcids', 'pmids', 'dois']
+        .flatMap((field) => {
+        const ids = group[field];
+        return ids?.length ? [`\`${field}\`: ${ids.join(', ')}`] : [];
+    })
+        .join('; ');
 }
 // ─── Tool Definition ─────────────────────────────────────────────────────────
+/**
+ * Distinct identifiers one call fetches across `pmcids`, `pmids`, and `dois`,
+ * in routing order; the rest are returned unfetched in `overLimit`. Bounds the
+ * candidates every tier works per call. (#192, #222)
+ */
+const FETCH_LIMIT = 10;
+/** Distinct identifiers one call may name across the three fields. (#222) */
+const MAX_IDENTIFIERS = 50;
 /**
  * Compose the tool description for the fallback tiers enabled in this
  * deployment. PMC EFetch is always present; Europe PMC (`EUROPEPMC_ENABLED`)
@@ -1193,7 +1352,7 @@ function buildDeferralNotice(deferred) {
  * recoveries that silently can't happen.
  */
 export function buildFulltextDescription(tiers) {
-    const base = 'Fetch full-text articles from PubMed Central with structured sections, tables, and references.';
+    const base = 'Fetch full-text articles from PubMed Central as structured sections — the body, then back matter such as acknowledgments, declarations, and appendices — with tables and references.';
     const epmcClause = 'Europe PMC `fullTextXML` (structured JATS for records with a PMC counterpart)';
     const unpaywallClause = 'Unpaywall — publisher-hosted or institutional open-access copies as HTML-as-Markdown or PDF-as-text';
     let fallback;
@@ -1217,7 +1376,7 @@ export function buildFulltextDescription(tiers) {
             : tiers.unpaywall
                 ? '; DOIs with no PMC copy recover via Unpaywall open access'
                 : '';
-    const input = `Provide exactly one of \`pmcids\` (PMC IDs directly), \`pmids\` (PubMed IDs, auto-resolved), or \`dois\` (DOIs, auto-resolved to PMC via the ID Converter${doiTail}).`;
+    const input = `Name articles by \`pmcids\` (PMC IDs directly), \`pmids\` (PubMed IDs, auto-resolved), \`dois\` (DOIs, auto-resolved to PMC via the ID Converter${doiTail}), or any mix of the three — up to ${MAX_IDENTIFIERS} distinct identifiers; the first ${FETCH_LIMIT} are fetched per call, the rest returned in \`overLimit\`; an article several of them name is fetched and returned once.`;
     const budget = 'Two independent character controls: `maxCharacters` caps body text per article, `maxResponseCharacters` caps the whole response and defers articles past the ceiling whole, listing them in `deferred.ids` for a follow-up call.';
     return `${base} ${fallback} ${input} ${budget}`;
 }
@@ -1233,28 +1392,42 @@ export const fetchFulltextTool = tool('pubmed_fetch_fulltext', {
     // Only the ID routing's `idConvert` calls run unwrapped. Every Europe PMC and
     // Unpaywall call sits behind a catch that folds the failure into
     // `unavailable[].triedTiers`, so their service reasons never reach a caller
-    // and are not declared here. (#168)
-    errors: [...NCBI_SERVICE_ERRORS],
+    // and are not declared here. (#168) `blank_filter` is the handler's own input
+    // check, raised before any upstream request. (#186)
+    errors: [
+        ...NCBI_SERVICE_ERRORS,
+        {
+            reason: 'blank_filter',
+            code: JsonRpcErrorCode.ValidationError,
+            when: 'A `sections` element holds no visible character — only whitespace, or invisible characters such as a zero-width space — so it names no heading. An exactly-empty element is not blank here; it is skipped.',
+            recovery: 'Give each named `sections` element a heading term such as Methods, or make it an empty string, which is skipped; omit `sections` for no filter. The same blank element will be rejected again.',
+            retryable: false,
+        },
+    ],
+    // Never advertised; rewritten to the canonical key before the schema parses.
+    // Singular spellings sibling tools and this tool's own output use; a lone
+    // string under one becomes a one-element array. (#221)
+    inputAliases: { pmcid: 'pmcids', pmcId: 'pmcids', pmid: 'pmids', doi: 'dois' },
     input: z
         .object({
         pmcids: z
             .array(pmcidStringSchema)
             .min(1)
-            .max(10)
+            .max(MAX_IDENTIFIERS)
             .optional()
-            .describe('PMC IDs to fetch (e.g. ["PMC9575052"]). Provide exactly one of `pmcids`, `pmids`, or `dois`. PMC IDs with no retrievable full text fall through to Europe PMC, then to Unpaywall on the DOI the chain resolves for them.'),
+            .describe(`PMC IDs to fetch (e.g. ["PMC9575052"]). Combinable with \`pmids\` and \`dois\` — up to ${MAX_IDENTIFIERS} distinct identifiers across the three; the first ${FETCH_LIMIT} are fetched per call, the rest returned in \`overLimit\`. PMC IDs with no retrievable full text fall through to Europe PMC, then to Unpaywall on the DOI the chain resolves for them.`),
         pmids: z
             .array(pmidStringSchema)
             .min(1)
-            .max(10)
+            .max(MAX_IDENTIFIERS)
             .optional()
-            .describe('PubMed IDs. Provide exactly one of `pmcids`, `pmids`, or `dois`. Articles in PMC are returned as structured JATS; articles not in PMC fall through to Europe PMC (when EPMC has a `fullTextXML`), then to Unpaywall when `UNPAYWALL_EMAIL` is set and a DOI is available.'),
+            .describe(`PubMed IDs. Combinable with \`pmcids\` and \`dois\` — up to ${MAX_IDENTIFIERS} distinct identifiers across the three; the first ${FETCH_LIMIT} are fetched per call, the rest returned in \`overLimit\`. Articles in PMC are returned as structured JATS; articles not in PMC fall through to Europe PMC (when EPMC has a \`fullTextXML\`), then to Unpaywall when \`UNPAYWALL_EMAIL\` is set and a DOI is available.`),
         dois: z
             .array(doiStringSchema)
             .min(1)
-            .max(10)
+            .max(MAX_IDENTIFIERS)
             .optional()
-            .describe('DOIs to resolve (e.g. ["10.21203/rs.3.rs-9010375/v1"]), one per element. Provide exactly one of `pmcids`, `pmids`, or `dois`. Resolved to a PMCID via the PMC ID Converter and returned as structured JATS when the article is in PMC; DOIs with no PMC counterpart (preprints, EPMC-only OA) fall through to Europe PMC, then Unpaywall, when those layers are enabled.'),
+            .describe(`DOIs to resolve (e.g. ["10.21203/rs.3.rs-9010375/v1"]), one per element. Combinable with \`pmcids\` and \`pmids\` — up to ${MAX_IDENTIFIERS} distinct identifiers across the three; the first ${FETCH_LIMIT} are fetched per call, the rest returned in \`overLimit\`. Resolved to a PMCID via the PMC ID Converter and returned as structured JATS when the article is in PMC; DOIs with no PMC counterpart (preprints, EPMC-only OA) fall through to Europe PMC, then Unpaywall, when those layers are enabled.`),
         includeReferences: z
             .boolean()
             .default(false)
@@ -1271,41 +1444,52 @@ export const fetchFulltextTool = tool('pubmed_fetch_fulltext', {
             .number()
             .int()
             .min(1)
-            .max(50)
             .optional()
-            .describe('Maximum top-level body sections. Applies to `source=pmc` results only.'),
+            .describe('Maximum top-level sections. Back-matter sections count and follow the body, so a cap drops them first. Applies to `source=pmc` results only.'),
         sections: z
             .array(z.string())
             .optional()
-            .describe('Filter to specific sections by title (e.g. ["Introduction", "Methods", "Results", "Discussion"]). A term matches a section or subsection title at any nesting depth, case-insensitively, as a substring — "resul" matches "Results". A section whose own title matches is returned whole; one kept only because a nested subsection matched keeps its heading as a breadcrumb, with its own text cleared and only the matching branch beneath it. Tables and assets narrow with the filter: one whose section did not survive, or that names no section, is dropped. Applies to `source=pmc` results only.'),
+            .describe('Filter to specific sections by title (e.g. ["Introduction", "Methods", "Results", "Discussion"]). A term matches a section or subsection title at any nesting depth, case-insensitively, as a substring — "resul" matches "Results". Back-matter sections match the same way: by their own titles, or by their kind when they carry neither a title nor a label — "appendix" matches a section titled "Appendix A", "footnotes" an untitled footnote group. A label is never matched, so an appendix labelled "Appendix A" under a title of its own matches only on that title. A section whose own title matches is returned whole; one kept only because a nested subsection matched keeps its heading as a breadcrumb, with its own text cleared and only the matching branch beneath it. Tables and assets narrow with the filter: one whose section did not survive, or that names no section, is dropped. Empty strings are skipped, so `[""]` applies no filter; an element of only whitespace or invisible characters, such as a zero-width space, is rejected. Applies to `source=pmc` results only.'),
         maxCharacters: z
             .number()
             .int()
             .min(1)
-            .max(1_000_000)
             .optional()
-            .describe('Per-article budget for body text, in characters. Counts `source=pmc` section and subsection text — which carries the inline blocks the parser renders in place, such as lists, definition lists, block quotes, boxed text, preformatted blocks and displayed formulae — plus table label, caption, cell and footnote text and asset label, caption and `href` text; or the `source=unpaywall` `content` body. Titles, abstracts, identifiers, and references are never counted or shortened. Shortened text ends at the last word boundary inside its allowance, so it can come back a few characters under it. The counted unit is that text alone — the Markdown grid `content[]` renders around the cells (pipes, padding, the divider row, headings) is scaffolding this budget does not measure, so a table renders longer than it costs here. Sections are served first, then tables, then assets, each spending what is left, in document order — admission stops at the first entry that does not fit, and every entry from there on is dropped whole rather than cut mid-row or returned with a shortened caption, counted in `truncation.omittedTables` / `truncation.omittedAssets` and named in `truncation.articles[].omittedTableNames` / `omittedAssetNames`. Applied after `sections`, `maxSections`, `includeReferences`, `includeTables`, and `includeAssets`, so semantic filtering is unaffected. This knob alone bounds only bodies: the response-wide ceiling it implies is this value times the number of articles returned, plus every uncounted field. Use `maxResponseCharacters` for a true whole-response ceiling. Omit for the full body.'),
+            .describe('Per-article budget for body text, in characters. Counts `source=pmc` section and subsection text — which carries the inline blocks the parser renders in place, such as lists, definition lists, block quotes, boxed text, preformatted blocks and displayed formulae — plus table label, caption, cell and footnote text and asset label, caption and `href` text; or the `source=unpaywall` `content` body. Titles, abstracts, identifiers, and references are never counted or shortened. Shortened text ends at the last word boundary inside its allowance, so it can come back a few characters under it. The counted unit is that text alone — the Markdown grid `content[]` renders around the cells (pipes, padding, the divider row, headings) is scaffolding this budget does not measure, so a table renders longer than it costs here. Body sections are served first, then tables, then assets, then back-matter sections, each spending what is left, in document order. For tables and assets, admission stops at the first entry that does not fit, and every entry from there on is dropped whole rather than cut mid-row or returned with a shortened caption, counted in `truncation.omittedTables` / `truncation.omittedAssets` and named in `truncation.articles[].omittedTableNames` / `omittedAssetNames`. Back matter takes only what remains and is shortened or dropped as body sections are; `sections` still returns it after the body. Applied after `sections`, `maxSections`, `includeReferences`, `includeTables`, and `includeAssets`, so semantic filtering is unaffected. This knob alone bounds only bodies: the response-wide ceiling it implies is this value times the number of articles returned, plus every uncounted field. Use `maxResponseCharacters` for a true whole-response ceiling. Omit for the full body.'),
         maxCharactersPerSection: z
             .number()
             .int()
             .min(1)
-            .max(1_000_000)
             .optional()
-            .describe('Budget for a single top-level body section, in characters, counting the section text plus its subsections. Combine with `maxCharacters` to cap both one section and the article; the tighter of the two wins. Applies to `source=pmc` results only.'),
+            .describe('Budget for a single top-level section, in characters, counting the section text plus its subsections. Combine with `maxCharacters` to cap both one section and the article; the tighter of the two wins. Applies to `source=pmc` results only.'),
         maxResponseCharacters: z
             .number()
             .int()
             .min(1)
-            .max(1_000_000)
             .optional()
-            .describe('Opt-in ceiling for the whole response, in characters — the true response-wide counterpart to the per-article `maxCharacters`. Each article is measured as the JSON record it is returned as, after every filter and the per-article body budget: title, abstract, body sections, references, identifiers, license and source metadata — every field it carries. One ledger covers all tiers, so PMC-, Europe PMC-, and Unpaywall-served articles spend the same budget. Articles are kept in response order until the next one would cross the ceiling; that article and the rest are deferred whole (never partially populated) and listed in `deferred.ids`. Response envelope fields — counts, `unavailable`, `truncation`, `deferred` itself — are not counted. Omit to return every resolved article.'),
+            .describe('Opt-in ceiling for the whole response, in characters — the true response-wide counterpart to the per-article `maxCharacters`. Each article is measured as the JSON record it is returned as, after every filter and the per-article body budget: title, abstract, sections, references, identifiers, license and source metadata — every field it carries. One ledger covers all tiers, so PMC-, Europe PMC-, and Unpaywall-served articles spend the same budget. Articles are kept in response order until the next one would cross the ceiling; that article and the rest are deferred whole (never partially populated) and listed in `deferred.ids`. Response envelope fields — counts, `unavailable`, `truncation`, `deferred` itself — are not counted. Omit to return every resolved article.'),
         overflowMode: z
             .enum(['truncate', 'outline'])
             .default('truncate')
-            .describe('How to spend `maxCharacters` across an article that exceeds it. truncate: fill sections in document order, so early sections stay whole, the section the budget runs out in is cut, and every section or subsection past that point is dropped (counted in `truncation.omittedSections`). outline: split the budget evenly so every section and subsection keeps its heading, and an excerpt as far as the budget reaches — a heading the budget left empty is marked as such in the rendered text. Use it to survey what an article contains before requesting specific `sections`. Ignored when no budget is set, and identical for `source=unpaywall` bodies, which have no headings to preserve.'),
+            .describe('How to spend `maxCharacters` across an article that exceeds it. truncate: fill sections in document order, so early sections stay whole, the section the budget runs out in is cut, and every section or subsection past that point is dropped (counted in `truncation.omittedSections`). outline: split the budget evenly so every section and subsection keeps its heading, and an excerpt as far as the budget reaches — a heading the budget left empty is marked as such in the rendered text. In both modes the body sections spend the budget first and back-matter sections share what the body, tables, and assets leave. Use it to survey what an article contains before requesting specific `sections`. Ignored when no budget is set, and identical for `source=unpaywall` bodies, which have no headings to preserve.'),
     })
-        .refine((v) => [v.pmcids, v.pmids, v.dois].filter((b) => b !== undefined).length === 1, {
-        message: 'Provide exactly one of `pmcids`, `pmids`, or `dois` (not zero, not more).',
+        // Counted in each field's canonical form, the one its chain keys on, so the
+        // ceiling is settled before any upstream request; the handler then fetches
+        // the first FETCH_LIMIT the same way. (#192, #222)
+        .superRefine((v, refinement) => {
+        const distinct = new Set(requestedIds(v).map((r) => r.key));
+        if (distinct.size === 0) {
+            refinement.addIssue({
+                code: 'custom',
+                message: 'Provide at least one of `pmcids`, `pmids`, or `dois`.',
+            });
+        }
+        else if (distinct.size > MAX_IDENTIFIERS) {
+            refinement.addIssue({
+                code: 'custom',
+                message: `\`pmcids\`, \`pmids\`, and \`dois\` together name ${distinct.size} distinct identifiers; a call accepts at most ${MAX_IDENTIFIERS} and fetches the first ${FETCH_LIMIT} — split them across calls.`,
+            });
+        }
     }),
     output: z.object({
         articles: z.array(ArticleSchema).describe('Full-text articles'),
@@ -1315,39 +1499,53 @@ export const fetchFulltextTool = tool('pubmed_fetch_fulltext', {
         unavailable: z
             .array(UnavailableSchema)
             .optional()
-            .describe('Per-identifier explanations for any requested PMIDs, PMCIDs, or DOIs with no returnable full text. `idType` discriminates which branch the id came from. Distinct from `deferred`: nothing here is retrievable by re-calling, and an id never appears in both.'),
+            .describe('Per-identifier explanations for any requested PMIDs, PMCIDs, or DOIs with no returnable full text. `idType` names the field each id was sent in. Distinct from `deferred`: nothing here is retrievable by re-calling, and an id never appears in both. Ids past the per-call limit are listed in `overLimit`, never here.'),
         truncation: TruncationSchema.optional(),
         deferred: DeferredSchema.optional(),
+        overLimit: OverLimitSchema.optional(),
     }),
-    // Recovery guidance for five cases — a `sections` filter that removed every
-    // body section (#80), a record the chain could only retrieve as front matter
+    // Recovery guidance for six cases — a `sections` filter that removed every
+    // section (#80), a record the chain could only retrieve as front matter
     // (#86), a table returned with no cell values (#111), a body the per-article
-    // character budget shortened (#81), and articles the whole-response budget
-    // withheld (#100). Agent-facing context surfaced via
-    // ctx.enrich.notice() to structuredContent and content[]; absent when none
-    // applies.
+    // character budget shortened (#81), articles the whole-response budget
+    // withheld (#100), and identifiers past the per-call fetch limit (#222).
+    // Agent-facing context surfaced via ctx.enrich.notice() to structuredContent
+    // and content[]; absent when none applies.
     enrichment: {
         notice: z
             .string()
             .optional()
-            .describe('Optional guidance for a partial or empty body. A `sections`-filter miss names the requested terms and affected article id(s) and suggests retrying without `sections` or using broader headings. A metadata-only record names the id(s) the chain could retrieve as front matter only and points at `pubmed_fetch_articles` for the abstract. A table returned with no cell values names the affected table(s), the article each came from, and why the cells cannot be recovered. A budgeted response names the characters returned versus carried and points at `truncation`. A response-wide budget that deferred articles names the ids to re-request. Absent when none of those applies.'),
+            .describe('Optional guidance for a partial or empty body. A `sections`-filter miss names the requested terms and affected article id(s) and suggests retrying without `sections` or using broader headings. A metadata-only record names the id(s) the chain could retrieve as front matter only and points at `pubmed_fetch_articles` for the abstract. A table returned with no cell values names the affected table(s), the article each came from, and why the cells cannot be recovered. A budgeted response names the characters returned versus carried and points at `truncation`. A response-wide budget that deferred articles names the ids to re-request. Identifiers past the per-call limit are named with the field to resend each under. Absent when none of those applies.'),
         truncated: z
             .boolean()
             .optional()
-            .describe('True when a character budget shortened at least one returned body, or withheld a whole article. Absent when every resolved article is present with its full post-filter body. The per-article body accounting is in `truncation`; the withheld ids are in `deferred`.'),
+            .describe('True when a character budget shortened at least one returned body or withheld a whole article, or when the call named more distinct identifiers than one call fetches. Absent when every requested identifier was fetched and every resolved article is present with its full post-filter body. The per-article body accounting is in `truncation`; the withheld ids are in `deferred`; the unfetched ids are in `overLimit`.'),
     },
     async handler(input, ctx) {
+        const idCount = (input.pmcids?.length ?? 0) + (input.pmids?.length ?? 0) + (input.dois?.length ?? 0);
         ctx.log.info('Executing pubmed_fetch_fulltext', {
             hasPmcids: !!input.pmcids,
             hasPmids: !!input.pmids,
             hasDois: !!input.dois,
-            idCount: (input.pmcids ?? input.pmids ?? input.dois)?.length,
+            idCount,
         });
+        // A blank `sections` element fails the call before any upstream request;
+        // every stage filters on the nonblank terms alone. (#186)
+        const sectionFilter = splitSectionFilter(input.sections);
+        if (sectionFilter.blank.length > 0) {
+            const one = sectionFilter.blank.length === 1;
+            throw ctx.fail('blank_filter', `${sectionFilter.blank.map((path) => `\`${path}\``).join(', ')} ${one ? 'holds' : 'hold'} only whitespace or invisible characters, so ${one ? 'it names' : 'they name'} no section heading.`, { fields: sectionFilter.blank });
+        }
+        const filters = { ...input, sections: sectionFilter.terms };
+        // Settled before any upstream request: every tier below works the fetched
+        // ids alone, and the rest are handed back in `overLimit`. (#222)
+        const { fetched, overLimit: overLimitIds } = splitAtFetchLimit(input);
         // ── Chain tracking ──────────────────────────────────────────────────────
         // Per-input-id tier history (the `triedTiers` array on unavailable entries).
-        // Keys: pmid for `pmids` input, prefixed PMCID for `pmcids` input, doi for
-        // `dois` input. `recoveredIds` collects ids the chain produced an article
-        // for, so we can skip them when building `unavailable[]`.
+        // Keys: canonical PMID for a `pmids` entry, prefixed PMCID for a `pmcids`
+        // entry, first-submitted casing for a `dois` entry — disjoint shapes, so
+        // one map holds all three. `recoveredIds` collects ids the chain produced an
+        // article for, so we can skip them when building `unavailable[]`.
         const chainByInput = new Map();
         const recoveredIds = new Set();
         // Per-input-id set of tiers this deployment has not configured AND that
@@ -1361,16 +1559,17 @@ export const fetchFulltextTool = tool('pubmed_fetch_fulltext', {
             tiers.add(tier);
             unqueriedByInput.set(inputId, tiers);
         };
-        // Back-map from a converter-resolved prefixed PMCID to the input id that
-        // seeded it — a PMID for `pmids` input, a DOI for `dois` input — so the PMC
-        // and EPMC stages attribute recoveries and misses to the original input id.
+        // Back-map from a prefixed PMCID to the input id that owns its record — the
+        // PMC ID itself, or the PMID or DOI the converter placed on it — so the PMC
+        // stage attributes recoveries and misses to the original input id.
         const pmcidToInputId = new Map();
-        // DOI hints captured during pmids→pmcid routing so PMC-misses on the pmids
-        // branch can still reach Unpaywall without re-fetching from PubMed metadata.
-        const pmidContext = new Map();
-        // Ids of returned articles whose `sections` filter removed every body
-        // section — collected across the PMC and EPMC stages to drive one recovery
-        // notice via ctx.enrich.notice (#80).
+        // A DOI the routing learned for a PMC record — from the converter, or from a
+        // `dois` entry that named it — so a PMC miss can still reach Unpaywall
+        // without another lookup, whichever field owns the record.
+        const doiByPmcRecord = new Map();
+        // Ids of returned articles whose `sections` filter removed every section —
+        // collected across the PMC and EPMC stages to drive one recovery notice via
+        // ctx.enrich.notice (#80).
         const sectionFilterMisses = [];
         // Input ids whose PMC or EPMC record carried no body sections at all. Those
         // records are not full-text hits, so the chain continues past them; ids still
@@ -1386,19 +1585,46 @@ export const fetchFulltextTool = tool('pubmed_fetch_fulltext', {
         // caller can re-submit rather than whatever id the article happens to
         // carry — a `pmids` request recovers articles keyed by PMCID. (#100)
         const inputIdByArticle = new Map();
-        // The caller's own spellings of each chain key, so `unavailable[]` and
-        // `deferred.ids` report what was submitted. The `pmids` branch fills it — a
-        // PMID's chain runs on its canonical form — and so does the `dois` branch,
-        // whose chain runs once per DOI however many casings name it. Both also
-        // fold in an input id that resolves to a PMC record another one already
-        // claimed (see `routeToPmc`). Any other key is its own spelling. (#161, #166)
+        // The caller's own spellings of each chain key, each with the field it was
+        // sent in, so `unavailable[]` and `deferred` report what was submitted and
+        // where. A PMID's chain runs on its canonical form and a DOI's once however
+        // many casings name it, so those keys gather several spellings; a PMC ID is
+        // reported in its `PMC<digits>` key form. The first entry is the key's own,
+        // the id that opened the chain; an id that reaches a record another one
+        // already owns is folded in after it (see `joinChain`). (#161, #166, #192)
         const callerIds = new Map();
-        const addCallerId = (key, spelling) => {
+        const addCallerId = (key, callerId) => {
             const spellings = callerIds.get(key) ?? [];
-            if (!spellings.includes(spelling))
-                spellings.push(spelling);
+            if (!spellings.some((s) => s.id === callerId.id && s.idType === callerId.idType)) {
+                spellings.push(callerId);
+            }
             callerIds.set(key, spellings);
         };
+        // A joined spelling's own tiers from before its join, and the length of the
+        // owner's chain at that point: it reports those tiers, then only what the
+        // owner's chain gained afterwards, never a step another id took. (#192)
+        const ownChainOf = new Map();
+        /**
+         * Fold `joiner` into `owner` once both are known to name one record: the
+         * joiner's spellings become caller ids of the owner's chain, so the record is
+         * worked once and every spelling is recovered with it, or reported
+         * unavailable with its own tiers up to the join and the owner's after. (#192)
+         */
+        const joinChain = (joiner, owner) => {
+            const joinerChain = chainByInput.get(joiner) ?? [];
+            const from = chainByInput.get(owner)?.length ?? 0;
+            for (const callerId of callerIds.get(joiner) ?? []) {
+                const own = ownChainOf.get(callerId);
+                const tried = [...(own?.tried ?? []), ...joinerChain.slice(own?.from ?? 0)];
+                ownChainOf.set(callerId, { tried, from });
+                addCallerId(owner, callerId);
+            }
+            callerIds.delete(joiner);
+            chainByInput.delete(joiner);
+            unqueriedByInput.delete(joiner);
+            if (bodylessInputIds.delete(joiner))
+                bodylessInputIds.add(owner);
+        };
         const budget = {
             overflowMode: input.overflowMode,
             ...(input.maxCharacters !== undefined && { maxCharacters: input.maxCharacters }),
@@ -1406,18 +1632,19 @@ export const fetchFulltextTool = tool('pubmed_fetch_fulltext', {
                 maxCharactersPerSection: input.maxCharactersPerSection,
             }),
         };
-        const idType = input.pmids ? 'pmid' : input.pmcids ? 'pmcid' : 'doi';
-        // ── Branch routing → produce buckets the staged chain consumes ──────────
-        let pmcIds = [];
-        let pmidFallbackCandidates = [];
-        let pmcidFallbackCandidates = [];
-        let doiCandidates = [];
-        // Send a converter-resolved PMCID to PMC EFetch under the input id that
-        // named it. A second input id the converter places on the same PMC record
-        // — two DOIs for one article — joins the first one's chain as another
-        // spelling of it: the record is fetched once, and both ids are recovered,
-        // or reported unavailable with that chain, rather than the later id taking
-        // the PMCID over and leaving the earlier one with an empty chain.
+        // ── Routing → produce the buckets the staged chain consumes ─────────────
+        // `pmcids`, then `pmids`, then `dois`: the first id to reach a record owns
+        // it, so the PMC IDs claim their records before any converter answer is
+        // placed. Fallback candidates are bucketed by the field that owns them and
+        // run in that order, which is how a later tier picks a record's owner too.
+        const pmcIds = [];
+        const pending = { pmcid: [], pmid: [], doi: [] };
+        // Send a PMCID to PMC EFetch under the input id that named it. A second
+        // input id that reaches the same PMC record — two DOIs for one article, or
+        // a PMID for a PMC ID already given — joins the first one's chain as
+        // another spelling of it: the record is fetched once, and both ids are
+        // recovered, or reported unavailable with that chain, rather than the later
+        // id taking the PMCID over and leaving the earlier one with an empty chain.
         const routeToPmc = (inputId, pmcid) => {
             const normalized = normalizePmcId(pmcid);
             const prefixed = withPmcPrefix(normalized);
@@ -1427,135 +1654,126 @@ export const fetchFulltextTool = tool('pubmed_fetch_fulltext', {
                 pmcidToInputId.set(prefixed, inputId);
                 return;
             }
-            if (owner === inputId)
-                return;
-            for (const spelling of callerIds.get(inputId) ?? [inputId])
-                addCallerId(owner, spelling);
-            callerIds.delete(inputId);
-            chainByInput.delete(inputId);
+            if (owner !== inputId)
+                joinChain(inputId, owner);
         };
-        if (input.pmids) {
-            // The ID Converter parses `00000001` as PMID 1 yet reports it "not found
-            // in PMC", and every later stage answers with NCBI's own PMID, so the chain
-            // runs once per distinct PMID in its canonical form. (#161)
-            for (const id of input.pmids)
-                addCallerId(normalizePmid(id), id);
-            const pmids = [...callerIds.keys()];
-            for (const id of pmids)
-                chainByInput.set(id, []);
-            const records = await getNcbiService().idConvert(pmids, 'pmid', ctx.signal ? { signal: ctx.signal } : undefined);
-            const seen = new Set();
-            for (const r of records) {
-                if (r.pmid === undefined)
-                    continue;
-                const pmid = String(r.pmid);
-                seen.add(pmid);
-                if (r.pmcid) {
-                    routeToPmc(pmid, String(r.pmcid));
-                    pmidContext.set(pmid, { pmid, ...(r.doi && { doi: r.doi }) });
-                }
-                else {
-                    chainByInput.get(pmid)?.push({
-                        tier: 'pmc',
-                        outcome: 'not-attempted',
-                        detail: 'PMID has no PMC counterpart',
-                    });
-                    pmidFallbackCandidates.push({ pmid, ...(r.doi && { doi: r.doi }) });
-                }
+        const noteRecordDoi = (pmcid, doi) => {
+            const prefixed = withPmcPrefix(normalizePmcId(pmcid));
+            if (doi && !doiByPmcRecord.has(prefixed))
+                doiByPmcRecord.set(prefixed, doi);
+        };
+        // `PMC123`, `pmc123`, `123` and `PMC0123` name one record; it runs the
+        // chain once, keyed and reported in `PMC<digits>` form. (#170)
+        for (const id of fetched.pmcids) {
+            const normalized = normalizePmcId(id);
+            const key = withPmcPrefix(normalized);
+            if (!chainByInput.has(key))
+                chainByInput.set(key, []);
+            addCallerId(key, { id: key, idType: 'pmcid' });
+            routeToPmc(key, normalized);
+        }
+        // The ID Converter parses `00000001` as PMID 1 yet reports it "not found
+        // in PMC", and every later stage answers with NCBI's own PMID, so the chain
+        // runs once per distinct PMID in its canonical form. (#161)
+        for (const id of fetched.pmids)
+            addCallerId(normalizePmid(id), { id, idType: 'pmid' });
+        const pmids = [...new Set(fetched.pmids.map(normalizePmid))];
+        // DOIs resolve through the converter too, so PMC-indexed DOIs reach PMC
+        // EFetch instead of going straight to the EPMC/Unpaywall fallback (which
+        // misses articles whose only OA copy is the PMC JATS).
+        //
+        // DOIs are case-insensitive, and the converter echoes one casing in
+        // `requested-id` for DOIs that differ only in case, so every casing of a
+        // DOI shares one chain, keyed by the first spelling submitted, and
+        // converter records are matched to it case-insensitively. (#166)
+        const chainKeyByDoi = new Map();
+        for (const doi of fetched.dois) {
+            const key = chainKeyByDoi.get(doi.toLowerCase()) ?? doi;
+            chainKeyByDoi.set(doi.toLowerCase(), key);
+            addCallerId(key, { id: doi, idType: 'doi' });
+        }
+        const dois = [...new Set(chainKeyByDoi.values())];
+        for (const key of [...pmids, ...dois])
+            chainByInput.set(key, []);
+        // The two lookups are independent; their answers are placed in field order.
+        const convertOptions = ctx.signal ? { signal: ctx.signal } : undefined;
+        const [pmidRecords, doiRecords] = await Promise.all([
+            pmids.length > 0 ? getNcbiService().idConvert(pmids, 'pmid', convertOptions) : [],
+            dois.length > 0 ? getNcbiService().idConvert(dois, 'doi', convertOptions) : [],
+        ]);
+        const seenPmids = new Set();
+        for (const r of pmidRecords) {
+            if (r.pmid === undefined)
+                continue;
+            const pmid = String(r.pmid);
+            seenPmids.add(pmid);
+            if (r.pmcid) {
+                noteRecordDoi(String(r.pmcid), r.doi);
+                routeToPmc(pmid, String(r.pmcid));
             }
-            for (const requested of pmids) {
-                if (!seen.has(requested)) {
-                    chainByInput.get(requested)?.push({
-                        tier: 'pmc',
-                        outcome: 'not-attempted',
-                        detail: 'ID Converter returned no record for this PMID',
-                    });
-                    pmidFallbackCandidates.push({ pmid: requested });
-                }
+            else {
+                chainByInput.get(pmid)?.push({
+                    tier: 'pmc',
+                    outcome: 'not-attempted',
+                    detail: 'PMID has no PMC counterpart',
+                });
+                pending.pmid.push({ idType: 'pmid', id: pmid, ...(r.doi && { doi: r.doi }) });
             }
         }
-        else if (input.pmcids) {
-            // `PMC123`, `pmc123`, `123` and `PMC0123` name one record; it runs the
-            // chain once. (#170)
-            pmcIds = [...new Set(input.pmcids.map(normalizePmcId))];
-            for (const id of pmcIds)
-                chainByInput.set(withPmcPrefix(id), []);
+        for (const requested of pmids) {
+            if (!seenPmids.has(requested)) {
+                chainByInput.get(requested)?.push({
+                    tier: 'pmc',
+                    outcome: 'not-attempted',
+                    detail: 'ID Converter returned no record for this PMID',
+                });
+                pending.pmid.push({ idType: 'pmid', id: requested });
+            }
         }
-        else if (input.dois) {
-            // Mirror the `pmids` branch: resolve DOI → PMCID via the PMC ID Converter
-            // so PMC-indexed DOIs reach PMC EFetch instead of going straight to the
-            // EPMC/Unpaywall fallback (which misses articles whose only OA copy is the
-            // PMC JATS). DOIs the converter can't place in PMC seed `doiCandidates`.
-            //
-            // DOIs are case-insensitive, and the converter echoes one casing in
-            // `requested-id` for DOIs that differ only in case, so every casing of a
-            // DOI shares one chain, keyed by the first spelling submitted, and
-            // converter records are matched to it case-insensitively. (#166)
-            const chainKeyByDoi = new Map();
-            for (const doi of input.dois) {
-                const key = chainKeyByDoi.get(doi.toLowerCase()) ?? doi;
-                chainKeyByDoi.set(doi.toLowerCase(), key);
-                addCallerId(key, doi);
+        const seenDois = new Set();
+        for (const r of doiRecords) {
+            // Match on the echoed `requested-id`, not `r.doi`: the record's own DOI
+            // can be cased differently from anything the caller sent.
+            const doi = chainKeyByDoi.get(String(r['requested-id']).toLowerCase());
+            if (doi === undefined)
+                continue;
+            seenDois.add(doi);
+            if (r.pmcid) {
+                noteRecordDoi(String(r.pmcid), doi);
+                routeToPmc(doi, String(r.pmcid));
             }
-            const dois = [...callerIds.keys()];
-            for (const doi of dois)
-                chainByInput.set(doi, []);
-            const records = await getNcbiService().idConvert(dois, 'doi', ctx.signal ? { signal: ctx.signal } : undefined);
-            const seen = new Set();
-            for (const r of records) {
-                // Match on the echoed `requested-id`, not `r.doi`: the record's own DOI
-                // can be cased differently from anything the caller sent.
-                const doi = chainKeyByDoi.get(String(r['requested-id']).toLowerCase());
-                if (doi === undefined)
-                    continue;
-                seen.add(doi);
-                if (r.pmcid) {
-                    routeToPmc(doi, String(r.pmcid));
-                }
-                else {
-                    chainByInput.get(doi)?.push({
-                        tier: 'pmc',
-                        outcome: 'not-attempted',
-                        detail: 'DOI has no PMC counterpart',
-                    });
-                    doiCandidates.push({ doi });
-                }
+            else {
+                chainByInput.get(doi)?.push({
+                    tier: 'pmc',
+                    outcome: 'not-attempted',
+                    detail: 'DOI has no PMC counterpart',
+                });
+                pending.doi.push({ idType: 'doi', id: doi, doi });
             }
-            for (const requested of dois) {
-                if (!seen.has(requested)) {
-                    chainByInput.get(requested)?.push({
-                        tier: 'pmc',
-                        outcome: 'not-attempted',
-                        detail: 'ID Converter returned no record for this DOI',
-                    });
-                    doiCandidates.push({ doi: requested });
-                }
+        }
+        for (const requested of dois) {
+            if (!seenDois.has(requested)) {
+                chainByInput.get(requested)?.push({
+                    tier: 'pmc',
+                    outcome: 'not-attempted',
+                    detail: 'ID Converter returned no record for this DOI',
+                });
+                pending.doi.push({ idType: 'doi', id: requested, doi: requested });
             }
         }
-        // Route PMC-missed prefixed PMCIDs into the fallback buckets so EPMC and
-        // (for pmids/dois) Unpaywall still get a chance. For pmids input we look up
-        // the captured DOI hint via `pmidContext` to avoid an extra PubMed eFetch
-        // when available; the converter often returns the DOI alongside a PMCID
-        // match. For dois input the original DOI is the fallback key directly.
+        // Route PMC-missed prefixed PMCIDs on to the remaining tiers, each as a
+        // candidate of the field that owns its record — which decides how Europe
+        // PMC searches for it and which id an Unpaywall article is stamped with. A
+        // DOI the routing learned for the record rides along, sparing Unpaywall a
+        // lookup; a DOI owner carries its own.
         const routePmcMissesToFallback = (missingPrefixed) => {
-            if (missingPrefixed.length === 0)
-                return;
-            if (input.pmcids) {
-                pmcidFallbackCandidates = missingPrefixed.map((pmcid) => ({ pmcid }));
-            }
-            else if (input.pmids) {
-                for (const prefixed of missingPrefixed) {
-                    const pmid = pmcidToInputId.get(prefixed);
-                    if (pmid)
-                        pmidFallbackCandidates.push(pmidContext.get(pmid) ?? { pmid });
-                }
-            }
-            else if (input.dois) {
-                for (const prefixed of missingPrefixed) {
-                    const doi = pmcidToInputId.get(prefixed);
-                    if (doi)
-                        doiCandidates.push({ doi });
-                }
+            for (const prefixed of missingPrefixed) {
+                const owner = pmcidToInputId.get(prefixed) ?? prefixed;
+                const idType = callerIds.get(owner)?.[0]?.idType;
+                if (idType === undefined)
+                    continue;
+                const doi = idType === 'doi' ? owner : doiByPmcRecord.get(prefixed);
+                pending[idType].push({ idType, id: owner, ...(doi && { doi }) });
             }
         };
         // ── Stage 1: PMC EFetch ─────────────────────────────────────────────────
@@ -1581,17 +1799,18 @@ export const fetchFulltextTool = tool('pubmed_fetch_fulltext', {
                 const bodylessPmcIds = new Set();
                 const parsed = [];
                 for (const node of findAll(articleSet, 'article')) {
-                    const before = parsePmcArticle(node);
-                    if (isBodylessArticle(before)) {
-                        if (before.pmcId)
-                            bodylessPmcIds.add(before.pmcId);
+                    const parsedArticle = parsePmcArticle(node);
+                    if (isBodylessArticle(parsedArticle)) {
+                        if (parsedArticle.pmcId)
+                            bodylessPmcIds.add(parsedArticle.pmcId);
                         continue;
                     }
-                    const after = applyPmcFilters(before, input);
-                    if (isSectionFilterMiss(before, after, input.sections)) {
+                    const before = withBackMatter(parsedArticle);
+                    const after = applyPmcFilters(before, filters);
+                    if (isSectionFilterMiss(before, after, filters.sections)) {
                         sectionFilterMisses.push(articleDisplayId(after));
                     }
-                    const budgeted = applyPmcBudget(after, budget);
+                    const budgeted = applyPmcBudget(after, budget, bodySectionCount(parsedArticle, filters));
                     omittedSections += budgeted.omittedSections;
                     if (budgeted.truncation) {
                         truncatedArticles.push({
@@ -1650,85 +1869,72 @@ export const fetchFulltextTool = tool('pubmed_fetch_fulltext', {
                 routePmcMissesToFallback(allPrefixed);
             }
         }
+        // The records PMC EFetch served, by PMCID, under the id that owns each: the
+        // ID Converter can miss a PMC record a Europe PMC hit links, and that hit
+        // joins the owner rather than fetching the article again. (#192)
+        const servedByPmc = new Map();
+        for (const a of pmcArticles) {
+            if (a.pmcId)
+                servedByPmc.set(a.pmcId, inputIdByArticle.get(a) ?? a.pmcId);
+        }
         // ── Stage 2: Europe PMC fullTextXML ─────────────────────────────────────
+        // Each candidate's `id` is its own chain key from here on: a PMC miss is
+        // routed under the id that owns the record.
+        let candidates = [...pending.pmcid, ...pending.pmid, ...pending.doi];
         const epmc = getEuropePmcService();
         const epmcOutcomes = epmc
-            ? await runEpmcStage(epmc, {
-                pmidFallbackCandidates,
-                pmcidFallbackCandidates,
-                doiCandidates,
-                input,
-                budget,
-                ctx,
-            })
+            ? await runEpmcStage(epmc, { candidates, servedByPmc, input: filters, budget, ctx })
             : {
                 articles: [],
-                remainingPmid: pmidFallbackCandidates,
-                remainingPmcid: pmcidFallbackCandidates,
-                remainingDoi: doiCandidates,
-                pmidOutcomes: new Map(),
-                pmcidOutcomes: new Map(),
-                doiOutcomes: new Map(),
+                articleInputIds: new Map(),
+                joins: [],
+                outcomes: new Map(),
+                remaining: candidates,
                 sectionFilterMisses: [],
                 truncatedArticles: [],
                 omittedSections: 0,
-                articleInputIds: new Map(),
             };
         pmcArticles = pmcArticles.concat(epmcOutcomes.articles);
         truncatedArticles.push(...epmcOutcomes.truncatedArticles);
         omittedSections += epmcOutcomes.omittedSections;
         for (const [article, candidateId] of epmcOutcomes.articleInputIds) {
-            inputIdByArticle.set(article, pmcidToInputId.get(candidateId) ?? candidateId);
+            inputIdByArticle.set(article, candidateId);
         }
         // Fold EPMC outcomes into each id's chain. EPMC-served articles count as
         // recovered, so their ids are added to `recoveredIds` here.
         if (!epmc) {
-            const epmcDisabledEntry = {
-                tier: 'europepmc',
-                outcome: 'not-attempted',
-                detail: 'EUROPEPMC_ENABLED=false',
-            };
             // EPMC searches by PMID, PMCID, and DOI alike, so it could have served
             // every candidate that reached this stage — no applicability test.
-            const skipEpmc = (inputId) => {
-                chainByInput.get(inputId)?.push(epmcDisabledEntry);
-                markUnqueried(inputId, 'europepmc');
-            };
-            for (const c of pmidFallbackCandidates)
-                skipEpmc(c.pmid);
-            for (const c of pmcidFallbackCandidates) {
-                const prefixed = withPmcPrefix(c.pmcid);
-                skipEpmc(pmcidToInputId.get(prefixed) ?? prefixed);
+            for (const c of candidates) {
+                chainByInput.get(c.id)?.push({
+                    tier: 'europepmc',
+                    outcome: 'not-attempted',
+                    detail: 'EUROPEPMC_ENABLED=false',
+                });
+                markUnqueried(c.id, 'europepmc');
             }
-            for (const c of doiCandidates)
-                skipEpmc(c.doi);
         }
         else {
-            const foldEpmcOutcome = (inputId, outcome) => {
+            // A candidate whose search reached a record an earlier one already owns
+            // joins that chain before the owner's outcome lands on it. (#192)
+            for (const { id, owner } of epmcOutcomes.joins)
+                joinChain(id, owner);
+            for (const [inputId, outcome] of epmcOutcomes.outcomes) {
                 if (outcome.kind === 'hit') {
                     recoveredIds.add(inputId);
-                    return;
+                    continue;
                 }
                 if (outcome.kind === 'no-body')
                     bodylessInputIds.add(inputId);
                 chainByInput.get(inputId)?.push(epmcTierFromOutcome(outcome));
-            };
-            for (const [pmid, outcome] of epmcOutcomes.pmidOutcomes)
-                foldEpmcOutcome(pmid, outcome);
-            for (const [prefixed, outcome] of epmcOutcomes.pmcidOutcomes) {
-                foldEpmcOutcome(pmcidToInputId.get(prefixed) ?? prefixed, outcome);
             }
-            for (const [doi, outcome] of epmcOutcomes.doiOutcomes)
-                foldEpmcOutcome(doi, outcome);
         }
-        pmidFallbackCandidates = epmcOutcomes.remainingPmid;
-        pmcidFallbackCandidates = epmcOutcomes.remainingPmcid;
-        doiCandidates = epmcOutcomes.remainingDoi;
+        candidates = epmcOutcomes.remaining;
         sectionFilterMisses.push(...epmcOutcomes.sectionFilterMisses);
         // ── Stage 3: Unpaywall fallback ─────────────────────────────────────────
         const unpaywall = getUnpaywallService();
         const fallbackArticles = [];
-        // Detail of a DOI-backfill lookup that threw, per branch. A candidate still
+        // Detail of a DOI-backfill lookup that threw, per field. A candidate still
         // DOI-less after one of these is an unknown, not a settled absence: it
         // reports `doi-lookup-failed` rather than `no-doi`. (#119)
         let pmcidDoiLookupFailure;
@@ -1739,200 +1945,129 @@ export const fetchFulltextTool = tool('pubmed_fetch_fulltext', {
             outcome: failure ? 'doi-lookup-failed' : 'no-doi',
             ...(failure && { detail: failure }),
         });
-        // `pmcids` input reaches Unpaywall on the DOI the chain already holds: the
-        // EPMC stage searches by PMCID and its hit carries one, captured on non-hit
-        // outcomes too. PMCIDs EPMC never resolved fall back to the PMC ID
-        // Converter, which returns DOIs for PMC-indexed records. (#88)
-        if (pmcidFallbackCandidates.length > 0) {
-            if (!unpaywall) {
-                // The PMCID → DOI lookup below only runs when Unpaywall is configured,
-                // so a candidate arrives here with a DOI only if the EPMC stage handed
-                // one over. An absent DOI therefore means "never looked up", not "this
-                // record has none" — the tier stays a genuine unknown and is marked.
-                for (const c of pmcidFallbackCandidates) {
-                    const prefixed = withPmcPrefix(c.pmcid);
-                    const inputId = pmcidToInputId.get(prefixed) ?? prefixed;
-                    chainByInput.get(inputId)?.push({
-                        tier: 'unpaywall',
-                        outcome: 'not-attempted',
-                        detail: 'UNPAYWALL_EMAIL is not set',
-                    });
-                    markUnqueried(inputId, 'unpaywall');
-                }
-            }
-            else {
-                const needDoi = pmcidFallbackCandidates
-                    .filter((c) => !c.doi)
-                    .map((c) => withPmcPrefix(c.pmcid));
-                if (needDoi.length > 0) {
-                    try {
-                        const records = await getNcbiService().idConvert(needDoi, 'pmcid', ctx.signal ? { signal: ctx.signal } : undefined);
-                        const doiByPmcid = new Map();
-                        for (const r of records) {
-                            if (r.pmcid && r.doi) {
-                                doiByPmcid.set(withPmcPrefix(normalizePmcId(String(r.pmcid))), String(r.doi));
-                            }
-                        }
-                        pmcidFallbackCandidates = pmcidFallbackCandidates.map((c) => {
-                            if (c.doi)
-                                return c;
-                            const doi = doiByPmcid.get(withPmcPrefix(c.pmcid));
-                            return doi ? { ...c, doi } : c;
-                        });
-                    }
-                    catch (error) {
-                        if (ctx.signal.aborted)
-                            throw error;
-                        pmcidDoiLookupFailure = error instanceof Error ? error.message : String(error);
-                        ctx.log.warning('Failed to resolve PMCID → DOI for the Unpaywall fallback', {
-                            error: pmcidDoiLookupFailure,
-                            pmcidCount: needDoi.length,
-                        });
-                    }
-                }
-                const outcomes = await Promise.all(pmcidFallbackCandidates.map(async (candidate) => {
-                    // The prefixed PMCID is the id `unavailable[]` keys on, so stamping
-                    // it on the article makes a partially-recovered batch report its
-                    // successes and its failures under the same identifier. (#92)
-                    const pmcId = withPmcPrefix(candidate.pmcid);
-                    return {
-                        pmcId,
-                        result: candidate.doi
-                            ? await resolveUnpaywall({ pmcId, doi: candidate.doi, epmcTitle: candidate.title, budget }, unpaywall, ctx)
-                            : undefined,
-                    };
-                }));
-                for (const { pmcId, result } of outcomes) {
-                    const inputId = pmcidToInputId.get(pmcId) ?? pmcId;
-                    if (result === undefined) {
-                        chainByInput.get(inputId)?.push(doilessTierEntry(pmcidDoiLookupFailure));
-                    }
-                    else if ('article' in result) {
-                        fallbackArticles.push(result.article);
-                        inputIdByArticle.set(result.article, inputId);
-                        if (result.truncation)
-                            truncatedArticles.push(result.truncation);
-                        recoveredIds.add(inputId);
-                    }
-                    else {
-                        const u = result.unavailable;
-                        chainByInput.get(inputId)?.push({
-                            tier: 'unpaywall',
-                            outcome: unpaywallReasonToTierOutcome(u.reason),
-                            ...(u.detail && { detail: u.detail }),
-                        });
+        // Candidates reach Unpaywall on the DOI the chain already holds — a `dois`
+        // entry's own, one the routing learned for a PMC record, or one a Europe
+        // PMC hit carried, captured on non-hit outcomes too (#88). The rest are
+        // backfilled: a PMC ID through the PMC ID Converter, which returns DOIs for
+        // PMC-indexed records, and only when Unpaywall is configured; a PMID from
+        // PubMed metadata (db=pubmed), since the converter returns DOIs only for
+        // articles it has in PMC. The two lookups are independent.
+        const backfillPmcidDois = async (pmcids) => {
+            const found = new Map();
+            if (pmcids.length === 0)
+                return found;
+            try {
+                const records = await getNcbiService().idConvert(pmcids, 'pmcid', ctx.signal ? { signal: ctx.signal } : undefined);
+                for (const r of records) {
+                    if (r.pmcid && r.doi) {
+                        found.set(withPmcPrefix(normalizePmcId(String(r.pmcid))), String(r.doi));
                     }
                 }
             }
-        }
-        if (pmidFallbackCandidates.length > 0) {
-            // The PMC ID Converter only returns DOIs for articles it has in PMC, so
-            // candidates here are missing DOIs by default. Pull them from PubMed
-            // metadata (db=pubmed) before dispatching to Unpaywall.
-            const needDoi = pmidFallbackCandidates.filter((c) => !c.doi).map((c) => c.pmid);
-            if (needDoi.length > 0) {
-                try {
-                    const doiMap = await fetchPubmedDois(needDoi, ctx.signal);
-                    pmidFallbackCandidates = pmidFallbackCandidates.map((c) => {
-                        if (c.doi)
-                            return c;
-                        const doi = doiMap.get(c.pmid);
-                        return doi ? { ...c, doi } : c;
-                    });
-                }
-                catch (error) {
-                    if (ctx.signal.aborted)
-                        throw error;
-                    pmidDoiLookupFailure = error instanceof Error ? error.message : String(error);
-                    ctx.log.warning('Failed to batch-fetch DOIs from PubMed for Unpaywall fallback', {
-                        error: pmidDoiLookupFailure,
-                        pmidCount: needDoi.length,
-                    });
-                }
+            catch (error) {
+                if (ctx.signal.aborted)
+                    throw error;
+                pmcidDoiLookupFailure = error instanceof Error ? error.message : String(error);
+                ctx.log.warning('Failed to resolve PMCID → DOI for the Unpaywall fallback', {
+                    error: pmcidDoiLookupFailure,
+                    pmcidCount: pmcids.length,
+                });
             }
-            if (!unpaywall) {
-                // `fetchPubmedDois` has already run, so a candidate with no DOI could
-                // not have reached Unpaywall configured or not — that is `no-doi`, a
-                // real answer, not an incomplete search. Unless the lookup itself
-                // threw, in which case the DOI state is unknown rather than absent.
-                for (const c of pmidFallbackCandidates) {
-                    if (!c.doi) {
-                        chainByInput.get(c.pmid)?.push(doilessTierEntry(pmidDoiLookupFailure));
-                        continue;
-                    }
-                    chainByInput.get(c.pmid)?.push({
-                        tier: 'unpaywall',
-                        outcome: 'not-attempted',
-                        detail: 'UNPAYWALL_EMAIL is not set',
-                    });
-                    markUnqueried(c.pmid, 'unpaywall');
-                }
+            return found;
+        };
+        const backfillPmidDois = async (pmidsNeedingDoi) => {
+            if (pmidsNeedingDoi.length === 0)
+                return new Map();
+            try {
+                return await fetchPubmedDois(pmidsNeedingDoi, ctx.signal);
             }
-            else {
-                const outcomes = await Promise.all(pmidFallbackCandidates.map(async (candidate) => ({
-                    candidate,
-                    result: candidate.doi
-                        ? await resolveUnpaywall({ pmid: candidate.pmid, doi: candidate.doi, epmcTitle: candidate.title, budget }, unpaywall, ctx)
-                        : undefined,
-                })));
-                for (const { candidate, result } of outcomes) {
-                    if (result === undefined) {
-                        chainByInput.get(candidate.pmid)?.push(doilessTierEntry(pmidDoiLookupFailure));
-                    }
-                    else if ('article' in result) {
-                        fallbackArticles.push(result.article);
-                        inputIdByArticle.set(result.article, candidate.pmid);
-                        if (result.truncation)
-                            truncatedArticles.push(result.truncation);
-                        recoveredIds.add(candidate.pmid);
-                    }
-                    else {
-                        const u = result.unavailable;
-                        chainByInput.get(candidate.pmid)?.push({
-                            tier: 'unpaywall',
-                            outcome: unpaywallReasonToTierOutcome(u.reason),
-                            ...(u.detail && { detail: u.detail }),
-                        });
-                    }
+            catch (error) {
+                if (ctx.signal.aborted)
+                    throw error;
+                pmidDoiLookupFailure = error instanceof Error ? error.message : String(error);
+                ctx.log.warning('Failed to batch-fetch DOIs from PubMed for Unpaywall fallback', {
+                    error: pmidDoiLookupFailure,
+                    pmidCount: pmidsNeedingDoi.length,
+                });
+                return new Map();
+            }
+        };
+        const needingDoi = (idType) => candidates.filter((c) => c.idType === idType && !c.doi).map((c) => c.id);
+        const [pmcidDois, pmidDois] = await Promise.all([
+            unpaywall ? backfillPmcidDois(needingDoi('pmcid')) : new Map(),
+            backfillPmidDois(needingDoi('pmid')),
+        ]);
+        const backfilled = { pmcid: pmcidDois, pmid: pmidDois, doi: new Map() };
+        candidates = candidates.map((c) => {
+            const doi = c.doi ?? backfilled[c.idType].get(c.id);
+            return doi ? { ...c, doi } : c;
+        });
+        if (!unpaywall) {
+            for (const c of candidates) {
+                // `fetchPubmedDois` has already run, so a PMID with no DOI could not
+                // have reached Unpaywall configured or not — that is `no-doi`, a real
+                // answer, not an incomplete search, unless the lookup itself threw. A
+                // PMC ID's DOI is looked up only for Unpaywall, so its absence means
+                // "never looked up", and the tier stays a genuine unknown and is marked.
+                if (!c.doi && c.idType === 'pmid') {
+                    chainByInput.get(c.id)?.push(doilessTierEntry(pmidDoiLookupFailure));
+                    continue;
                 }
+                chainByInput.get(c.id)?.push({
+                    tier: 'unpaywall',
+                    outcome: 'not-attempted',
+                    detail: 'UNPAYWALL_EMAIL is not set',
+                });
+                markUnqueried(c.id, 'unpaywall');
             }
         }
-        if (doiCandidates.length > 0) {
-            if (!unpaywall) {
-                // Every candidate on this branch is a DOI, so Unpaywall applies to all
-                // of them.
-                for (const c of doiCandidates) {
-                    chainByInput.get(c.doi)?.push({
-                        tier: 'unpaywall',
-                        outcome: 'not-attempted',
-                        detail: 'UNPAYWALL_EMAIL is not set',
-                    });
-                    markUnqueried(c.doi, 'unpaywall');
+        else {
+            // One resolve per DOI, case-insensitively: a later candidate carrying a
+            // DOI an earlier one holds joins that chain, and the article is stamped
+            // with the owner's identifier. (#192)
+            const ownerByDoi = new Map();
+            for (const c of candidates) {
+                if (!c.doi) {
+                    const failure = c.idType === 'pmcid' ? pmcidDoiLookupFailure : pmidDoiLookupFailure;
+                    chainByInput.get(c.id)?.push(doilessTierEntry(failure));
+                    continue;
                 }
+                const owner = ownerByDoi.get(c.doi.toLowerCase());
+                if (owner)
+                    joinChain(c.id, owner.id);
+                else
+                    ownerByDoi.set(c.doi.toLowerCase(), { ...c, doi: c.doi });
             }
-            else {
-                // `resolveUnpaywall` catches its own failures so this Promise.all
-                // doesn't reject under normal operation.
-                const outcomes = await Promise.all(doiCandidates.map(async (c) => ({
+            // `resolveUnpaywall` catches its own failures so this Promise.all
+            // doesn't reject under normal operation.
+            const outcomes = await Promise.all([...ownerByDoi.values()].map(async (c) => ({
+                inputId: c.id,
+                // A PMC ID or PMID is stamped on the article so a partially-recovered
+                // batch reports its successes and its failures under the same
+                // identifier; Unpaywall itself only knows the DOI. (#92)
+                result: await resolveUnpaywall({
+                    ...(c.idType === 'pmcid' && { pmcId: c.id }),
+                    ...(c.idType === 'pmid' && { pmid: c.id }),
                     doi: c.doi,
-                    result: await resolveUnpaywall({ doi: c.doi, epmcTitle: c.title, budget }, unpaywall, ctx),
-                })));
-                for (const { doi, result } of outcomes) {
-                    if ('article' in result) {
-                        fallbackArticles.push(result.article);
-                        inputIdByArticle.set(result.article, doi);
-                        if (result.truncation)
-                            truncatedArticles.push(result.truncation);
-                        recoveredIds.add(doi);
-                    }
-                    else {
-                        const u = result.unavailable;
-                        chainByInput.get(doi)?.push({
-                            tier: 'unpaywall',
-                            outcome: unpaywallReasonToTierOutcome(u.reason),
-                            ...(u.detail && { detail: u.detail }),
-                        });
-                    }
+                    epmcTitle: c.title,
+                    budget,
+                }, unpaywall, ctx),
+            })));
+            for (const { inputId, result } of outcomes) {
+                if ('article' in result) {
+                    fallbackArticles.push(result.article);
+                    inputIdByArticle.set(result.article, inputId);
+                    if (result.truncation)
+                        truncatedArticles.push(result.truncation);
+                    recoveredIds.add(inputId);
+                }
+                else {
+                    const u = result.unavailable;
+                    chainByInput.get(inputId)?.push({
+                        tier: 'unpaywall',
+                        outcome: unpaywallReasonToTierOutcome(u.reason),
+                        ...(u.detail && { detail: u.detail }),
+                    });
                 }
             }
         }
@@ -1942,12 +2077,14 @@ export const fetchFulltextTool = tool('pubmed_fetch_fulltext', {
             if (recoveredIds.has(id))
                 continue;
             const unqueried = unqueriedByInput.get(id);
-            for (const callerId of callerIds.get(id) ?? [id]) {
+            for (const callerId of callerIds.get(id) ?? []) {
+                const own = ownChainOf.get(callerId);
+                const triedTiers = own ? [...own.tried, ...chain.slice(own.from)] : chain;
                 unavailable.push({
-                    id: callerId,
-                    idType,
-                    reason: reasonFromChain(chain),
-                    triedTiers: chain,
+                    id: callerId.id,
+                    idType: callerId.idType,
+                    reason: reasonFromChain(triedTiers),
+                    triedTiers,
                     ...(unqueried?.size && { unqueriedTiers: [...unqueried] }),
                 });
             }
@@ -1962,21 +2099,28 @@ export const fetchFulltextTool = tool('pubmed_fetch_fulltext', {
         const fit = ceiling === undefined ? undefined : fitWholeItems(resolved, ceiling);
         const articles = fit?.kept ?? resolved;
         const nextDeferredCharacters = fit?.nextDeferredCharacters;
+        // Each deferred article is handed back under the first spelling of the id
+        // that owns it, in the field that id was sent in. Every recovery site
+        // records the owner; a PMC record that came back without a PMC ID has none,
+        // and is reported under the id it carries — the total-function fallback,
+        // not an expected path.
+        const deferredIds = (fit?.deferred ?? []).map((a) => {
+            const key = inputIdByArticle.get(a);
+            const owner = key === undefined ? undefined : callerIds.get(key)?.[0];
+            return (owner ?? { id: articleDisplayId(a), idType: a.pmcId ? 'pmcid' : a.pmid ? 'pmid' : 'doi' });
+        });
         const deferred = ceiling !== undefined && nextDeferredCharacters !== undefined && fit
             ? {
                 maxResponseCharacters: ceiling,
                 returnedCharacters: fit.keptCharacters,
                 deferredCount: fit.deferred.length,
-                idType,
-                // Every recovery site records the input id; `articleDisplayId` is
-                // the total-function fallback, not an expected path.
-                ids: fit.deferred.map((a) => {
-                    const id = inputIdByArticle.get(a) ?? articleDisplayId(a);
-                    return callerIds.get(id)?.[0] ?? id;
-                }),
+                ...groupIdsByField(deferredIds),
                 nextDeferredCharacters,
             }
             : undefined;
+        const overLimit = overLimitIds.length > 0
+            ? { limit: FETCH_LIMIT, ...groupIdsByField(overLimitIds) }
+            : undefined;
         // A deferred article takes its body accounting out of the response with it —
         // those counts describe text the caller never received.
         if (fit) {
@@ -1992,13 +2136,14 @@ export const fetchFulltextTool = tool('pubmed_fetch_fulltext', {
             }
         }
         ctx.log.info('pubmed_fetch_fulltext completed', {
-            requested: (input.pmids ?? input.pmcids ?? input.dois)?.length ?? 0,
+            requested: idCount,
             returned: articles.length,
             pmcHits: pmcArticles.filter((a) => a.viaSource === 'pmc').length,
             epmcHits: pmcArticles.filter((a) => a.viaSource === 'europepmc').length,
             unpaywallHits: fallbackArticles.length,
             unavailable: unavailable.length,
             ...(deferred && { deferred: deferred.deferredCount }),
+            ...(overLimit && { overLimit: overLimit.ids.length }),
         });
         // Summed off the per-article entries rather than carried through every
         // stage, so a deferred article's dropped tables leave the roll-up together
@@ -2026,8 +2171,8 @@ export const fetchFulltextTool = tool('pubmed_fetch_fulltext', {
         // Only the last ctx.enrich.notice survives, so the applicable fragments are
         // collected and emitted once.
         const notices = [];
-        if (input.sections?.length && sectionFilterMisses.length > 0) {
-            notices.push(buildSectionFilterMissNotice(sectionFilterMisses, input.sections));
+        if (sectionFilterMisses.length > 0) {
+            notices.push(buildSectionFilterMissNotice(sectionFilterMisses, sectionFilter.terms));
         }
         const unrecoveredBodyless = [...bodylessInputIds].filter((id) => !recoveredIds.has(id));
         if (unrecoveredBodyless.length > 0)
@@ -2044,6 +2189,10 @@ export const fetchFulltextTool = tool('pubmed_fetch_fulltext', {
             notices.push(buildDeferralNotice(deferred));
             ctx.enrich({ truncated: true });
         }
+        if (overLimit) {
+            notices.push(buildOverLimitNotice(overLimit));
+            ctx.enrich({ truncated: true });
+        }
         if (notices.length > 0)
             ctx.enrich.notice(notices.join(' '));
         return {
@@ -2052,6 +2201,7 @@ export const fetchFulltextTool = tool('pubmed_fetch_fulltext', {
             ...(unavailable.length > 0 && { unavailable }),
             ...(truncation && { truncation }),
             ...(deferred && { deferred }),
+            ...(overLimit && { overLimit }),
         };
     },
     format: (result) => {
@@ -2082,7 +2232,11 @@ export const fetchFulltextTool = tool('pubmed_fetch_fulltext', {
         }
         if (result.deferred) {
             const d = result.deferred;
-            lines.push(`\n**Deferred by the response budget:** ${d.deferredCount} article(s) — ${d.returnedCharacters} of ${d.maxResponseCharacters} budgeted characters returned; next deferred article ${d.nextDeferredCharacters} characters`, `Re-call \`pubmed_fetch_fulltext\` with these ${d.idType} ids as \`${d.idType}s\`: ${d.ids.join(', ')}`);
+            lines.push(`\n**Deferred by the response budget:** ${d.deferredCount} article(s) — ${d.returnedCharacters} of ${d.maxResponseCharacters} budgeted characters returned; next deferred article ${d.nextDeferredCharacters} characters`, ...resendLines(d));
+        }
+        if (result.overLimit) {
+            const o = result.overLimit;
+            lines.push(`\n**Over the per-call limit:** ${o.ids.length} identifier(s) not fetched — a call fetches the first ${o.limit} distinct identifiers`, ...resendLines(o));
         }
         // An empty response under a budget is a deferral, not an absence — the
         // articles resolved and the ids above retrieve them.
@@ -2103,9 +2257,84 @@ export const fetchFulltextTool = tool('pubmed_fetch_fulltext', {
         return [{ type: 'text', text: lines.join('\n') }];
     },
 });
+/**
+ * Every requested id in routing order — `pmcids`, then `pmids`, then `dois`,
+ * request order within each — as sent. Every spelling one field accepts for an
+ * identifier shares a key, and the same digits in two fields are two keys.
+ * (#192, #222)
+ */
+function requestedIds(fields) {
+    return [
+        ...(fields.pmcids ?? []).map((id) => ({ id, idType: 'pmcid', key: `pmcid:${normalizePmcId(id)}` })),
+        ...(fields.pmids ?? []).map((id) => ({ id, idType: 'pmid', key: `pmid:${normalizePmid(id)}` })),
+        ...(fields.dois ?? []).map((id) => ({ id, idType: 'doi', key: `doi:${id.toLowerCase()}` })),
+    ];
+}
+/**
+ * Split the requested ids at the per-call fetch limit, before any upstream
+ * request. The first {@link FETCH_LIMIT} distinct identifiers in routing order
+ * are fetched, each with every spelling that names it; each later identifier is
+ * handed back once, under its first spelling — a PMC ID in the `PMC<digits>`
+ * form every output reports it in. (#222)
+ */
+function splitAtFetchLimit(fields) {
+    const fetched = { pmcids: [], pmids: [], dois: [] };
+    const overLimit = [];
+    const admitted = new Set();
+    const listed = new Set();
+    for (const { id, idType, key } of requestedIds(fields)) {
+        if (admitted.has(key) || admitted.size < FETCH_LIMIT) {
+            admitted.add(key);
+            fetched[`${idType}s`].push(id);
+        }
+        else if (!listed.has(key)) {
+            listed.add(key);
+            overLimit.push({ id: idType === 'pmcid' ? withPmcPrefix(normalizePmcId(id)) : id, idType });
+        }
+    }
+    return { fetched, overLimit };
+}
+/**
+ * Group ids handed back for a follow-up call: one field names them all —
+ * always so for a single-field call — or each field's list says where to
+ * resend its ids. (#192, #222)
+ */
+function groupIdsByField(callerIds) {
+    const fields = new Set(callerIds.map((c) => c.idType));
+    const [onlyField] = fields;
+    const under = (idType) => callerIds.filter((c) => c.idType === idType).map((c) => c.id);
+    return {
+        ...(fields.size === 1 && onlyField && { idType: onlyField }),
+        ids: callerIds.map((c) => c.id),
+        ...(fields.size > 1 && {
+            ...(fields.has('pmcid') && { pmcids: under('pmcid') }),
+            ...(fields.has('pmid') && { pmids: under('pmid') }),
+            ...(fields.has('doi') && { dois: under('doi') }),
+        }),
+    };
+}
+/**
+ * The `content[]` lines that resend a group of ids. Rendered on presence, each
+ * independently: a group carries `idType` or the per-field lists, never both.
+ */
+function resendLines(group) {
+    const fieldLists = idFieldLists(group);
+    return [
+        ...(group.idType
+            ? [
+                `Re-call \`pubmed_fetch_fulltext\` with these ${group.idType} ids as \`${group.idType}s\`: ${group.ids.join(', ')}`,
+            ]
+            : []),
+        ...(fieldLists
+            ? [
+                `Re-call \`pubmed_fetch_fulltext\` with these ids, each under its own field — ${fieldLists}`,
+            ]
+            : []),
+    ];
+}
 /**
  * Merge what a Europe PMC hit carried onto a candidate bound for Unpaywall. A
- * DOI the candidate already holds wins — for `dois` input it is the caller's
+ * DOI the candidate already holds wins — for a `dois` entry it is the caller's
  * own identifier.
  */
 function carryEpmcHit(candidate, hit) {
@@ -2121,18 +2350,63 @@ function nonEmptyDisplayText(raw) {
 }
 /**
  * Run the Europe PMC step against everything that fell through PMC EFetch
- * plus any direct DOI input. Each candidate goes through search-by-best-id →
- * fullTextXML. Hits become `source: 'pmc'` articles with `viaSource: 'europepmc'`;
- * misses flow through to the Unpaywall stage unchanged.
+ * plus any DOI the converter could not place. Each candidate is searched by its
+ * own id; each record the searches reach is then fetched as fullTextXML once,
+ * for the first candidate in field order that reached it, and any later one
+ * joins that candidate's chain. Hits become `source: 'pmc'` articles with
+ * `viaSource: 'europepmc'`; misses flow through to the Unpaywall stage
+ * unchanged.
  *
- * Candidates run in parallel — the EPMC request queue caps concurrency so this
- * stays polite without serializing. Errors are caught and logged inside the
- * helpers; a transient EPMC failure must not block the downstream Unpaywall
- * fallback.
+ * Searches and fetches run in parallel — the EPMC request queue caps
+ * concurrency so this stays polite without serializing. Errors are caught and
+ * logged inside the helpers; a transient EPMC failure must not block the
+ * downstream Unpaywall fallback.
  */
 async function runEpmcStage(epmc, args) {
-    const runOne = async (c, query, contextPmid) => {
-        const search = await searchEpmcSafe(epmc, query, args.ctx);
+    /**
+     * Query shapes are load-bearing and not interchangeable with their quoted
+     * variants. Europe PMC matches zero records for `EXT_ID:"<pmid>" AND SRC:MED`
+     * and `PMCID:"PMC<digits>"` — the quotes only survive as long as no `AND SRC:`
+     * clause follows. `SRC:PMC` is likewise wrong for a PMCID lookup: EPMC's
+     * canonical record for a PMC-indexed article has `source: MED` and carries the
+     * PMCID as a field, so the filter excludes the very record being sought. DOIs
+     * keep their quotes — they carry slashes and dots that need them. (#85)
+     */
+    const queryFor = (c) => {
+        switch (c.idType) {
+            case 'pmcid':
+                return `PMCID:${c.id}`;
+            case 'pmid':
+                return `EXT_ID:${c.id} AND SRC:MED`;
+            case 'doi':
+                return `DOI:"${c.id}"`;
+        }
+    };
+    const searched = await Promise.all(args.candidates.map(async (c) => ({
+        c,
+        search: await searchEpmcSafe(epmc, queryFor(c), args.ctx),
+    })));
+    // Every tier keys on the record: the first candidate whose search reached a
+    // record owns it, and a later one joins its chain rather than fetching and
+    // returning the same article again — as does one whose hit names a PMC ID
+    // PMC EFetch already served, joining that article's owner. (#192)
+    const joins = [];
+    const ownerByRecord = new Map();
+    const owned = searched.filter(({ c, search }) => {
+        if (search.kind !== 'hit')
+            return true;
+        const record = `${search.hit.source}:${search.hit.id}`;
+        const pmcid = search.hit.pmcid ?? (search.hit.source === 'PMC' ? search.hit.id : undefined);
+        const servedOwner = pmcid === undefined ? undefined : args.servedByPmc.get(withPmcPrefix(normalizePmcId(pmcid)));
+        const owner = servedOwner ?? ownerByRecord.get(record);
+        if (owner === undefined) {
+            ownerByRecord.set(record, c.id);
+            return true;
+        }
+        joins.push({ id: c.id, owner });
+        return false;
+    });
+    const runOne = async (c, search) => {
         if (search.kind === 'error') {
             return { c, outcome: { kind: 'service-error', detail: search.detail } };
         }
@@ -2143,6 +2417,7 @@ async function runEpmcStage(epmc, args) {
             ...(search.hit.doi && { doi: search.hit.doi }),
             ...(title && { title }),
         };
+        const contextPmid = c.idType === 'pmid' ? c.id : undefined;
         const fetched = await fetchEpmcArticle(epmc, search.hit, args, contextPmid);
         if (fetched.kind === 'error') {
             return { c, ...hit, outcome: { kind: 'service-error', detail: fetched.detail } };
@@ -2167,34 +2442,11 @@ async function runEpmcStage(epmc, args) {
             ...(fetched.truncation && { truncation: fetched.truncation }),
         };
     };
-    /**
-     * Query shapes are load-bearing and not interchangeable with their quoted
-     * variants. Europe PMC matches zero records for `EXT_ID:"<pmid>" AND SRC:MED`
-     * and `PMCID:"PMC<digits>"` — the quotes only survive as long as no `AND SRC:`
-     * clause follows. `SRC:PMC` is likewise wrong for a PMCID lookup: EPMC's
-     * canonical record for a PMC-indexed article has `source: MED` and carries the
-     * PMCID as a field, so the filter excludes the very record being sought. DOIs
-     * keep their quotes — they carry slashes and dots that need them. (#85)
-     */
-    const fetchForPmid = (c) => runOne(c, `EXT_ID:${c.pmid} AND SRC:MED`, c.pmid);
-    const fetchForPmcid = (c) => {
-        const normalized = withPmcPrefix(c.pmcid);
-        return runOne({ c, normalized }, `PMCID:${normalized}`, undefined);
-    };
-    const fetchForDoi = (c) => runOne(c, `DOI:"${c.doi}"`, undefined);
-    const [pmidResults, pmcidResults, doiResults] = await Promise.all([
-        Promise.all(args.pmidFallbackCandidates.map(fetchForPmid)),
-        Promise.all(args.pmcidFallbackCandidates.map(fetchForPmcid)),
-        Promise.all(args.doiCandidates.map(fetchForDoi)),
-    ]);
+    const runs = await Promise.all(owned.map(({ c, search }) => runOne(c, search)));
     const articles = [];
     const articleInputIds = new Map();
-    const remainingPmid = [];
-    const remainingPmcid = [];
-    const remainingDoi = [];
-    const pmidOutcomes = new Map();
-    const pmcidOutcomes = new Map();
-    const doiOutcomes = new Map();
+    const remaining = [];
+    const outcomes = new Map();
     const sectionFilterMisses = [];
     const truncatedArticles = [];
     let omittedSections = 0;
@@ -2207,39 +2459,22 @@ async function runEpmcStage(epmc, args) {
             truncatedArticles.push(run.truncation);
         omittedSections += run.omittedSections ?? 0;
     };
-    for (const run of pmidResults) {
-        pmidOutcomes.set(run.c.pmid, run.outcome);
+    for (const run of runs) {
+        outcomes.set(run.c.id, run.outcome);
         if (run.article)
-            collectHit(run.c.pmid, { ...run, article: run.article });
+            collectHit(run.c.id, { ...run, article: run.article });
         // What the EPMC hit carried is evidence the next stage needs, whatever the
-        // fetch outcome was: its DOI spares Unpaywall a PubMed metadata round-trip
-        // (#119), and its title backs up Unpaywall's own record (#144).
+        // fetch outcome was: its DOI spares Unpaywall a DOI lookup (#88, #119), and
+        // its title backs up Unpaywall's own record (#144).
         else
-            remainingPmid.push(carryEpmcHit(run.c, run));
-    }
-    for (const run of pmcidResults) {
-        pmcidOutcomes.set(run.c.normalized, run.outcome);
-        if (run.article)
-            collectHit(run.c.normalized, { ...run, article: run.article });
-        else
-            remainingPmcid.push(carryEpmcHit(run.c.c, run));
-    }
-    for (const run of doiResults) {
-        doiOutcomes.set(run.c.doi, run.outcome);
-        if (run.article)
-            collectHit(run.c.doi, { ...run, article: run.article });
-        else
-            remainingDoi.push(carryEpmcHit(run.c, run));
+            remaining.push(carryEpmcHit(run.c, run));
     }
     return {
         articles,
         articleInputIds,
-        remainingPmid,
-        remainingPmcid,
-        remainingDoi,
-        pmidOutcomes,
-        pmcidOutcomes,
-        doiOutcomes,
+        joins,
+        outcomes,
+        remaining,
         sectionFilterMisses,
         truncatedArticles,
         omittedSections,
@@ -2297,16 +2532,17 @@ async function fetchEpmcArticle(epmc, hit, args, contextPmid) {
         if (!articleNode) {
             return { kind: 'no-fulltext', detail: 'EPMC fullTextXML payload had no <article> element' };
         }
-        const beforeFilter = parsePmcArticle(articleNode);
-        if (isBodylessArticle(beforeFilter)) {
+        const parsedArticle = parsePmcArticle(articleNode);
+        if (isBodylessArticle(parsedArticle)) {
             return {
                 kind: 'no-body',
                 detail: 'EPMC fullTextXML carried front matter and abstract only, with no body sections',
             };
         }
+        const beforeFilter = withBackMatter(parsedArticle);
         const parsed = applyPmcFilters(beforeFilter, args.input);
         const sectionFilterMiss = isSectionFilterMiss(beforeFilter, parsed, args.input.sections);
-        const budgeted = applyPmcBudget(parsed, args.budget);
+        const budgeted = applyPmcBudget(parsed, args.budget, bodySectionCount(parsedArticle, args.input));
         // `parsePmcArticle` always returns string fields (sometimes empty). Strip
         // empty `pmcId`/`pmcUrl` for EPMC-only records (preprints) so the schema's
         // optional shape is respected — agents read `epmcId`/`epmcSource` for those.
@@ -2381,8 +2617,8 @@ async function fetchPubmedDois(pmids, signal) {
 }
 /**
  * Resolve a DOI to an open-access article via Unpaywall. `pmcId` and `pmid`,
- * when set, are stamped onto the resulting article so the branch that requested
- * it carries its identifier through — Unpaywall itself only knows the DOI.
+ * when set, are stamped onto the resulting article so the id that requested it
+ * carries its identifier through — Unpaywall itself only knows the DOI.
  *
  * The article's title is the first one found in Unpaywall's own record, then
  * `epmcTitle` — the Europe PMC record the chain searched for this id — then,
@@ -2709,8 +2945,8 @@ function formatPmcArticle(a, lines, truncation, mode) {
     }
     if (a.affiliations?.length) {
         lines.push(`\n**Affiliations:**`);
-        for (const [i, aff] of a.affiliations.entries())
-            lines.push(`${i + 1}. ${aff}`);
+        for (const aff of a.affiliations)
+            lines.push(`- ${aff}`);
     }
     if (a.journal) {
         const parts = [];
@@ -2781,6 +3017,9 @@ function formatPmcArticle(a, lines, truncation, mode) {
  * `rowspan`, so a well-formed table arrives rectangular and every value renders
  * under the header it belongs to; a row still short of the widest is padded on
  * the right with empty cells only, never a neighbour's value.
+ *
+ * A grid row and the Footnotes line are single lines, so the `\n` a cell or the
+ * footer keeps between its lines renders as {@link inlineLines} says. (#185)
  */
 function formatTables(tables, lines) {
     lines.push(`\n#### Tables (${tables.length})`);
@@ -2799,10 +3038,23 @@ function formatTables(tables, lines) {
         }
         if (table.rows.length > 0)
             lines.push(...renderTableGrid(table.rows, table.headerRowCount));
-        if (table.footnotes)
-            lines.push(`\nFootnotes: ${escapeMarkdownInline(table.footnotes)}`);
+        if (table.footnotes) {
+            lines.push(`\nFootnotes: ${escapeMarkdownInline(inlineLines(table.footnotes))}`);
+        }
     }
 }
+/**
+ * Lay a multi-line cell or footer value onto one Markdown line, its lines joined
+ * by ` · ` — the joiner the header fold and the meta lines already use. A bare
+ * space would run one footnote into the next, and a line per footnote would put
+ * markers such as `*`, `#` and `1.` at the start of a line, where they become
+ * Markdown structure. Callers escape the joined result, so emphasis pairing is
+ * judged across the whole rendered line rather than one source line at a time.
+ * (#185)
+ */
+function inlineLines(text) {
+    return text.replaceAll('\n', ' · ');
+}
 /**
  * Render every figure and supplementary item, so a `content[]` reader gets the
  * same caption, pointer and placement `structuredContent` carries rather than a
@@ -2868,7 +3120,7 @@ function foldHeaderColumn(headerRows, column) {
 /** One table's rows as Markdown grid lines, preceded by a blank line. */
 function renderTableGrid(rows, headerRowCount) {
     const columns = rows.reduce((widest, row) => Math.max(widest, row.length), 0);
-    const renderRow = (cells) => `| ${Array.from({ length: columns }, (_, i) => escapeMarkdownTableCell(cells[i] ?? '')).join(' | ')} |`;
+    const renderRow = (cells) => `| ${Array.from({ length: columns }, (_, i) => escapeMarkdownTableCell(inlineLines(cells[i] ?? ''))).join(' | ')} |`;
     const headerRows = rows.slice(0, headerRowCount);
     const header = Array.from({ length: columns }, (_, i) => foldHeaderColumn(headerRows, i));
     return [
@@ -2941,7 +3193,7 @@ function sectionHeading(section) {
     return section.label ? escapeMarkdownInline(section.label) : UNTITLED_SECTION_LABEL;
 }
 /**
- * Render one body section and everything nested under it, one markdown heading
+ * Render one section and everything nested under it, one markdown heading
  * level per nesting level. Walks the full depth the output schema carries, so
  * `content[]` shows every section `structuredContent` does. Headings stop
  * deepening at `######`, the deepest markdown supports. (#112)