@pipeworx/mcp-medicare-pricing 0.1.0 → 0.1.2

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 1663+ 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,51 @@ 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.
+
+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`.
+
+**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 +293,7 @@ directly, instead of just this one's:
 }
 ```
 
-Both URLs reach the same gateway and the same 1663+ 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.0",
+  "version": "0.1.2",
   "description": "What does Medicare PAY — physician fee schedule, lab rates, and per-day unit",
   "type": "module",
   "main": "src/index.ts",
@@ -24,5 +24,9 @@
   "devDependencies": {
     "typescript": "^5.9.3",
     "@cloudflare/workers-types": "^4.20260405.1"
+  },
+  "pipeworx": {
+    "sourceHash": "v1-39abb67f2c97d76656d44948e3ff83744176d3ab644ad6bb0dfb4fe227df10b6",
+    "sourceCommit": "6182c4cfebddb94950e060b5d2fca18f18ad1aca"
   }
 }

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.0",
+  "version": "0.1.2",
   "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/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,7 @@ 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';
 
 // 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 +893,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. 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).',
+    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 +974,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 +1132,73 @@ 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;
+      const { matched_by, tests } = matchAdlt(test);
+      const [snapshot, coverage] = await Promise.all([adltSnapshotCheck(), tests.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,
+        ...snapshot,
+      };
+      if (!tests.length) {
+        return {
+          found: false,
+          reason: 'not_on_adlt_list',
+          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.',
+          ...provenance,
+        };
+      }
+      const results = await Promise.all(tests.map(async (t: AdltTest) => {
+        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 active = docs.filter((d) => !d.retired);
+        const retired = docs.filter((d) => d.retired);
+        return {
+          code: t.code,
+          ...(t.code_note ? { code_note: t.code_note } : {}),
+          test_name: t.test_name,
+          lab: t.lab,
+          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,
+          },
+          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.',
+                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.' },
+        };
+      }));
+      return {
+        found: true,
+        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.',
+        ...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.0' },
+  { name: '@pipeworx/mcp-medicare-pricing', version: '0.1.2' },
   { capabilities: { tools: {} } },
 );
 

package/.pipeworx-staged-ok

@@ -1,6 +0,0 @@
-{
-  "staged_at": "2026-09-23T20:33:13.962Z",
-  "publisher_blob": "da6994091dc9dcc6a7433084251ca4bbd58b4bed",
-  "publisher_commit": "1c417b2cfcdac06e2d9210e869265722ef013f20",
-  "note": "Written by scripts/publish-pack.sh as its LAST step. Its presence is the ONLY thing that lets stage-unpublished-packs.sh skip this pack. Deleting this dir is the correct way to force a rebuild."
-}