@pipeworx/mcp-medicare-pricing 0.1.1 → 0.1.3

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 1679+ live data sources.
+Part of [Pipeworx](https://pipeworx.io) — an MCP gateway connecting AI agents to 1683+ live data sources.
 
 ## Tools
 
@@ -12,6 +12,7 @@ Part of [Pipeworx](https://pipeworx.io) — an MCP gateway connecting AI agents
 |---|---|
 | `medicare_physician_payment` | "How much does Medicare pay for 99213 in Los Angeles?" — RVUs and dollars, locality-adjusted. |
 | `medicare_lab_rate` | "What does a comprehensive metabolic panel reimburse?" — national CLFS rate. |
+| `medicare_lab_test_lookup` | "What does Medicare pay for Signatera, and which MolDX LCD applies?" — brand name → PLA code, current CLFS rate, and the MolDX LCDs/articles for the test's category. |
 | `medicare_dmepos_rate` | "How much does Medicare pay for a CPAP machine (E0601) in Texas?" — state-priced, rural vs non-rural. |
 | `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. |
@@ -32,6 +33,69 @@ All from CMS, all downloadable files with no API:
 - **NCCI Medically Unlikely Edits** — quarterly
 - **NCCI PTP quarterly additions/deletions/revisions files** — quarterly (see below — a narrower source than the other three)
 
+## ADLT list — brand name to billing code
+
+`medicare_lab_test_lookup` exists because callers name a test by its brand
+("Signatera"), not its code ("0340U"), and nothing else in the catalog maps one
+to the other (fleet #2426).
+
+**Source, and why it is the only one.** CMS's list of Advanced Diagnostic
+Laboratory Tests
+(<https://www.cms.gov/files/document/advanced-diagnostic-laboratory-tests-under-medicare-clfs.pdf>)
+gives code, lab, proprietary test name, approval date and initial-period
+payment for 18 tests. It is a US federal work (17 USC 105). The sources that
+were checked and rejected:
+
+- **AMA PLA long-descriptor PDF** — "CPT® Copyright 2026 American Medical
+  Association. All rights reserved." It also lists only the codes changed in
+  the latest cycles (143 of them), and 0340U is not among them.
+- **Palmetto MolDX DEX registry** — needs a registered account, even for the
+  "public user" catalog, and hides Z-codes from public users. That's an auth
+  wall.
+- **CMS Coverage API article code tables** — need a caller's CMS/AMA licence
+  token (already how `medicare-coverage` handles it).
+- **NCBI GTR** — knows Signatera and Guardant360 but its `cptcode` field is
+  empty for them.
+
+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
+Descriptor" column is AMA PLA text and is **not** copied. Every call sends a
+HEAD to the PDF and compares `Last-Modified` with the snapshot's. If CMS has
+republished, the response carries `snapshot_current: false`. To refresh:
+download the PDF, extract its text (`pypdf` works), update the rows in
+`src/adlt.ts`, and bump `ADLT_DATA_AS_OF` and `SNAPSHOT_LAST_MODIFIED`.
+
+**Coverage.** Each test has a `coverage_topic`, a phrase that is ours and not
+CMS's. It matches the title of the MolDX LCD/article family for the test's
+category (for Signatera, "Minimal Residual Disease"). The tool reads the live,
+keyless CMS Coverage API reports and returns the active LCDs and billing
+articles with that title. Retired ones come back only with
+`include_retired: true`. This matters because contractors re-issue MolDX
+policies under new numbers: Noridian's L38816 and A58456 were retired
+2026-02-05 and replaced by L38814 and A58454. Whether a specific test is listed
+is answered by the billing article's code table, not by the title match.
+
 ## Vintage is not a detail
 
 Fee schedules change annually and NCCI/CLFS quarterly. Quoting a 2026 procedure
@@ -247,7 +311,7 @@ directly, instead of just this one's:
 }
 ```
 
-Both URLs reach the same gateway and the same 1679+ data sources. The
+Both URLs reach the same gateway and the same 1683+ 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,6 +1,6 @@
 {
   "name": "@pipeworx/mcp-medicare-pricing",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "What does Medicare PAY — physician fee schedule, lab rates, and per-day unit",
   "type": "module",
   "main": "src/index.ts",
@@ -26,7 +26,7 @@
     "@cloudflare/workers-types": "^4.20260405.1"
   },
   "pipeworx": {
-    "sourceHash": "v1-99cba48ac939afdd396bff76c29f505a71d0adef43532b151a0889ee1e98a95a",
-    "sourceCommit": "adb69d997f82a62e8e22b594488c7d04a227db35"
+    "sourceHash": "v1-4bc045e1de966c1a9bd8a24cb7841ad9803cdfe842f2b6db807b64562639bc33",
+    "sourceCommit": "6fe8fb3e01138dfc4ebe7d5c246503aab9278d06"
   }
 }

package/server.json

@@ -3,7 +3,7 @@
   "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.1",
+  "version": "0.1.3",
   "websiteUrl": "https://pipeworx.io/packs/medicare-pricing",
   "repository": {
     "url": "https://github.com/pipeworx-io/mcp-medicare-pricing",

package/src/adlt.ts

@@ -0,0 +1,96 @@
+/**
+ * CMS's list of Advanced Diagnostic Laboratory Tests (ADLTs) — the one public,
+ * licence-clean list that maps a lab test's BRAND name to its billing code
+ * (fleet #2426: "Signatera" -> 0340U).
+ *
+ * Source: https://www.cms.gov/files/document/advanced-diagnostic-laboratory-tests-under-medicare-clfs.pdf
+ * (linked from cms.gov "ADLT Information"; embedded source name
+ * "2025.3.10_List of Approved ADLTs.xlsx"; HTTP Last-Modified
+ * Tue, 11 Mar 2025 15:10:55 GMT, 118,376 bytes — checked 2026-09-25).
+ *
+ * WHY IT IS BAKED, NOT FETCHED. The list is a two-page PDF that changes a few
+ * times a year and has no API; the gateway carries no PDF parser. It is a US
+ * federal work (17 USC 105), so a copy is fine (CLAUDE.md, "build the copy").
+ * The refresh path is the live Last-Modified check in the tool itself
+ * (SNAPSHOT_LAST_MODIFIED below): when CMS republishes, every response says
+ * so, and the README section "ADLT list" says how to re-extract.
+ *
+ * WHAT IS NOT HERE. The PDF's "Test Descriptor" column is the AMA's CPT PLA
+ * descriptor text ("CPT Copyright ... American Medical Association. All rights
+ * reserved") — the same text this pack already refuses to store. Only the CMS
+ * facts are kept: code, lab, proprietary test name, approval date, the new-ADLT
+ * initial period and its payment.
+ *
+ * `coverage_topic` is OURS, not CMS's: a phrase that matches the title of the
+ * MolDX LCD / billing article for the test's category (each checked against the
+ * live LCD title list on 2026-09-25). It finds the policy family; whether this
+ * specific test is listed in the article's code table is a separate question
+ * the article answers. null where no local policy title fits.
+ */
+
+export interface AdltTest {
+  code: string;
+  code_note: string | null;
+  lab: string;
+  test_name: string;
+  aliases: string[];
+  adlt_approval_date: string;
+  new_adlt_initial_period: string | null;
+  initial_period_payment_usd: number | null;
+  existing_adlt: boolean;
+  coverage_topic: string | null;
+}
+
+export const ADLT_SOURCE_URL = 'https://www.cms.gov/files/document/advanced-diagnostic-laboratory-tests-under-medicare-clfs.pdf';
+export const ADLT_DATA_AS_OF = '2025-03-10';
+export const SNAPSHOT_LAST_MODIFIED = 'Tue, 11 Mar 2025 15:10:55 GMT';
+
+export const ADLT_TESTS: AdltTest[] = [
+  { code: '0537U', code_note: null, lab: 'Guardant Health, Inc.', test_name: 'Shield', aliases: ['Guardant Shield'], adlt_approval_date: '2025-03-10', new_adlt_initial_period: '2025-04-01 to 2025-12-31', initial_period_payment_usd: 1495, existing_adlt: false, coverage_topic: null },
+  { code: '0473U', code_note: null, lab: 'Tempus AI, Inc.', test_name: 'xT CDx', aliases: ['Tempus xT', 'Tempus xT CDx'], adlt_approval_date: '2024-06-26', new_adlt_initial_period: '2024-07-01 to 2025-03-31', initial_period_payment_usd: 4500, existing_adlt: false, coverage_topic: 'Next-Generation Sequencing for Solid Tumors' },
+  { code: '0356U', code_note: null, lab: 'Naveris, Inc.', test_name: 'NavDx', aliases: [], adlt_approval_date: '2024-03-18', new_adlt_initial_period: '2024-04-01 to 2024-12-31', initial_period_payment_usd: 1800, existing_adlt: false, coverage_topic: 'Minimal Residual Disease' },
+  { code: '0315U', code_note: null, lab: 'Castle Biosciences, Inc.', test_name: 'DecisionDx-SCC', aliases: ['DecisionDx SCC'], adlt_approval_date: '2023-06-30', new_adlt_initial_period: '2023-07-01 to 2024-03-31', initial_period_payment_usd: 8500, existing_adlt: false, coverage_topic: 'Risk Stratification of Cutaneous Squamous Cell Carcinoma' },
+  { code: '0360U', code_note: null, lab: 'Biodesix, Inc.', test_name: 'Nodify CDT', aliases: [], adlt_approval_date: '2023-06-30', new_adlt_initial_period: null, initial_period_payment_usd: null, existing_adlt: true, coverage_topic: null },
+  { code: '0295U', code_note: null, lab: 'Prelude Corporation', test_name: 'DCISionRT', aliases: [], adlt_approval_date: '2023-03-23', new_adlt_initial_period: '2023-04-01 to 2023-12-31', initial_period_payment_usd: 5435, existing_adlt: false, coverage_topic: null },
+  { code: '0108U', code_note: null, lab: 'Castle Biosciences, Inc. / Cernostics, Inc.', test_name: "TissueCypher Barrett's Esophagus Assay", aliases: ['TissueCypher'], adlt_approval_date: '2022-03-24', new_adlt_initial_period: '2022-04-01 to 2022-12-31', initial_period_payment_usd: 2350, existing_adlt: false, coverage_topic: 'Upper Gastrointestinal Metaplasia, Dysplasia, and Neoplasia' },
+  { code: '0340U', code_note: null, lab: 'Natera, Inc.', test_name: 'Signatera', aliases: [], adlt_approval_date: '2021-06-17', new_adlt_initial_period: '2021-07-01 to 2022-03-31', initial_period_payment_usd: 3500, existing_adlt: false, coverage_topic: 'Minimal Residual Disease' },
+  { code: '0242U', code_note: null, lab: 'Guardant Health, Inc.', test_name: 'Guardant360 CDx', aliases: ['Guardant360', 'Guardant 360'], adlt_approval_date: '2021-03-18', new_adlt_initial_period: '2021-04-01 to 2021-12-31', initial_period_payment_usd: 5000, existing_adlt: false, coverage_topic: 'Plasma-Based Genomic Profiling in Solid Tumors' },
+  { code: '0239U', code_note: null, lab: 'Foundation Medicine, Inc.', test_name: 'FoundationOne Liquid CDx', aliases: ['F1 Liquid CDx', 'FoundationOne Liquid'], adlt_approval_date: '2021-01-25', new_adlt_initial_period: '2021-04-01 to 2021-12-31', initial_period_payment_usd: 3500, existing_adlt: false, coverage_topic: 'Plasma-Based Genomic Profiling in Solid Tumors' },
+  { code: '81554', code_note: 'Effective 2021-01-01', lab: 'Veracyte', test_name: 'Envisia Genomic Classifier', aliases: ['Envisia'], adlt_approval_date: '2020-09-17', new_adlt_initial_period: '2020-10-01 to 2021-06-30', initial_period_payment_usd: 5500, existing_adlt: false, coverage_topic: 'Idiopathic Pulmonary Fibrosis' },
+  { code: '0172U', code_note: 'Effective 2020-07-01', lab: 'Myriad', test_name: 'myChoice CDx', aliases: ['Myriad myChoice'], adlt_approval_date: '2019-12-11', new_adlt_initial_period: '2020-01-01 to 2020-09-30', initial_period_payment_usd: 4040, existing_adlt: false, coverage_topic: 'Next-Generation Sequencing for Solid Tumors' },
+  { code: '0090U', code_note: null, lab: 'Myriad', test_name: 'myPath Melanoma', aliases: ['Myriad myPath'], adlt_approval_date: '2019-09-06', new_adlt_initial_period: '2019-10-01 to 2020-06-30', initial_period_payment_usd: 1950, existing_adlt: false, coverage_topic: 'Molecular Assays for the Diagnosis of Cutaneous Melanoma' },
+  { code: '0080U', code_note: null, lab: 'Biodesix, Inc.', test_name: 'BDX-XL2', aliases: ['BDX XL2'], adlt_approval_date: '2019-05-17', new_adlt_initial_period: '2019-07-01 to 2020-03-31', initial_period_payment_usd: 3520, existing_adlt: false, coverage_topic: null },
+  { code: '81529', code_note: 'Effective 2021-01-01', lab: 'Castle Biosciences, Inc.', test_name: 'DecisionDx-Melanoma', aliases: ['DecisionDx Melanoma'], adlt_approval_date: '2019-05-17', new_adlt_initial_period: '2019-07-01 to 2020-03-31', initial_period_payment_usd: 7193, existing_adlt: false, coverage_topic: 'Melanoma Risk Stratification' },
+  { code: '81552', code_note: 'Effective 2020-01-01; CMS lists an earlier code for this test ("Previously ...")', lab: 'Castle Biosciences, Inc.', test_name: 'DecisionDx-UM', aliases: ['DecisionDx UM', 'Decision Dx-UM'], adlt_approval_date: '2019-05-17', new_adlt_initial_period: null, initial_period_payment_usd: null, existing_adlt: true, coverage_topic: 'Uveal Melanoma' },
+  { code: '81538', code_note: null, lab: 'Biodesix, Inc.', test_name: 'VeriStrat', aliases: [], adlt_approval_date: '2018-12-21', new_adlt_initial_period: null, initial_period_payment_usd: null, existing_adlt: true, coverage_topic: null },
+  { code: '0037U', code_note: null, lab: 'Foundation Medicine, Inc.', test_name: 'FoundationOne CDx', aliases: ['F1CDx', 'F1 CDx'], adlt_approval_date: '2018-05-18', new_adlt_initial_period: '2018-07-01 to 2019-03-31', initial_period_payment_usd: 3500, existing_adlt: false, coverage_topic: 'Next-Generation Sequencing for Solid Tumors' },
+];
+
+const norm = (s: string) => s.toLowerCase().replace(/[^a-z0-9]/g, '');
+
+/**
+ * Match a caller's free text to ADLT rows: by code, then by test name/alias
+ * (either contains the other, so "Signatera MRD test" still resolves), then by
+ * lab. A test-name hit wins over a lab hit — "Guardant360" must not return
+ * Shield just because both are Guardant's.
+ */
+export function matchAdlt(query: string): { matched_by: 'code' | 'test_name' | 'lab' | null; tests: AdltTest[] } {
+  const q = norm(query);
+  if (q.length < 3) return { matched_by: null, tests: [] };
+  const byCode = ADLT_TESTS.filter((t) => norm(t.code) === q);
+  if (byCode.length) return { matched_by: 'code', tests: byCode };
+  const names = (t: AdltTest) => [t.test_name, ...t.aliases].map(norm);
+  const exact = ADLT_TESTS.filter((t) => names(t).includes(q));
+  if (exact.length) return { matched_by: 'test_name', tests: exact };
+  const byName = ADLT_TESTS.filter((t) => names(t).some((n) => n.length >= 4 && (n.includes(q) || q.includes(n))));
+  if (byName.length) {
+    // "Guardant360 CDx" contains "guardant360", and so does nothing else; but a
+    // query that CONTAINS two names ("FoundationOne CDx") keeps only the longest.
+    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 = ADLT_TESTS.filter((t) => q.length >= 4 && norm(t.lab).includes(q));
+  if (byLab.length) return { matched_by: 'lab', tests: byLab };
+  return { matched_by: null, tests: [] };
+}

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

@@ -452,7 +452,42 @@ async function fetchWithTimeout(
         ),
       );
     }
-    throw err;
+    // Fleet #2382. Everything that isn't a timeout/abort here is a genuine
+    // NETWORK-LEVEL failure — DNS resolution, connection refused, TLS handshake,
+    // Cloudflare's own "Network connection lost." — meaning `fetch()` itself
+    // threw and no HTTP response of any kind was ever received. Until this fix
+    // that raw exception was rethrown VERBATIM: a bare `TypeError: fetch failed`
+    // (or the Workers-runtime equivalent) names no upstream, carries no class
+    // token, and reads exactly like a defect in OUR code — because it says
+    // nothing about the call at all. It landed in `error`, the tier that means
+    // "Pipeworx has a defect", for every one of the (at the time of writing)
+    // ~470 packs that call this helper directly with no wrapper of their own.
+    //
+    // `dexscreener` hit this independently (fleet #1579) and fixed it with a
+    // bespoke per-pack try/catch around `fetchWithTimeout`. That fix is correct
+    // but only covers one pack; every other caller of this shared helper still
+    // leaked the raw exception. Moving the same fix HERE — the one place that
+    // already carries the timeout case — covers every pack that uses
+    // `fetchWithTimeout` without a wrapper, for free, and without widening
+    // `classifyToolError`'s regex list: the fix is giving the message a proper
+    // `upstream_down:` token at the point the two facts (no response was ever
+    // received, and which host we were trying to reach) are actually in hand,
+    // not teaching the classifier to guess from prose after the fact.
+    //
+    // Safe on the same grounds as the timeout branch above: no argument a
+    // caller passes can make `fetch()` itself throw a connection-level error,
+    // so this is always an availability failure, never a caller mistake. Same
+    // `markInternalOrigin` treatment — an origin we run that never answered is
+    // still ours, not a third party's outage.
+    const raw = err instanceof Error ? err.message : String(err);
+    throw new Error(
+      markInternalOrigin(
+        `upstream_down: could not reach ${name} at all (${raw.slice(0, 160)}). ` +
+          `No request reached ${name}, so this says NOTHING about whether the arguments you passed ` +
+          'are valid — do not re-check them on the strength of this error. Retry shortly.',
+        url,
+      ),
+    );
   }
 }
 
@@ -704,6 +739,8 @@ function collapse(s: string): string {
  * returns year_not_loaded rather than silently substituting another vintage.
  */
 
+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()`
@@ -857,6 +894,19 @@ const tools: McpToolExport['tools'] = [
       required: ['code'],
     },
   },
+  {
+    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. 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: {
+        test: { type: 'string', description: 'The test\'s brand or commercial name ("Signatera", "Guardant360 CDx"), the lab ("Natera"), or its code ("0340U").' },
+        include_retired: { type: 'boolean', description: 'Also list retired LCDs/articles for the test category (default false). Contractors re-issue MolDX policies under new numbers, so an older citation may be a retired document.' },
+      },
+      required: ['test'],
+    },
+  },
   {
     name: 'medicare_dmepos_rate',
     description:
@@ -925,6 +975,57 @@ const tools: McpToolExport['tools'] = [
   },
 ];
 
+/**
+ * The ADLT table is a baked copy of a CMS PDF, so every answer re-checks the
+ * PDF's Last-Modified against the snapshot. A changed date means CMS has
+ * republished the list and the copy may be missing a test — said, not hidden.
+ */
+async function adltSnapshotCheck(): Promise<{ snapshot_current: boolean | null; snapshot_note?: string }> {
+  try {
+    const res = await pwFetch(ADLT_SOURCE_URL, { method: 'HEAD', headers: { 'User-Agent': 'Mozilla/5.0 (compatible; Pipeworx/1.0; +https://pipeworx.io)' } });
+    const lm = res.ok ? res.headers.get('last-modified') : null;
+    if (!lm) return { snapshot_current: null, snapshot_note: `Could not re-check the CMS ADLT list (HTTP ${res.status}); results reflect the list as of ${ADLT_DATA_AS_OF}.` };
+    if (lm === SNAPSHOT_LAST_MODIFIED) return { snapshot_current: true };
+    return { snapshot_current: false, snapshot_note: `CMS republished the ADLT list (Last-Modified ${lm}) after the version these results reflect (${SNAPSHOT_LAST_MODIFIED}); a newly approved ADLT may be missing from these results.` };
+  } catch {
+    return { snapshot_current: null, snapshot_note: `Could not re-check the CMS ADLT list; results reflect the list as of ${ADLT_DATA_AS_OF}.` };
+  }
+}
+
+interface CoverageDoc {
+  document_display_id: string; document_type: string; title: string; contractor: string;
+  effective_date: string; retired: boolean; url: string;
+}
+
+/** CMS writes retirement_date as MM/DD/YYYY or "N/A"; a future date is still in effect. */
+function retiredBy(d: string): boolean {
+  const m = /^(\d{2})\/(\d{2})\/(\d{4})$/.exec(d);
+  return !!m && Date.UTC(+m[3], +m[1] - 1, +m[2]) <= Date.now();
+}
+
+/** Every final LCD and local article, keyless from the CMS Coverage API reports. null if CMS did not answer. */
+async function coverageIndex(): Promise<CoverageDoc[] | null> {
+  try {
+    const get = async (path: string) => {
+      const res = await pwFetch(`https://api.coverage.cms.gov/v1/reports/${path}/?page_size=5000`, { headers: { Accept: 'application/json' } });
+      if (!res.ok) throw new Error(String(res.status));
+      return ((await res.json()) as { data?: Record<string, unknown>[] }).data ?? [];
+    };
+    const [lcds, articles] = await Promise.all([get('local-coverage-final-lcds'), get('local-coverage-articles')]);
+    return [...lcds, ...articles].map((r) => ({
+      document_display_id: String(r.document_display_id ?? ''),
+      document_type: String(r.document_type ?? ''),
+      title: String(r.title ?? ''),
+      contractor: String(r.contractor_name_type ?? '').split(/\r?\n/)[0],
+      effective_date: String(r.effective_date ?? ''),
+      retired: /retired/i.test(String(r.note ?? '')) || retiredBy(String(r.retirement_date ?? '')),
+      url: String(r.url ?? ''),
+    }));
+  } catch {
+    return null;
+  }
+}
+
 async function resolveLocality(cfg: Cfg, q: unknown, year: number): Promise<{ chosen: Gpci | null; alternatives: Gpci[]; note: string }> {
   if (typeof q !== 'string' || !q.trim()) {
     return { chosen: null, alternatives: [], note: 'No locality given, so no geographic adjustment was applied — the RVUs below are national and the payment figures are omitted. Pass locality for an actual dollar amount.' };
@@ -1032,6 +1133,111 @@ async function callTool(name: string, args: Record<string, unknown>): Promise<un
       };
     }
 
+    case 'medicare_lab_test_lookup': {
+      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;
+      // 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: `${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 (!rows.length) {
+        return {
+          found: false,
+          reason: 'brand_not_found',
+          test,
+          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(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 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,
+          ...(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: 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 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 matched to this test; it may be covered nationally (NCD) or case by case — medicare_lcd_search can look.' },
+        };
+      }));
+      return {
+        found: true,
+        query: test,
+        matched_by,
+        tests: results,
+        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,
+      };
+    }
+
     case 'medicare_dmepos_rate': {
       const hcpcs = code(args.code);
       if (!hcpcs) return { found: false, reason: 'no_code', hint: 'Pass code, e.g. "E0601".' };

package/src/server.ts

@@ -9,7 +9,7 @@ import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprot
 import pack from './index.js';
 
 const server = new Server(
-  { name: '@pipeworx/mcp-medicare-pricing', version: '0.1.1' },
+  { name: '@pipeworx/mcp-medicare-pricing', version: '0.1.3' },
   { capabilities: { tools: {} } },
 );