@pipeworx/mcp-medicare-pricing 0.1.2 → 0.1.4

package/README.md

@@ -4,7 +4,7 @@ What Medicare **pays** — physician fee schedule, lab rates, and per-day unit
 limits. The companion to `medicare-coverage`, which answers whether something is
 covered but not what it is worth.
 
-Part of [Pipeworx](https://pipeworx.io) — an MCP gateway connecting AI agents to 1683+ live data sources.
+Part of [Pipeworx](https://pipeworx.io) — an MCP gateway connecting AI agents to 1831+ live data sources. This is an independent, unofficial integration — not affiliated with, endorsed by, or published by the upstream provider.
 
 ## Tools
 
@@ -17,6 +17,7 @@ Part of [Pipeworx](https://pipeworx.io) — an MCP gateway connecting AI agents
 | `medicare_code_units_limit` | "How many units of this code will they pay for in one day?" — NCCI MUE. |
 | `check_code_pair` | "Can I bill 00142 and 64474 together?" — NCCI PTP edit + modifier indicator for a code pair. |
 | `explain_ncci_edit` | "What is bundled into (or bundles into) this code?" — every recorded PTP edit for one code. |
+| `medicare_fqhc_pps_rate` | "What is the FQHC PPS base rate for 2026?" — CMS's national Federally Qualified Health Center per-visit base rate, by year. |
 | `medicare_pricing_coverage` | Which vintages are loaded, including the PTP baseline vintage. |
 
 ## Auth
@@ -32,6 +33,31 @@ All from CMS, all downloadable files with no API:
 - **DMEPOS fee schedule** (durable medical equipment, prosthetics, orthotics, supplies) — quarterly (as necessary): A=Jan, B=Apr, C=Jul, D=Oct
 - **NCCI Medically Unlikely Edits** — quarterly
 - **NCCI PTP quarterly additions/deletions/revisions files** — quarterly (see below — a narrower source than the other three)
+- **FQHC Prospective Payment System base payment rate** — annual (see below — a hand-maintained table, not a downloaded file)
+
+## FQHC PPS base payment rate — a hand-maintained table, and why
+
+`medicare_fqhc_pps_rate` is different from the rest of this pack: it is not
+backed by Supabase or a downloaded bulk file, because there is neither. CMS
+publishes the FQHC PPS national base rate exactly once a year, as a single new
+dollar figure inside a CMS Manual System "Recurring Update Notification"
+Change Request PDF — one number, one PDF, once a year. Standing up an ingest
+pipeline for that is not proportionate, so the pack carries a small table of
+`{year, base_rate_usd, effective_date, market_basket_update_pct,
+prior_year_rate_usd, transmittal, change_request, publication}` in
+`src/index.ts` (`FQHC_PPS_BASE_RATES`), five rows (CY2022–CY2026), each read
+directly off its own primary CMS transmittal.
+
+This is the national BASE rate only — before the per-FQHC Geographic
+Adjustment Factor (GAF) CMS applies on top. The GAF table itself is not
+loaded; an agent that needs the GAF-adjusted dollar amount for a specific FQHC
+still needs that separately.
+
+**Refresh**: CMS issues the following year's transmittal in Nov/Dec (the
+CY2026 update was dated 2025-12-05 for a Jan 1, 2026 effective date). Add a
+row to `FQHC_PPS_BASE_RATES` each year once it posts — search CMS's own
+transmittals (Pub 100-04 Medicare Claims Processing, or Pub 100-02 Medicare
+Benefit Policy) for "FQHC PPS Calendar Year".
 
 ## ADLT list — brand name to billing code
 
@@ -57,8 +83,26 @@ were checked and rejected:
 - **NCBI GTR** — knows Signatera and Guardant360 but its `cptcode` field is
   empty for them.
 
-So coverage is limited to ADLTs. A test outside the list gets
-`found: false, reason: not_on_adlt_list` and a pointer to `medicare_lab_rate`.
+That made coverage ADLT-only, and fleet #2458 measured the cost: Oncotype DX
+(81519, a Category I MAAA code, not an ADLT) routed here 5/5 and came back
+`found: false`. Resolution now runs through three sources in order:
+
+1. **CMS ADLT list** (`src/adlt.ts`, below).
+2. **MAAA brand table** (`src/brand-codes.ts`) -- non-ADLT branded tests whose
+   proprietary name is tied to a code in CPT Appendix O and which each have a
+   brand-named or category MolDX billing article on the CMS MCD (Oncotype DX
+   breast/DCIS/colon/prostate, Prosigna, MammaPrint, EndoPredict, Breast
+   Cancer Index, Cologuard, Prolaris, Decipher, Afirma, ConfirmMDx, 4Kscore).
+   Only brand -> code -> lab FACTS are kept, never AMA descriptor text. Every
+   code was checked to carry a CLFS rate on 2026-09-26. To add a row: confirm
+   the pair in a public source, confirm `medicare_lab_rate` has a rate, and set
+   `coverage_topic` to a phrase from a live MolDX article title.
+3. **NCBI GTR, live** -- where the performing lab registered a CPT code
+   (e.g. Afirma -> 81546, Decipher -> 81542). Labelled lab-reported. Sparse:
+   Oncotype DX and Signatera carry no code there, which is why it is last.
+
+A test found in none returns `found: false, reason: brand_not_found` with
+`sources_checked` naming all three, and a pointer to `medicare_lab_rate`.
 
 **Copy, not proxy.** The list is a two-page PDF with no API, and the gateway
 has no PDF parser, so the rows are baked into `src/adlt.ts`. The PDF's "Test
@@ -293,7 +337,7 @@ directly, instead of just this one's:
 }
 ```
 
-Both URLs reach the same gateway and the same 1683+ data sources. The
+Both URLs reach the same gateway and the same 1831+ data sources. The
 only difference is which pack's tools are listed **directly**; `ask_pipeworx`
 reaches all of them from either one.
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pipeworx/mcp-medicare-pricing",
-  "version": "0.1.2",
-  "description": "What does Medicare PAY — physician fee schedule, lab rates, and per-day unit",
+  "version": "0.1.4",
+  "description": "What does Medicare PAY — physician fee schedule, lab rates, and per-day unit limits.",
   "type": "module",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -26,7 +26,7 @@
     "@cloudflare/workers-types": "^4.20260405.1"
   },
   "pipeworx": {
-    "sourceHash": "v1-39abb67f2c97d76656d44948e3ff83744176d3ab644ad6bb0dfb4fe227df10b6",
-    "sourceCommit": "6182c4cfebddb94950e060b5d2fca18f18ad1aca"
+    "sourceHash": "v1-65f2f81a2d58d5024e9845e0238d0a24b75f7fa653f412494f5054bb6cfc84dd",
+    "sourceCommit": "514e3efb42b8d81082c07e01d3ae7654bbf91f52"
   }
 }

package/server.json

@@ -2,8 +2,8 @@
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.pipeworx-io/medicare-pricing",
   "title": "Medicare Pricing",
-  "description": "What does Medicare PAY — physician fee schedule, lab rates, and per-day unit",
-  "version": "0.1.2",
+  "description": "What does Medicare PAY — physician fee schedule, lab rates, and per-day unit limits.",
+  "version": "0.1.4",
   "websiteUrl": "https://pipeworx.io/packs/medicare-pricing",
   "repository": {
     "url": "https://github.com/pipeworx-io/mcp-medicare-pricing",

package/src/brand-codes.ts

@@ -0,0 +1,113 @@
+/**
+ * Branded lab tests that are NOT ADLTs but carry their own code (fleet #2458).
+ *
+ * #2426 resolved brand names only through the CMS ADLT list, so the most-asked
+ * branded test of all -- Oncotype DX, a Category I MAAA code (81519) -- came
+ * back found:false. Two more sources close the class:
+ *
+ *  1. THIS TABLE: the Category I MAAA tests whose proprietary name is tied to
+ *     its code in CPT Appendix O, each also the subject of a brand-named MolDX
+ *     billing-and-coding article on the CMS Medicare Coverage Database. What is
+ *     kept is the FACT (brand -> code -> lab), never the AMA descriptor text,
+ *     under the same rule as adlt.ts. Every code here was checked on
+ *     2026-09-26 to carry a rate on the loaded CLFS.
+ *  2. NCBI GTR (Genetic Testing Registry), fetched LIVE per request: labs
+ *     register their tests there and many state the CPT code. US government
+ *     work, keyless E-utilities. It is lab-reported, so the answer says so.
+ *
+ * `coverage_topic` is a phrase from the title of the test's MolDX policy (a
+ * brand-named billing article where one exists), matched live against the CMS
+ * Coverage API title list -- ours, not CMS's, checked 2026-09-26.
+ */
+
+export interface BrandTest {
+  code: string;
+  lab: string;
+  test_name: string;
+  aliases: string[];
+  coverage_topic: string | null;
+}
+
+export const BRAND_SOURCE = 'CPT Appendix O (MAAA) proprietary-name-to-code pairs, each with a brand-named or category MolDX billing article on the CMS Medicare Coverage Database';
+export const BRAND_DATA_AS_OF = '2026-09-26';
+
+export const BRAND_TESTS: BrandTest[] = [
+  { code: '81519', lab: 'Genomic Health (Exact Sciences)', test_name: 'Oncotype DX Breast Recurrence Score', aliases: ['Oncotype DX', 'Oncotype DX Breast', 'Oncotype DX Breast Cancer Assay', 'Oncotype'], coverage_topic: 'Oncotype DX Breast Cancer Assay' },
+  { code: '0045U', lab: 'Genomic Health (Exact Sciences)', test_name: 'Oncotype DX Breast DCIS Score', aliases: ['Oncotype DX DCIS', 'Oncotype DCIS'], coverage_topic: 'Oncotype DX Breast Cancer for DCIS' },
+  { code: '81525', lab: 'Genomic Health (Exact Sciences)', test_name: 'Oncotype DX Colon Recurrence Score', aliases: ['Oncotype DX Colon', 'Oncotype DX Colon Cancer Assay'], coverage_topic: 'Oncotype DX Colon Cancer' },
+  { code: '0047U', lab: 'Genomic Health (Exact Sciences)', test_name: 'Oncotype DX Genomic Prostate Score', aliases: ['Oncotype DX Prostate', 'Genomic Prostate Score', 'Oncotype GPS'], coverage_topic: 'Prostate Cancer Genomic Classifier Assay' },
+  { code: '81518', lab: 'Biotheranostics (Hologic)', test_name: 'Breast Cancer Index', aliases: ['BCI'], coverage_topic: 'Breast Cancer Index' },
+  { code: '81520', lab: 'NanoString Technologies (Veracyte)', test_name: 'Prosigna', aliases: ['Prosigna Breast Cancer Prognostic Gene Signature Assay', 'PAM50'], coverage_topic: 'Prosigna' },
+  { code: '81521', lab: 'Agendia', test_name: 'MammaPrint', aliases: [], coverage_topic: 'MammaPrint' },
+  { code: '81522', lab: 'Myriad Genetics', test_name: 'EndoPredict', aliases: [], coverage_topic: 'EndoPredict' },
+  { code: '81528', lab: 'Exact Sciences', test_name: 'Cologuard', aliases: [], coverage_topic: null },
+  { code: '81541', lab: 'Myriad Genetics', test_name: 'Prolaris', aliases: [], coverage_topic: 'Prostate Cancer Genomic Classifier Assay' },
+  { code: '81542', lab: 'Veracyte (Decipher Biosciences)', test_name: 'Decipher Prostate', aliases: ['Decipher', 'Decipher Prostate Genomic Classifier'], coverage_topic: 'Prostate Cancer Genomic Classifier Assay' },
+  { code: '81546', lab: 'Veracyte', test_name: 'Afirma Genomic Sequencing Classifier', aliases: ['Afirma', 'Afirma GSC'], coverage_topic: 'Molecular Testing for Risk Stratification of Thyroid Nodules' },
+  { code: '81551', lab: 'MDxHealth', test_name: 'ConfirmMDx', aliases: ['ConfirmMDx for Prostate Cancer'], coverage_topic: 'Molecular Biomarkers to Risk-Stratify Patients at Increased Risk for Prostate Cancer' },
+  { code: '81539', lab: 'OPKO Health (BioReference)', test_name: '4Kscore', aliases: ['4K score', '4Kscore Test'], coverage_topic: 'Molecular Biomarkers to Risk-Stratify Patients at Increased Risk for Prostate Cancer' },
+];
+
+export const norm = (s: string) => s.toLowerCase().replace(/[®™]/g, '').replace(/[^a-z0-9]/g, '');
+
+type Named = { code: string; test_name: string; aliases: string[]; lab: string };
+
+/**
+ * Match free text to rows: by code, then exact name/alias, then containment
+ * (either way, longest name wins so "Oncotype DX colon" is colon, not breast),
+ * then lab. A name hit beats a lab hit.
+ */
+export function matchTests<T extends Named>(rows: T[], query: string): { matched_by: 'code' | 'test_name' | 'lab' | null; tests: T[] } {
+  const q = norm(query);
+  if (q.length < 3) return { matched_by: null, tests: [] };
+  const byCode = rows.filter((t) => norm(t.code) === q);
+  if (byCode.length) return { matched_by: 'code', tests: byCode };
+  const names = (t: T) => [t.test_name, ...t.aliases].map(norm);
+  const exact = rows.filter((t) => names(t).includes(q));
+  if (exact.length) return { matched_by: 'test_name', tests: exact };
+  const byName = rows.filter((t) => names(t).some((n) => n.length >= 4 && (n.includes(q) || q.includes(n))));
+  if (byName.length) {
+    const longest = Math.max(...byName.map((t) => Math.max(...names(t).filter((n) => q.includes(n)).map((n) => n.length), 0)));
+    const narrowed = longest > 0 ? byName.filter((t) => names(t).some((n) => n.length === longest && q.includes(n))) : byName;
+    return { matched_by: 'test_name', tests: narrowed };
+  }
+  const byLab = rows.filter((t) => q.length >= 4 && norm(t.lab).includes(q));
+  if (byLab.length) return { matched_by: 'lab', tests: byLab };
+  return { matched_by: null, tests: [] };
+}
+
+export interface GtrHit { code: string; test_name: string; lab: string; gtr_accession: string; url: string }
+
+/**
+ * NCBI GTR, live: tests whose registered name matches the query AND whose lab
+ * stated a CPT code. null when NCBI did not answer (distinct from "no hit").
+ */
+export async function gtrLookup(query: string, fetcher: typeof fetch): Promise<GtrHit[] | null> {
+  const q = norm(query);
+  if (q.length < 4) return [];
+  const base = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils';
+  const tool = '&tool=pipeworx&email=support%40pipeworx.io';
+  try {
+    const s = await fetcher(`${base}/esearch.fcgi?db=gtr&retmode=json&retmax=40&term=${encodeURIComponent(query)}${tool}`);
+    if (!s.ok) return null;
+    const ids = ((await s.json()) as { esearchresult?: { idlist?: string[] } }).esearchresult?.idlist ?? [];
+    if (!ids.length) return [];
+    const r = await fetcher(`${base}/esummary.fcgi?db=gtr&retmode=json&id=${ids.join(',')}${tool}`);
+    if (!r.ok) return null;
+    const res = ((await r.json()) as { result?: Record<string, any> }).result ?? {};
+    const hits: GtrHit[] = [];
+    for (const id of ids) {
+      const x = res[id];
+      if (!x || typeof x.testname !== 'string') continue;
+      const n = norm(x.testname);
+      if (!(n.includes(q) || (n.length >= 4 && q.includes(n)))) continue;
+      const codes = String(x.cptcode ?? '').split(/[^0-9A-Za-z]+/).map((c: string) => c.toUpperCase()).filter((c: string) => /^(\d{5}|\d{4}U)$/.test(c));
+      for (const code of codes) {
+        hits.push({ code, test_name: x.testname, lab: String(x.offerer ?? ''), gtr_accession: String(x.accession ?? ''), url: `https://www.ncbi.nlm.nih.gov/gtr/tests/${id}/` });
+      }
+    }
+    return hits;
+  } catch {
+    return null;
+  }
+}

package/src/index.ts

@@ -740,6 +740,7 @@ function collapse(s: string): string {
  */
 
 import { ADLT_DATA_AS_OF, ADLT_SOURCE_URL, SNAPSHOT_LAST_MODIFIED, matchAdlt, type AdltTest } from './adlt.js';
+import { BRAND_DATA_AS_OF, BRAND_SOURCE, BRAND_TESTS, gtrLookup, matchTests, norm as normName } from './brand-codes.js';
 
 // Bound every fetch() in this pack to a fixed timeout — an upstream that
 // degrades without erroring would otherwise hold the Worker in `await fetch()`
@@ -863,6 +864,94 @@ const STATUS: Record<string, string> = {
   X: 'Statutorily excluded from the fee schedule',
 };
 
+// ── FQHC PPS base payment rate (fleet #3241) ──────────────────────────────
+//
+// CMS publishes this ONE number a year, in a CMS Manual System TRANSMITTAL
+// (a "Recurring Update Notification" Change Request PDF) — there is no API
+// and no bulk file, just a yearly PDF with a single new figure in it. A
+// hand-maintained table of a handful of values is the documented shape for
+// that case (house rule for fleet #3241: "a PDF fact sheet with one number
+// per year... a tiny dated table is acceptable"), not a Supabase ingest
+// pipeline for five numbers. Every row below was read directly off its own
+// primary CMS transmittal (not a summary site) — see transmittal/change
+// request/pub per row.
+//
+// REFRESH: CMS issues the next year's transmittal in Nov/Dec for the
+// following Jan 1 (the CY2026 one was dated 2025-12-05) — add a row here
+// each year when it posts. Search "FQHC PPS Calendar Year" among CMS's own
+// transmittals (Pub 100-04 Medicare Claims Processing or Pub 100-02 Medicare
+// Benefit Policy) to find the next one.
+interface FqhcPpsRow {
+  year: number;
+  base_rate_usd: number;
+  effective_date: string;
+  market_basket_update_pct: number;
+  prior_year_rate_usd: number;
+  transmittal: string;
+  change_request: string;
+  publication: string;
+}
+const FQHC_PPS_BASE_RATES: FqhcPpsRow[] = [
+  { year: 2022, base_rate_usd: 180.16, effective_date: '2022-01-01', market_basket_update_pct: 2.1, prior_year_rate_usd: 176.45, transmittal: 'Transmittal 11057', change_request: 'CR 12490', publication: 'Pub 100-04 Medicare Claims Processing' },
+  { year: 2023, base_rate_usd: 187.19, effective_date: '2023-01-01', market_basket_update_pct: 3.9, prior_year_rate_usd: 180.16, transmittal: 'Transmittal 11677', change_request: 'CR 12961', publication: 'Pub 100-04 Medicare Claims Processing' },
+  { year: 2024, base_rate_usd: 195.99, effective_date: '2024-01-01', market_basket_update_pct: 4.7, prior_year_rate_usd: 187.19, transmittal: 'Transmittal 12267', change_request: 'CR 13398', publication: 'Pub 100-04 Medicare Claims Processing' },
+  { year: 2025, base_rate_usd: 202.65, effective_date: '2025-01-01', market_basket_update_pct: 3.4, prior_year_rate_usd: 195.99, transmittal: 'Transmittal 12951', change_request: 'CR 13867', publication: 'Pub 100-04 Medicare Claims Processing' },
+  { year: 2026, base_rate_usd: 207.72, effective_date: '2026-01-01', market_basket_update_pct: 2.5, prior_year_rate_usd: 202.65, transmittal: 'Transmittal 13506', change_request: 'CR 14309', publication: 'Pub 100-02 Medicare Benefit Policy' },
+];
+const FQHC_SOURCE = 'Centers for Medicare & Medicaid Services (CMS), Federally Qualified Health Center (FQHC) Prospective Payment System base payment rate';
+
+function fqhcStatement(r: FqhcPpsRow): string {
+  return `CMS FQHC PPS base payment rate for CY ${r.year}: $${r.base_rate_usd.toFixed(2)}, effective ${r.effective_date} — a ${r.market_basket_update_pct}% FQHC market basket increase over CY ${r.year - 1}'s $${r.prior_year_rate_usd.toFixed(2)} (${r.transmittal}, ${r.change_request}, ${r.publication}). This is the national base rate before any per-FQHC Geographic Adjustment Factor (GAF).`;
+}
+
+function fqhcPpsRate(args: Record<string, unknown>) {
+  const askedYear = typeof args.year === 'number' ? Math.floor(args.year) : null;
+  const rows = FQHC_PPS_BASE_RATES;
+  if (askedYear == null) {
+    const latest = rows[rows.length - 1];
+    return {
+      found: true,
+      source: FQHC_SOURCE,
+      year: latest.year,
+      year_was_defaulted: true,
+      base_rate_usd: latest.base_rate_usd,
+      effective_date: latest.effective_date,
+      market_basket_update_pct: latest.market_basket_update_pct,
+      prior_year_rate_usd: latest.prior_year_rate_usd,
+      transmittal: latest.transmittal,
+      change_request: latest.change_request,
+      publication: latest.publication,
+      statement: fqhcStatement(latest),
+      per_visit_not_per_code: 'This is a per-DAY encounter rate (lesser of actual charges or this PPS rate), not a fee per HCPCS/CPT code.',
+      history: rows,
+    };
+  }
+  const row = rows.find((r) => r.year === askedYear);
+  if (!row) {
+    return {
+      found: false,
+      reason: 'year_not_loaded',
+      loaded_years: rows.map((r) => r.year),
+      hint: `No FQHC PPS base payment rate loaded for CY ${askedYear}. Loaded years: ${rows.map((r) => r.year).join(', ')}.`,
+    };
+  }
+  return {
+    found: true,
+    source: FQHC_SOURCE,
+    year: row.year,
+    year_was_defaulted: false,
+    base_rate_usd: row.base_rate_usd,
+    effective_date: row.effective_date,
+    market_basket_update_pct: row.market_basket_update_pct,
+    prior_year_rate_usd: row.prior_year_rate_usd,
+    transmittal: row.transmittal,
+    change_request: row.change_request,
+    publication: row.publication,
+    statement: fqhcStatement(row),
+    per_visit_not_per_code: 'This is a per-DAY encounter rate (lesser of actual charges or this PPS rate), not a fee per HCPCS/CPT code.',
+  };
+}
+
 const tools: McpToolExport['tools'] = [
   {
     name: 'medicare_physician_payment',
@@ -896,7 +985,7 @@ const tools: McpToolExport['tools'] = [
   {
     name: 'medicare_lab_test_lookup',
     description:
-      'Resolve a branded molecular or genomic lab test by its commercial name (e.g. Signatera, Guardant360 CDx, FoundationOne CDx, FoundationOne Liquid CDx, Tempus xT CDx, DecisionDx-Melanoma, Envisia, Shield) to its CPT PLA / HCPCS billing code, the lab that runs it, what Medicare pays for it now on the Clinical Laboratory Fee Schedule, and the MolDX local coverage determinations (LCDs) and billing-and-coding articles for its test category. Answers "what does Medicare pay for Signatera", "what is the PLA code for Guardant360", "which MolDX LCD covers this test". Also accepts a lab name (e.g. "Natera") or a code. Covers the tests on the CMS list of Advanced Diagnostic Laboratory Tests (ADLTs), the only public list that ties a test\'s brand name to its code; a test not on it returns not_found with the reason. Sourced from CMS (ADLT list, Clinical Laboratory Fee Schedule, Medicare Coverage Database).',
+      'Resolve a branded molecular or genomic lab test by its commercial name (e.g. Signatera, Guardant360 CDx, FoundationOne CDx, FoundationOne Liquid CDx, Tempus xT CDx, DecisionDx-Melanoma, Envisia, Shield) to its CPT PLA / HCPCS billing code, the lab that runs it, what Medicare pays for it now on the Clinical Laboratory Fee Schedule, and the MolDX local coverage determinations (LCDs) and billing-and-coding articles for its test category. Answers "what does Medicare pay for Signatera", "what is the PLA code for Guardant360", "which MolDX LCD covers this test". Also accepts a lab name (e.g. "Natera") or a code. Also covers non-ADLT branded MAAA tests (Oncotype DX, Prosigna, MammaPrint, EndoPredict, Breast Cancer Index, Cologuard, Prolaris, Decipher, Afirma, ConfirmMDx, 4Kscore) and any test whose lab registered its code in the NCBI Genetic Testing Registry. Resolves in order: the CMS list of Advanced Diagnostic Laboratory Tests (ADLTs), a brand-to-code table of MAAA tests with MolDX billing articles, then NCBI GTR live; a test found in none returns brand_not_found naming every source checked. Sourced from CMS (ADLT list, Clinical Laboratory Fee Schedule, Medicare Coverage Database) and NCBI GTR.',
     inputSchema: {
       type: 'object' as const,
       properties: {
@@ -966,6 +1055,18 @@ const tools: McpToolExport['tools'] = [
       required: ['code'],
     },
   },
+  {
+    name: 'medicare_fqhc_pps_rate',
+    description:
+      'What does Medicare pay a Federally Qualified Health Center (FQHC) per visit? Returns the CMS FQHC Prospective Payment System (PPS) national BASE payment rate for a calendar year — the figure CMS publishes once a year, before any per-FQHC Geographic Adjustment Factor (GAF) is applied. Answers "what is the FQHC PPS base rate", "how much does Medicare pay an FQHC per encounter", "FQHC PPS rate for 2025 vs 2026". '
+      + 'Medicare pays an FQHC the LESSER of its actual charges or this PPS rate for all FQHC services furnished to a beneficiary on a day with a qualifying face-to-face visit — it is a per-DAY encounter rate, not a fee per procedure code (unlike medicare_physician_payment/medicare_lab_rate). This tool does NOT compute the GAF-adjusted, FQHC-specific amount — only the national base rate before that adjustment; the GAF table is not loaded here. Omit year for the newest loaded year plus the full known history (small — CMS publishes one number a year); pass year for one row.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        year: { type: 'number', description: 'Calendar year, e.g. 2026. Omit to get the newest loaded year AND the full history table.' },
+      },
+    },
+  },
   {
     name: 'medicare_pricing_coverage',
     description:
@@ -1041,6 +1142,12 @@ async function resolveLocality(cfg: Cfg, q: unknown, year: number): Promise<{ ch
 }
 
 async function callTool(name: string, args: Record<string, unknown>): Promise<unknown> {
+  // FQHC PPS is a hand-maintained constant table (see FQHC_PPS_BASE_RATES
+  // above) — not Supabase-backed like the rest of this pack — so it is
+  // dispatched before the credential check below, which every OTHER tool
+  // here needs.
+  if (name === 'medicare_fqhc_pps_rate') return fqhcPpsRate(args);
+
   const url = (args._supabaseUrl as string | undefined)?.trim();
   const key = (args._supabaseKey as string | undefined)?.trim();
   if (!url || !key) {
@@ -1136,57 +1243,94 @@ async function callTool(name: string, args: Record<string, unknown>): Promise<un
       const test = typeof args.test === 'string' ? args.test.trim() : '';
       if (!test) return { found: false, reason: 'no_test', hint: 'Pass test, e.g. "Signatera".' };
       const includeRetired = args.include_retired === true;
-      const { matched_by, tests } = matchAdlt(test);
-      const [snapshot, coverage] = await Promise.all([adltSnapshotCheck(), tests.some((t) => t.coverage_topic) ? coverageIndex() : Promise.resolve(null)]);
+      // Sources in order (fleet #2458): the CMS ADLT list, then the MAAA brand
+      // table, then NCBI GTR live. The first that resolves answers; a miss
+      // names every source checked.
+      type Row = { code: string; test_name: string; lab: string; coverage_topic: string | null; code_source: string; adlt?: AdltTest; gtr?: { accession: string; url: string } };
+      const sourcesChecked: string[] = ['CMS ADLT list'];
+      let matched_by: string | null = null;
+      let rows: Row[] = [];
+      let sourceLabel = 'CMS list of Advanced Diagnostic Laboratory Tests (ADLTs) under the Medicare CLFS';
+      const adltHit = matchAdlt(test);
+      if (adltHit.tests.length) {
+        matched_by = adltHit.matched_by;
+        rows = adltHit.tests.map((t) => ({ code: t.code, test_name: t.test_name, lab: t.lab, coverage_topic: t.coverage_topic, code_source: 'CMS ADLT list', adlt: t }));
+      } else {
+        sourcesChecked.push('MAAA brand table (CPT Appendix O pairs backed by MolDX billing articles)');
+        const b = matchTests(BRAND_TESTS, test);
+        if (b.tests.length) {
+          matched_by = b.matched_by;
+          sourceLabel = BRAND_SOURCE;
+          rows = b.tests.map((t) => ({ code: t.code, test_name: t.test_name, lab: t.lab, coverage_topic: t.coverage_topic, code_source: 'MAAA brand table' }));
+        } else {
+          sourcesChecked.push('NCBI Genetic Testing Registry (live)');
+          const g = await gtrLookup(test, ((u: string) => pwFetch(u)) as unknown as typeof fetch);
+          if (g === null) sourcesChecked[sourcesChecked.length - 1] += ' — did not answer';
+          else if (g.length) {
+            matched_by = 'test_name';
+            sourceLabel = 'NCBI Genetic Testing Registry (GTR), code as registered by the performing lab';
+            const seen = new Set<string>();
+            rows = g.filter((h) => !seen.has(h.code + h.lab) && seen.add(h.code + h.lab)).slice(0, 10)
+              .map((h) => ({ code: h.code, test_name: h.test_name, lab: h.lab, coverage_topic: null, code_source: 'NCBI GTR (lab-reported)', gtr: { accession: h.gtr_accession, url: h.url } }));
+          }
+        }
+      }
+      const fromAdlt = rows.some((r) => r.adlt);
+      const [snapshot, coverage] = await Promise.all([
+        fromAdlt || !rows.length ? adltSnapshotCheck() : Promise.resolve({}),
+        rows.some((t) => t.coverage_topic) ? coverageIndex() : Promise.resolve(null),
+      ]);
       const provenance = {
-        source: 'CMS list of Advanced Diagnostic Laboratory Tests (ADLTs) under the Medicare CLFS; rates from the CMS Clinical Laboratory Fee Schedule; policies from the CMS Medicare Coverage Database',
-        source_url: ADLT_SOURCE_URL,
-        data_as_of: ADLT_DATA_AS_OF,
+        source: `${sourceLabel}; rates from the CMS Clinical Laboratory Fee Schedule; policies from the CMS Medicare Coverage Database`,
+        source_url: fromAdlt || !rows.length ? ADLT_SOURCE_URL : rows[0].gtr ? 'https://www.ncbi.nlm.nih.gov/gtr/' : 'https://www.cms.gov/medicare-coverage-database/',
+        data_as_of: fromAdlt || !rows.length ? ADLT_DATA_AS_OF : rows[0].gtr ? new Date().toISOString().slice(0, 10) : BRAND_DATA_AS_OF,
         ...snapshot,
       };
-      if (!tests.length) {
+      if (!rows.length) {
         return {
           found: false,
-          reason: 'not_on_adlt_list',
+          reason: 'brand_not_found',
           test,
-          hint: 'This test is not on CMS\'s ADLT list, which is the only public list that maps a lab test\'s brand name to its billing code. Most PLA codes are not ADLTs; the full PLA code list with proprietary names is published by the AMA under copyright. If you have the code (it usually ends in U, e.g. "0340U"), medicare_lab_rate gives its rate; medicare_lcd_search finds coverage policies by topic.',
+          sources_checked: sourcesChecked,
+          hint: `No billing code found for "${test}" in: ${sourcesChecked.join('; ')}. The full PLA code list with proprietary names is published by the AMA under copyright and is not used here. If you have the code (PLA codes end in U, e.g. "0340U"), medicare_lab_rate gives its rate; medicare_lcd_search finds coverage policies by topic.`,
           ...provenance,
         };
       }
-      const results = await Promise.all(tests.map(async (t: AdltTest) => {
+      const results = await Promise.all(rows.map(async (t) => {
         const rates = await pg<{ year: number; quarter: string; rate: number }>(cfg,
           `clfs_rates?hcpcs=eq.${t.code}&select=year,quarter,rate&order=year.desc,quarter.desc&limit=1`);
         // "Response to Comments" articles are the comment period's record, not policy.
-        const docs = t.coverage_topic && coverage
-          ? coverage.filter((d) => d.title.toLowerCase().includes(t.coverage_topic!.toLowerCase()) && !/^response to comments/i.test(d.title))
+        const topic = t.coverage_topic ? normName(t.coverage_topic) : '';
+        const docs = topic && coverage
+          ? coverage.filter((d) => normName(d.title).includes(topic) && !/^response to comments/i.test(d.title))
           : [];
         const active = docs.filter((d) => !d.retired);
         const retired = docs.filter((d) => d.retired);
+        const a = t.adlt;
         return {
           code: t.code,
-          ...(t.code_note ? { code_note: t.code_note } : {}),
+          ...(a?.code_note ? { code_note: a.code_note } : {}),
           test_name: t.test_name,
           lab: t.lab,
+          code_source: t.code_source,
+          ...(t.gtr ? { gtr: t.gtr } : {}),
           current_clfs_rate: rates.length
             ? { rate_usd: rates[0].rate, fee_schedule_year: rates[0].year, quarter: rates[0].quarter, note: 'National rate; the CLFS is not adjusted by locality.' }
             : { rate_usd: null, note: `${t.code} has no rate on the loaded Clinical Laboratory Fee Schedule (it may be contractor-priced).` },
-          adlt: {
-            approval_date: t.adlt_approval_date,
-            existing_adlt: t.existing_adlt,
-            new_adlt_initial_period: t.new_adlt_initial_period,
-            initial_period_payment_usd: t.initial_period_payment_usd,
-          },
+          adlt: a
+            ? { approval_date: a.adlt_approval_date, existing_adlt: a.existing_adlt, new_adlt_initial_period: a.new_adlt_initial_period, initial_period_payment_usd: a.initial_period_payment_usd }
+            : { is_adlt: false },
           coverage: t.coverage_topic
             ? {
                 policy_topic: t.coverage_topic,
-                topic_note: 'Policies whose title matches this test\'s category (our topic mapping, not CMS\'s). Whether this specific test is listed is stated in the billing article\'s code table.',
+                topic_note: 'Policies whose title matches this test or its category (our topic mapping, not CMS\'s). Whether this specific test is listed is stated in the billing article\'s code table.',
                 active_documents: active.slice(0, 20),
                 active_count: active.length,
                 ...(includeRetired ? { retired_documents: retired.slice(0, 20) } : {}),
                 retired_count: retired.length,
                 ...(coverage === null ? { error: 'CMS Coverage API did not answer; retry, or use medicare_lcd_search with the policy_topic.' } : {}),
               }
-            : { policy_topic: null, note: 'No MolDX local policy title matches this test\'s category; it may be covered nationally (NCD) or case by case.' },
+            : { policy_topic: null, note: 'No MolDX local policy title matched to this test; it may be covered nationally (NCD) or case by case — medicare_lcd_search can look.' },
         };
       }));
       return {
@@ -1194,7 +1338,8 @@ async function callTool(name: string, args: Record<string, unknown>): Promise<un
         query: test,
         matched_by,
         tests: results,
-        no_descriptors_note: 'The AMA\'s CPT PLA descriptor text is not returned (AMA copyright); the test name and lab are CMS\'s.',
+        sources_checked: sourcesChecked,
+        no_descriptors_note: 'The AMA\'s CPT descriptor text is not returned (AMA copyright); only the code, test name and lab.',
         ...provenance,
       };
     }
@@ -1391,6 +1536,7 @@ async function callTool(name: string, args: Record<string, unknown>): Promise<un
         geographic_localities: gpciN.length ? { year: gpciN[0].year } : null,
         clinical_lab_fee_schedule: clfsN.length ? { year: clfsN[0].year, quarter: clfsN[0].quarter } : null,
         dmepos_fee_schedule: dmeN.length ? { year: dmeN[0].year, release: dmeN[0].release, release_month: DME_RELEASE_MONTH[dmeN[0].release] ?? null, priced_by: 'state (not Medicare locality), with separate rural/non-rural amounts' } : null,
+        fqhc_pps_base_rate: { newest_loaded_year: FQHC_PPS_BASE_RATES[FQHC_PPS_BASE_RATES.length - 1].year, loaded_years: FQHC_PPS_BASE_RATES.map((r) => r.year), source: FQHC_SOURCE },
         medically_unlikely_edits: mueN.length ? { effective_from: mueN[0].effective_date } : null,
         procedure_to_procedure_edits: ptpRange.length ? {
           baseline_vintage: '2026q3 (v322r0, effective 2026-07-01) — CMS\'s FULL NCCI PTP edit baseline, AMA-CPT-licence-gated; licence accepted on the company\'s behalf by Bruce, 2026-09-07 (fleet #1293)',
@@ -1400,7 +1546,7 @@ async function callTool(name: string, args: Record<string, unknown>): Promise<un
         refresh_cadence: 'Physician fee schedule annually (with intra-year releases); lab fee schedule, DMEPOS fee schedule, MUE units edits, and PTP pair-edit changes all quarterly (as necessary).',
         no_descriptions_note:
           'CPT procedure descriptions (physician fee schedule, lab schedule) are not returned — American Medical Association copyright. DMEPOS is the exception: it uses HCPCS Level II codes, which CMS itself maintains, so medicare_dmepos_rate DOES return the code description.',
-        source: 'CMS Physician Fee Schedule, Clinical Laboratory Fee Schedule, DMEPOS fee schedule, and National Correct Coding Initiative (MUE + PTP quarterly change files)',
+        source: 'CMS Physician Fee Schedule, Clinical Laboratory Fee Schedule, DMEPOS fee schedule, FQHC PPS base payment rate, and National Correct Coding Initiative (MUE + PTP quarterly change files)',
       };
     }
 

package/src/server.ts

@@ -8,8 +8,9 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import pack from './index.js';
 
+
 const server = new Server(
-  { name: '@pipeworx/mcp-medicare-pricing', version: '0.1.2' },
+  { name: '@pipeworx/mcp-medicare-pricing', version: '0.1.4' },
   { capabilities: { tools: {} } },
 );
 
@@ -24,7 +25,9 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
   const { name, arguments: args } = request.params;
   try {
-    const result = await pack.callTool(name, (args ?? {}) as Record<string, unknown>);
+    const callArgs = { ...((args ?? {}) as Record<string, unknown>) };
+    
+    const result = await pack.callTool(name, callArgs);
     return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
   } catch (err) {
     return {