@cliwant/mcp-sam-gov 1.4.0 → 1.6.0

package/dist/server.js

@@ -58,28 +58,34 @@ import * as lda from "./lda.js";
 import * as courtlistener from "./courtlistener.js";
 import * as nonprofit from "./nonprofit.js";
 import * as fema from "./fema.js";
+import * as nws from "./nws-weather.js";
+import * as govDomains from "./gov-domains.js";
 import * as fdic from "./fdic.js";
 import * as bls from "./bls.js";
 import * as ofac from "./ofac.js";
 import * as nvd from "./nvd.js";
+import * as nistControls from "./nist-controls.js";
 import * as nppes from "./nppes.js";
 import * as cms from "./cms.js";
 import * as fac from "./fac.js";
 import * as usitc from "./usitc.js";
 import * as openfda from "./openfda.js";
 import * as openfdaDevice from "./openfda-device.js";
+import * as openfdaDrugsfda from "./openfda-drugsfda.js";
 import * as nhtsa from "./nhtsa.js";
 import * as cpsc from "./cpsc.js";
+import * as cbpBorder from "./cbp-border.js";
 import { fetchAttachmentText } from "./attachments.js";
 import * as keys from "./keys.js";
 import { toToolError, ToolErrorCarrier, errorFromResponse } from "./errors.js";
+import * as feedback from "./feedback.js";
 import { buildMeta, isMetaBundle, withMeta, } from "./meta.js";
 import { pathToFileURL, fileURLToPath } from "node:url";
 import { realpathSync } from "node:fs";
 const SERVER_NAME = "mcp-sam-gov";
 // Kept in lockstep with package.json / manifest.json / server.json.
 // Keep in sync with package.json "version" (asserted at release; see CHANGELOG).
-const SERVER_VERSION = "1.4.0";
+const SERVER_VERSION = "1.6.0";
 // ─── Tool input schemas (Zod) ────────────────────────────────────
 const SamSearchInput = z.object({
     query: z.string().optional().describe("Free-text title query"),
@@ -94,6 +100,7 @@ const SamSearchInput = z.object({
         .describe("Place-of-performance state, 2-letter, e.g. 'MD'"),
     setAside: z.array(z.string()).optional().describe("Set-aside codes: SBA, 8A, HZS, SDVOSBC, WOSB, EDWOSB, VSA, VSS"),
     limit: z.number().min(1).max(50).optional(),
+    offset: z.number().min(0).optional().describe("Page offset into the result set (default 0)."),
 });
 // Pre-solicitation shaping radar (doc 06 §3.1). Surfaces Sources Sought /
 // Presolicitation / Special Notices BEFORE the RFP exists — the free, real-time
@@ -178,7 +185,9 @@ const UsasIndividualAwardsInput = UsasFiltersBase.extend({
     limit: z.number().min(1).max(50).optional(),
 });
 const UsasSubAgencyInput = z.object({
-    agency: z.string(),
+    agency: z
+        .string()
+        .describe("Canonical agency NAME (e.g. 'Department of Veterans Affairs'), NOT a toptier code — this filter matches by name; a numeric code silently matches nothing. Resolve via usas_lookup_agency / usas_list_toptier_agencies."),
     fiscalYear: z.number().int().min(2007).optional(),
 });
 const UsasLookupAgencyInput = z.object({
@@ -192,7 +201,14 @@ const UsasRecipientAwardsInput = z.object({
     limit: z.number().min(1).max(50).optional(),
 });
 const UsasSubawardsInput = z.object({
-    primeRecipientName: z.string().optional(),
+    // DRIFT/SEMANTICS FIX (dogfooding 2026-07-16): this filters the SUBAWARDEE name,
+    // NOT the prime. On spending_by_award{subawards:true} the only keyless recipient
+    // filter is `recipient_search_text`, which USAspending matches against the
+    // SUB-recipient (live-verified: recipient_search_text:["Leidos"] returns rows
+    // whose Sub-Awardee Name IS Leidos, under OTHER primes). The old name
+    // `primeRecipientName` promised the opposite. Renamed to `subRecipientName`; the
+    // #182 unknown-key guard makes the old name fail loud with the valid-key list.
+    subRecipientName: z.string().optional(),
     agency: z.string().optional(),
     naics: z.string().optional(),
     fiscalYear: z.number().int().min(2007).optional(),
@@ -297,13 +313,19 @@ const UsasSpendingOverTimeInput = z.object({
         .optional(),
 });
 const UsasCategorySpendingInput = z.object({
-    agency: z.string().optional(),
+    agency: z
+        .string()
+        .optional()
+        .describe("Canonical agency NAME (e.g. 'Department of Veterans Affairs'), NOT a toptier code — this filter matches by name; a numeric code silently matches nothing. Resolve via usas_lookup_agency."),
     naics: z.string().optional(),
     fiscalYear: z.number().int().min(2007).optional(),
     limit: z.number().min(1).max(50).optional(),
 });
 const UsasCfdaInput = z.object({
-    agency: z.string().optional(),
+    agency: z
+        .string()
+        .optional()
+        .describe("Canonical agency NAME (e.g. 'Department of Veterans Affairs'), NOT a toptier code — this filter matches by name; a numeric code silently matches nothing. Resolve via usas_lookup_agency."),
     fiscalYear: z.number().int().min(2007).optional(),
     limit: z.number().min(1).max(50).optional(),
 });
@@ -355,6 +377,21 @@ const UsasGlossaryInput = z.object({
 const UsasListAgenciesInput = z.object({
     limit: z.number().min(1).max(150).optional(),
 });
+const UsasListDisasterCodesInput = z.object({});
+const UsasDisasterSpendingInput = z.object({
+    defCodes: z
+        .array(z.string().min(1))
+        .min(1)
+        .describe("Disaster Emergency Fund Codes (DEFC) to include — REQUIRED. e.g. ['L','M'] (COVID-19 relief) or ['1'] (IIJA / infrastructure). Discover the full code set via usas_list_disaster_codes."),
+    spendingType: z
+        .enum(["obligation", "outlay"])
+        .optional()
+        .describe("obligation (default) or outlay. Some DEFCs report $0 obligations but real outlays — try both."),
+    geoLayer: z
+        .enum(["state", "county", "district"])
+        .optional()
+        .describe("Geographic breakout: state (default), county, or congressional district."),
+});
 // Federal Register
 const FedRegSearchInput = z.object({
     query: z.string().optional(),
@@ -797,6 +834,39 @@ const CisaKevLookupInput = z.object({
         .describe("Max matches returned (default 100, max 1000)."),
     offset: z.number().min(0).optional().describe("Zero-based page offset (default 0)."),
 });
+const NistControlsInput = z.object({
+    controlId: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Exact control identifier, e.g. 'AC-2', 'SC-7', 'AC-2(1)' (case-insensitive; zero-padding is normalized)."),
+    family: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Control family — the 2-letter code ('AC', 'SC', 'IA') OR a substring of the family name ('Access Control', 'Audit'). Case-insensitive."),
+    keyword: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Case-insensitive substring searched over the control title + requirement statement."),
+    limit: z.number().int().min(1).max(200).optional().describe("Max controls returned (default 25, max 200)."),
+    offset: z.number().int().min(0).optional().describe("Zero-based page offset (default 0)."),
+});
+const CbpBorderWaitInput = z.object({
+    border: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Filter by border — case-insensitive substring, e.g. 'Canadian' or 'Mexican' (the feed labels ports 'Canadian Border' / 'Mexican Border')."),
+    portName: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Filter by port name — case-insensitive substring, e.g. 'Laredo', 'Detroit'."),
+    limit: z.number().int().min(1).max(200).optional().describe("Max ports returned (default 100, max 200)."),
+    offset: z.number().int().min(0).optional().describe("Zero-based page offset (default 0)."),
+});
 // ━━━ NPPES NPI Registry — the healthcare-provider identity/credentialing lane (1) ━━━ ADR-0036
 // nppes_lookup_provider: exact NPI detail OR search over CMS/HHS's keyless public
 // registry of every US healthcare provider (npiregistry.cms.hhs.gov/api, version=2.1
@@ -1094,8 +1164,10 @@ const TreasuryDatasetEnum = z
     "mts_table_1",
     "rates_of_exchange",
     "debt_outstanding",
+    "interest_expense",
+    "tror",
 ])
-    .describe("Which confirmed Treasury Fiscal Data dataset to query: debt_to_penny (daily total public debt), avg_interest_rates (avg rate by security type), mts_table_1 (Monthly Treasury Statement receipts/outlays/deficit), rates_of_exchange (quarterly FX by currency), debt_outstanding (historical fiscal-year-end debt).");
+    .describe("Which confirmed Treasury Fiscal Data dataset to query: debt_to_penny (daily total public debt), avg_interest_rates (avg rate by security type), mts_table_1 (Monthly Treasury Statement receipts/outlays/deficit), rates_of_exchange (quarterly FX by currency), debt_outstanding (historical fiscal-year-end debt), interest_expense (ACTUAL interest PAID / debt-service cost by security type — distinct from the rate), tror (Treasury Report on Receivables: federal receivables + delinquent-debt collections BY AGENCY).");
 const TreasuryQueryDatasetInput = z.object({
     dataset: TreasuryDatasetEnum,
     fields: z
@@ -2037,6 +2109,124 @@ const FemaDisasterDeclarationsInput = z.object({
         .default(0)
         .describe("0-based row offset ($skip) for pagination, default 0."),
 });
+const FemaSearchHazardMitigationInput = z.object({
+    state: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Filter by state (→ state eq '...'). Accepts EITHER a 2-letter code ('AL', like the other FEMA tools) OR the full name ('Alabama'); the module maps a 2-letter code to the full name this dataset requires."),
+    programArea: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Filter by mitigation program (→ programArea eq '...'): HMGP (Hazard Mitigation Grant Program), FMA (Flood Mitigation Assistance), PDM (Pre-Disaster Mitigation), BRIC (Building Resilient Infrastructure and Communities), LPDM, FMA-SL."),
+    disasterNumber: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe("Filter by FEMA disaster number (→ disasterNumber eq N)."),
+    status: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Filter by project status (→ status eq '...'). e.g. 'Closed', 'Open'."),
+    programFy: z
+        .number()
+        .int()
+        .optional()
+        .describe("Filter by program fiscal year (→ programFy eq N). e.g. 2005."),
+    region: z
+        .number()
+        .int()
+        .min(1)
+        .max(10)
+        .optional()
+        .describe("Filter by FEMA region number 1–10 (→ region eq N)."),
+    minProjectAmount: z
+        .number()
+        .optional()
+        .describe("Minimum project amount (→ projectAmount ge N)."),
+    maxProjectAmount: z
+        .number()
+        .optional()
+        .describe("Maximum project amount (→ projectAmount le N)."),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(1000)
+        .default(100)
+        .describe("Rows per page ($top), 1..1000, default 100."),
+    offset: z
+        .number()
+        .int()
+        .min(0)
+        .default(0)
+        .describe("0-based row offset ($skip) for pagination, default 0."),
+});
+const NwsActiveAlertsInput = z.object({
+    state: z
+        .string()
+        .regex(/^[A-Za-z]{2}$/)
+        .optional()
+        .describe("2-letter US state/territory code to scope alerts (→ NWS ?area=), e.g. 'CA'. Omit for all active US alerts."),
+    event: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Filter by event type — case-insensitive substring, e.g. 'Flood', 'Wind', 'Winter Storm'."),
+    severity: z
+        .enum(["Extreme", "Severe", "Moderate", "Minor", "Unknown"])
+        .optional()
+        .describe("Filter by severity (exact): Extreme | Severe | Moderate | Minor | Unknown."),
+    limit: z.number().int().min(1).max(500).optional().describe("Max alerts returned (default 50, max 500)."),
+    offset: z.number().int().min(0).optional().describe("Zero-based page offset (default 0)."),
+});
+const SearchGovDomainsInput = z.object({
+    scope: z
+        .enum(["all", "federal"])
+        .optional()
+        .describe("'all' (federal + SLED: state/county/city/school-district/special-district/tribal, ~16k rows, DEFAULT) or 'federal' (federal-only, ~1.3k rows)."),
+    organization: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Organization name — case-insensitive SUBSTRING match (e.g. 'veterans', 'cybersecurity')."),
+    domain: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Domain name — case-insensitive SUBSTRING match (e.g. 'cdc.gov', 'irs')."),
+    domainType: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Domain type — case-insensitive match (e.g. 'Federal - Executive', 'County', 'Tribal', 'State or territory', 'School district')."),
+    state: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("2-letter state/territory code — case-insensitive exact match (e.g. 'CA')."),
+    city: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("City — case-insensitive SUBSTRING match."),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(500)
+        .optional()
+        .describe("Rows per page, 1..500, default 50."),
+    offset: z
+        .number()
+        .int()
+        .min(0)
+        .optional()
+        .describe("0-based row offset for pagination, default 0."),
+});
 // ─── EPA ECHO REST (keyless facility compliance/enforcement) — input schemas ──
 // ADR-0009. KEYLESS, single fixed host (echodata.epa.gov) + three fixed service
 // paths (the SSRF core — no free host/path). `state` is a curated US state/
@@ -2280,7 +2470,7 @@ const DatagovSearchDatasetsInput = z.object({
         .min(1)
         .max(500)
         .optional()
-        .describe("Free-text search over the dataset catalog (→ _q), e.g. 'wildfire'. LIVE-CONFIRMED to narrow."),
+        .describe("Free-text search over the dataset catalog (→ q), e.g. 'wildfire'. LIVE-CONFIRMED to narrow (2026-07-16: the v4 API param is `q`; the old `_q` is silently ignored)."),
     organization: z
         .string()
         .min(1)
@@ -3238,6 +3428,41 @@ const OpenfdaDeviceClearancesInput = z.object({
         .optional()
         .describe("Row offset for pagination (default 0). Page with _meta.pagination.nextOffset."),
 });
+const OpenfdaDrugApprovalsInput = z.object({
+    sponsorName: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Sponsor / applicant company name (→ sponsor_name), e.g. 'pfizer'. Matched as an escaped Lucene phrase."),
+    brandName: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Product brand name (→ products.brand_name), e.g. 'lipitor'. Matched as an escaped Lucene phrase."),
+    activeIngredient: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Active ingredient name (→ products.active_ingredients.name), e.g. 'atorvastatin calcium'. Matched as an escaped Lucene phrase."),
+    applicationNumber: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("FDA application number (→ application_number), e.g. 'NDA050347'. Matched as an escaped Lucene phrase."),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(100)
+        .optional()
+        .describe("Max application records to return (default 25, max 100). Offset-paginated via skip."),
+    skip: z
+        .number()
+        .int()
+        .min(0)
+        .optional()
+        .describe("Row offset for pagination (default 0). Page with _meta.pagination.nextOffset."),
+});
 // ─── NHTSA vehicle safety (api.nhtsa.gov) — KEYLESS vehicle/parts supplier vetting ──
 // ADR-0057. Two tools (recalls + complaints) share make/model/modelYear inputs. NO
 // API key at all. ★The complaints VIN (PII) is excluded from the output. modelYear is
@@ -3561,6 +3786,25 @@ const NonprofitFinancialsInput = z.object({
 });
 // api_key_status takes no input — it is a pure status query over process.env.
 const ApiKeyStatusInput = z.object({});
+// `feedback` builds a PREFILLED GitHub issue URL for the human to submit (PULL —
+// the server never posts). All inputs optional; `summary` is a short, NON-sensitive
+// title line (the issue is public — the description + return value say so).
+const FeedbackInput = z.object({
+    kind: z
+        .enum(["bug", "feature", "wrong_output"])
+        .optional()
+        .describe("What kind of report: bug (default), feature (a capability this server lacks), or wrong_output (a tool returned a wrong/suspicious result)."),
+    tool: z
+        .string()
+        .max(80)
+        .optional()
+        .describe("The tool name this is about, if any (e.g. 'sam_search_opportunities')."),
+    summary: z
+        .string()
+        .max(500)
+        .optional()
+        .describe("A short one-line summary for the issue title/body. PUBLIC — never include API keys, personal data, or sensitive query values."),
+});
 // Build a ToolDef whose `handler` is type-checked against the schema's inferred
 // input `I` at the call site (e.g. `input.searchText` is known-present). The
 // `I` binding is erased to `any` in the ToolDef[] array, so entries without a
@@ -4097,7 +4341,7 @@ export const TOOLS = [
     }),
     defineTool({
         name: "usas_search_subawards",
-        description: "Enumerate subcontracts on prime awards. Use for 'who teams with Leidos at DISA' or 'show small-business subs on Accenture's DHS contracts' — surfaces the prime/sub network for teaming-map artifacts.",
+        description: "Enumerate federal subawards (subcontracts), optionally filtered by SUBAWARDEE name. Use for 'where does Leidos appear as a SUBcontractor, and under which primes' — surfaces the prime/sub network for teaming-map artifacts. NOTE: subRecipientName matches the SUB-recipient, NOT the prime (the keyless spending_by_award subaward view has no prime-name filter); to see the subs UNDER a specific prime, resolve that prime's awards first (usas_search_awards → usas_get_award_detail) and read their sub network. Each row carries subRecipient (the subawardee), amount, actionDate, the prime award id, and the prime award's NAICS.",
         inputSchema: UsasSubawardsInput,
         handler: (input) => usas.searchSubawards(input),
     }),
@@ -4225,6 +4469,18 @@ export const TOOLS = [
         inputSchema: UsasListAgenciesInput,
         handler: (input) => usas.listToptierAgencies(input),
     }),
+    defineTool({
+        name: "usas_list_disaster_codes",
+        description: "List the Disaster Emergency Fund Codes (DEFC) — the supplemental-appropriation tags (COVID-19 relief, IIJA/infrastructure, and other emergency laws) that usas_disaster_spending filters on. Keyless USAspending references/def_codes. Returns the COMPLETE code set (no pagination): each `code` with its `group` ('covid_19' | 'infrastructure' | null), `title`, and `publicLaw`. Use this to discover the codes to pass to usas_disaster_spending. HONESTY: group is null (never fabricated) when a code belongs to no named group; totalAvailable is the exact complete count.",
+        inputSchema: UsasListDisasterCodesInput,
+        handler: () => usas.listDisasterCodes(),
+    }),
+    defineTool({
+        name: "usas_disaster_spending",
+        description: "Disaster / emergency-fund spending BY GEOGRAPHY — obligations or outlays tagged to one or more Disaster Emergency Fund Codes (DEFC: COVID-19, IIJA, etc.), broken out per state / county / congressional district (keyless USAspending disaster/spending_by_geography). Answers 'which geographies captured COVID/IIJA relief money' — a distinct axis the standard award search does not expose. `defCodes` REQUIRED (discover via usas_list_disaster_codes); `spendingType` obligation (default) | outlay; `geoLayer` state (default) | county | district. Each row: name, code, amount, awardCount, population, perCapita. HONESTY: amount/perCapita are number|null (a real 0 stays 0 — some DEFCs like IIJA report $0 OBLIGATIONS with a nonzero awardCount, disclosed in a note; absent → null, never a fabricated 0); the endpoint returns the COMPLETE set of geo units (no pagination) so totalAvailable = returned; an outage/4xx THROWS (never a fake empty).",
+        inputSchema: UsasDisasterSpendingInput,
+        handler: (input) => usas.disasterSpending(input),
+    }),
     // ━━━ Federal Register (4) ━━━
     defineTool({
         name: "fed_register_search_documents",
@@ -4365,6 +4621,12 @@ export const TOOLS = [
         inputSchema: CisaKevLookupInput,
         handler: (input) => nvd.cisaKevLookup(input),
     }),
+    defineTool({
+        name: "nist_800_53_controls",
+        description: "Look up NIST SP 800-53 Rev 5 security & privacy CONTROLS (keyless) — the requirement backbone for FedRAMP / CMMC / RMF compliance work. Retrieve a control by `controlId` (exact, e.g. 'AC-2', 'SC-7', 'AC-2(1)'), a `family` (2-letter code 'AC'/'SC'/'IA' or a name substring 'Access Control'), and/or a `keyword` (case-insensitive substring over title + statement); `limit`/`offset` pagination. Each row: { id (e.g. 'AC-2'), family (e.g. 'AC — Access Control'), title, statement (the labelled requirement prose), guidance (discussion), enhancements:[{id,title}] (e.g. AC-2(1)) }. Complements cve_lookup + cisa_kev_lookup (the vulnerability side) with the CONTROL/requirement side. HONESTY: source is NIST's OFFICIAL OSCAL catalog published at github.com/usnistgov/oscal-content (authoritative first-party data served from GitHub, not a .gov API host — provenance disclosed in _meta); the catalog has no query API so filtering is CLIENT-SIDE and totalAvailable is the EXACT match count; this is the REQUIREMENT text only — applicability depends on the system's FIPS-199 impact baseline (Low/Moderate/High), which the catalog does not encode (disclosed); a download failure or an implausibly-truncated catalog (< 15 families) THROWS (never a fake-empty 'control not found').",
+        inputSchema: NistControlsInput,
+        handler: (input) => nistControls.searchControls(input),
+    }),
     // ━━━ NPPES NPI Registry — Healthcare-Provider Vetting (1) ━━━ ADR-0036
     defineTool({
         name: "nppes_lookup_provider",
@@ -4408,7 +4670,7 @@ export const TOOLS = [
     // ━━━ US Treasury — Fiscal Data (keyless) (4) ━━━ ADR-0002
     defineTool({
         name: "treasury_query_dataset",
-        description: "Escape-hatch query over 5 confirmed US Treasury Fiscal Data datasets (keyless): debt_to_penny, avg_interest_rates, mts_table_1 (Monthly Treasury Statement), rates_of_exchange, debt_outstanding. Choose `dataset` (enum — no free path), and optionally project `fields` (CSV), `filter` (CSV 'col:op:val', ops lt|lte|gt|gte|eq|in, AND-combined), and `sort` (CSV, '-' = desc), with page[size]/page[number] pagination. Returns raw rows plus a truthful `_meta` (totalAvailable = upstream total-count, offset pagination). Value/amount fields are raw upstream strings — the string \"null\"/empty means 'no value', never 0. Covers rates_of_exchange + debt_outstanding without a dedicated tool.",
+        description: "Escape-hatch query over 7 confirmed US Treasury Fiscal Data datasets (keyless): debt_to_penny, avg_interest_rates, mts_table_1 (Monthly Treasury Statement), rates_of_exchange, debt_outstanding, interest_expense (actual interest PAID / debt-service cost), tror (Treasury Report on Receivables — federal receivables + delinquent-debt collections by agency). Choose `dataset` (enum — no free path), and optionally project `fields` (CSV), `filter` (CSV 'col:op:val', ops lt|lte|gt|gte|eq|in, AND-combined), and `sort` (CSV, '-' = desc), with page[size]/page[number] pagination. Returns raw rows plus a truthful `_meta` (totalAvailable = upstream total-count, offset pagination). Value/amount fields are raw upstream strings — the string \"null\"/empty means 'no value', never 0. Covers rates_of_exchange + debt_outstanding without a dedicated tool.",
         inputSchema: TreasuryQueryDatasetInput,
         handler: (input) => treasury.queryDataset(input),
     }),
@@ -4601,7 +4863,7 @@ export const TOOLS = [
         inputSchema: BlsQcewInput,
         handler: (input) => bls.qcew(input),
     }),
-    // ━━━ OpenFEMA — keyless disaster declarations + emergency-assistance spend (2) ━━━ ADR-0016
+    // ━━━ OpenFEMA — keyless disaster declarations + emergency-assistance spend (3) ━━━ ADR-0016
     defineTool({
         name: "fema_search_public_assistance",
         description: "Search FEMA Public Assistance funded projects — federal emergency-assistance spend to state/local/tribal applicants (keyless OpenFEMA, dataset PublicAssistanceFundedProjectsDetails v2, ~800k rows). Structured filters (module-built into an OData $filter; each LIVE-VERIFIED to narrow): `state` (→ stateAbbreviation), `disasterNumber`, `applicantId`, `damageCategoryCode` (e.g. 'B' = Emergency Protective Measures), `incidentType`, `minProjectAmount`/`maxProjectAmount` (projectAmount ge/le), `declaredDateFrom`/`declaredDateTo` (declarationDate ge/le). `limit` (≤1000, def 100 → $top), `offset` (→ $skip). HONESTY: the module ALWAYS sends $inlinecount=allpages so totalAvailable is the EXACT filtered total (metadata.count), never the page length; amount fields are number|null (a real 0 stays 0, absent → null); genuine-empty ⇒ complete:true/total:0; an outage/400/404 THROWS (never a fake empty).",
@@ -4614,6 +4876,26 @@ export const TOOLS = [
         inputSchema: FemaDisasterDeclarationsInput,
         handler: (input) => fema.disasterDeclarations(input),
     }),
+    defineTool({
+        name: "fema_search_hazard_mitigation",
+        description: "Search FEMA Hazard Mitigation Assistance projects — the disaster-RESILIENCE grant axis (HMGP/FMA/PDM/BRIC mitigation grants to state/local/tribal subrecipients, distinct from the disaster-RECOVERY spend in fema_search_public_assistance). Keyless OpenFEMA, dataset HazardMitigationAssistanceProjects v4, ~56k rows. Structured filters (module-built into an OData $filter; each LIVE-VERIFIED to narrow): `state` (→ state — the FULL state NAME, e.g. 'Alabama', NOT the 2-letter code), `programArea` (HMGP/FMA/PDM/BRIC/LPDM/FMA-SL), `disasterNumber`, `status` (e.g. 'Closed'), `programFy`, `region` (FEMA region 1–10), `minProjectAmount`/`maxProjectAmount` (projectAmount ge/le). `limit` (≤1000, def 100 → $top), `offset` (→ $skip). HONESTY: the module ALWAYS sends $inlinecount=allpages so totalAvailable is the EXACT filtered total (metadata.count), never the page length; amount fields (projectAmount/federalShareObligated/initialObligationAmount/netValueBenefits) are number|null (a real 0 stays 0, absent → null); genuine-empty ⇒ complete:true/total:0; an outage/400/404 THROWS (never a fake empty). NOTE: 'state' here is the full name (this dataset 400s on a 2-letter code), whereas fema_search_public_assistance maps 'state' to the 2-letter 'stateAbbreviation'.",
+        inputSchema: FemaSearchHazardMitigationInput,
+        handler: (input) => fema.searchHazardMitigation(input),
+    }),
+    // ━━━ NWS — National Weather Service active alerts (keyless) (1) ━━━
+    defineTool({
+        name: "nws_active_alerts",
+        description: "List CURRENTLY-ACTIVE National Weather Service alerts — watches, warnings, and advisories (keyless; api.weather.gov). The disaster/climate-readiness lane that pairs with the FEMA tools (declarations → public assistance → hazard mitigation → LIVE active weather): where severe-weather events are active NOW, ahead of the declarations/contracts that follow. Filters: `state` (2-letter code → server-side ?area=, e.g. 'CA'; omit for all US), `event` (case-insensitive substring, e.g. 'Flood', 'Wind'), `severity` (Extreme/Severe/Moderate/Minor/Unknown); `limit`/`offset` pagination. Each alert: { id, event, headline, severity, urgency, certainty, category, status, messageType, areaDesc, effective, onset, expires, ends, senderName, description, instruction, response }. HONESTY: this is REAL-TIME data (alerts active at request time — a live snapshot, NOT a historical archive; read effective/expires for each window, disclosed in _meta); every scalar is null-never-empty-string and dates are ISO strings; totalAvailable is the EXACT count of matched active alerts; a NO-active-alerts result is an HONEST EMPTY (returned:0), never an error; an outage/4xx/timeout THROWS and a non-FeatureCollection body ⇒ schema_drift. A descriptive User-Agent is sent per NWS policy (no key/token).",
+        inputSchema: NwsActiveAlertsInput,
+        handler: (input) => nws.activeAlerts(input),
+    }),
+    // ━━━ get.gov — CISA authoritative .gov domain registry (keyless) (1) ━━━
+    defineTool({
+        name: "search_gov_domains",
+        description: "Search the authoritative US .gov domain registry (CISA get.gov) — resolve which ORGANIZATION owns a .gov domain, enumerate federal agencies, and MAP SLED entities (state/county/city/school-district/special-district/tribal) for market targeting. Keyless. scope 'all' (federal + SLED, ~16k rows, default) | 'federal'. Filters (client-side over the published CSV): organization/domain/city (case-insensitive SUBSTRING), domainType (e.g. 'Federal - Executive', 'County', 'Tribal'), state (2-letter). Each row: domain, domainType, organization, suborganization, city, state. HONESTY: source is CISA's OFFICIAL registry published at github.com/cisagov/dotgov-data (authoritative first-party data, not a .gov API host — provenance disclosed in _meta); the registry has no query API so filtering is CLIENT-SIDE and totalAvailable is the EXACT match count; the 'Security contact email' column is intentionally EXCLUDED (org mailbox — this tool resolves organizations, not contacts); an outage/4xx THROWS (never a fake empty); a header-column rename ⇒ schema_drift.",
+        inputSchema: SearchGovDomainsInput,
+        handler: (input) => govDomains.searchGovDomains(input),
+    }),
     // ━━━ FPDS-NG — federal contract AWARD ACTIONS (keyless ATOM) (1) ━━━ ADR-0012
     // The FIRST XML/ATOM source (bounded, ReDoS-safe hand-parser — the far.ts/gao.ts
     // lineage; NOT the getJson port). FPDS is the system-of-record USAspending
@@ -4952,6 +5234,12 @@ export const TOOLS = [
         inputSchema: OpenfdaDeviceClearancesInput,
         handler: (input) => openfdaDevice.deviceClearances(input),
     }),
+    defineTool({
+        name: "openfda_drug_approvals",
+        description: "Search openFDA Drugs@FDA DRUG APPROVALS — FDA-approved drug applications (NDA/ANDA/BLA) with the sponsor, application number, each approved product (brand + generic/active-ingredient name, dosage form, route, marketing status), and the submission/approval history (openFDA /drug/drugsfda.json; api.fda.gov). Answers 'what drugs did sponsor X get approved, and which are still marketed' — pharma vendor product/approval intelligence. KEYLESS (an OPTIONAL free OPENFDA_API_KEY only RAISES the rate limit — keyless works at ~1000 requests/day; NEVER throws for a missing key; api_key_status lists every source's key requirement). Input: STRUCTURED filters — `sponsorName` (→sponsor_name), `brandName` (→products.brand_name), `activeIngredient` (→products.active_ingredients.name), `applicationNumber` (→application_number) — safely escaped into the openFDA search= Lucene string (NO raw passthrough — injection-safe), plus `limit` (1..100, default 25) and `skip` (offset ≥0). Returns { applications:[{ applicationNumber, sponsorName, products:[{ brandName, genericIngredients:[{name,strength}], dosageForm, route, marketingStatus }], submissions:[{ submissionType, submissionNumber, submissionStatus, submissionStatusDate, submissionClass }] }] } + honest _meta. HONESTY: totalAvailable is openFDA's EXACT meta.results.total (skip/limit pagination — never results.length); every scalar is null-never-empty-string; a 'Discontinued' marketingStatus is NOT an approval revocation (disclosed in _meta). ★A no-match query returns openFDA HTTP 404 NOT_FOUND ⇒ an HONEST EMPTY (returned:0/total:0), NOT an error; a 400 ⇒ invalid_input surfacing openFDA's message; a 5xx ⇒ THROWS; a 200 non-JSON ⇒ schema_drift. The optional key rides ONLY the &api_key= query param — never logged or echoed.",
+        inputSchema: OpenfdaDrugApprovalsInput,
+        handler: (input) => openfdaDrugsfda.drugApprovals(input),
+    }),
     // ━━━ NHTSA vehicle safety (api.nhtsa.gov) — vehicle/parts supplier vetting (2) ━━━ ADR-0057
     // ★KEYLESS — no API key at all (no parameter, no header). The cross-agency
     // product-safety family alongside openFDA (medical). Both tools share
@@ -4983,6 +5271,13 @@ export const TOOLS = [
         inputSchema: CpscRecallsInput,
         handler: (input) => cpsc.recalls(input),
     }),
+    // ━━━ CBP Border Wait Times (bwt.cbp.gov) — freight/logistics (1) ━━━
+    defineTool({
+        name: "cbp_border_wait_times",
+        description: "Live CBP land-border-port wait times — current commercial-vehicle (and passenger) crossing delays at every US Canadian- and Mexican-border port (keyless; bwt.cbp.gov). The FREIGHT / LOGISTICS situational-awareness lane: per-port commercial-vehicle standard + FAST lane delay (minutes), operational status, open-lane count, and maximum lanes. Filters (optional): `border` (case-insensitive substring, 'Canadian'/'Mexican'), `portName` (substring, e.g. 'Laredo'); `limit`/`offset` pagination. Each row: { portNumber, portName, crossingName, border, portStatus (Open/Closed), asOf, commercialVehicle:{ maxLanes, standard:{operationalStatus, delayMinutes, lanesOpen, updateTime}, fast:{…} } }. HONESTY: this is REAL-TIME operational data — each lane carries its own updateTime (surfaced verbatim; freshness never implied live-to-the-second); delayMinutes/lanesOpen are number|null (a real 0 stays 0; an empty/N/A value — e.g. a closed lane — is null, NEVER a fabricated 0, because a closed lane's delay is UNKNOWN, not zero); the API returns the WHOLE port set so totalAvailable is the EXACT matched-port count; an outage/4xx/timeout THROWS and a non-array body ⇒ schema_drift (never a fake empty).",
+        inputSchema: CbpBorderWaitInput,
+        handler: (input) => cbpBorder.borderWaitTimes(input),
+    }),
     // ━━━ BEA Regional Economic Accounts (apps.bea.gov) — regional GDP/income (1) ━━━ ADR-0051
     // ★The server's THIRD KEY-REQUIRED source: the BEA Data API has NO keyless tier, so
     // WITHOUT a BEA_API_KEY this tool throws an honest invalid_input config error (the
@@ -5087,6 +5382,17 @@ export const TOOLS = [
         inputSchema: ApiKeyStatusInput,
         handler: async () => keys.apiKeyStatus(),
     }),
+    // ━━━ Meta: in-product feedback → GitHub issue (PULL-only, keyless) ━━━
+    // The server's "user" is an AI agent, so we collect real-usage friction THROUGH
+    // it: this returns a PREFILLED GitHub new-issue URL for the HUMAN to open and
+    // submit. The server NEVER posts (no token/account/auto-submit) and embeds no
+    // PII — only the caller's summary + tool name. See feedback.ts.
+    defineTool({
+        name: "feedback",
+        description: "Report a problem, request a feature, or flag a wrong-looking result for THIS server — returns a PREFILLED GitHub issue link (public repo cliwant/mcp-sam-gov) for the USER to open and submit. KEYLESS. The server does NOT post anything: it only builds the link; the human submits it (nothing is sent automatically, no network call). Use when the user reports a bug, says a tool's output looks wrong, or wants a capability this server doesn't have. Input (all optional): `kind` (bug|feature|wrong_output, default bug), `tool` (the tool it's about), `summary` (a short, NON-SENSITIVE title line). Returns { reportUrl, repo, willPost:false, instructions, privacy }. PRIVACY: never put secrets, personal data, or sensitive query values in `summary` — the issue is PUBLIC and the link prefills only your summary + tool + server version.",
+        inputSchema: FeedbackInput,
+        handler: async (input) => feedback.feedbackTool(input),
+    }),
 ];
 // ─── Server bootstrap ────────────────────────────────────────────
 async function main() {
@@ -5107,7 +5413,12 @@ async function main() {
             },
         },
     });
-    const server = new Server({ name: SERVER_NAME, version: SERVER_VERSION }, { capabilities: { tools: {} } });
+    const server = new Server({ name: SERVER_NAME, version: SERVER_VERSION }, {
+        capabilities: { tools: {} },
+        // Surfaced to the agent at initialize. Tells it how to route real-usage
+        // friction back to the project WITHOUT the server ever posting anything.
+        instructions: "This server wraps US government open data (keyless-first). If a tool result looks wrong, a tool stays broken, or the user wants a capability this server lacks, help improve it: call the `feedback` tool — or use the `report` URL present on schema_drift / upstream_unavailable errors — to get a PREFILLED GitHub issue link, and offer it to the user to open and submit. Nothing is posted automatically; the user submits. Never include secrets or personal data in a report (the repo is public).",
+    });
     server.setRequestHandler(ListToolsRequestSchema, async () => {
         return {
             tools: TOOLS.map((t) => ({
@@ -5146,6 +5457,12 @@ async function main() {
             // NON-retryable `invalid_input` with readable field-level issues — never a
             // generic `unknown` carrying Zod's raw JSON dump.
             const error = toToolError(err, name);
+            // PULL-only feedback loop (feedback.ts): attach a PREFILLED GitHub issue URL
+            // ONLY for the two "something may be broken" kinds — schema_drift (the
+            // upstream changed shape) and upstream_unavailable (a possible moved/broken
+            // endpoint). Carries only tool + kind + version (no args/PII). The 429 and
+            // invalid_input/not_found envelopes stay byte-identical (no `report`).
+            feedback.maybeAttachReport(error, name, SERVER_VERSION);
             const envelope = { ok: false, error };
             return {
                 content: [
@@ -5221,6 +5538,32 @@ function synthesizeDefaultMeta(toolName, sam) {
     }
     return buildMeta({ source, keylessMode, complete: true, truncated: false });
 }
+// Unwrap a tool's inputSchema down to its underlying ZodObject so we can read the
+// set of declared top-level keys. Tools wrap the object in .refine()/.superRefine()
+// (ZodEffects), or occasionally .optional()/.default()/.nullable(), so peel those
+// layers. Returns null if no ZodObject is reachable (then unknown-key rejection is
+// skipped for that tool — fail open, never fail closed on our own introspection).
+function objectSchemaOf(schema) {
+    let s = schema;
+    for (let i = 0; i < 20; i++) {
+        const def = s?._def;
+        if (!def)
+            break;
+        const tn = def.typeName;
+        if (tn === "ZodObject")
+            return s;
+        if (tn === "ZodEffects") {
+            s = def.schema;
+            continue;
+        }
+        if (tn === "ZodOptional" || tn === "ZodDefault" || tn === "ZodNullable") {
+            s = def.innerType;
+            continue;
+        }
+        break;
+    }
+    return null;
+}
 export async function runTool(name, args, sam) {
     // R1 (ADR-0001) — registry dispatch. Every tool's TOOLS[] entry carries a
     // co-located `handler`: route through it by parsing `args` with the entry's
@@ -5230,6 +5573,26 @@ export async function runTool(name, args, sam) {
     // gone (all 52 tools migrated) — an unknown name has no entry and throws.
     const entry = TOOLS.find((t) => t.name === name);
     if (entry?.handler) {
+        // HONESTY (dogfooding 2026-07-15): reject UNKNOWN top-level input keys LOUD
+        // instead of Zod's default silent-strip. A misspelled filter (naicsCode↔naics,
+        // keyword↔query) was otherwise dropped and the tool scanned the WHOLE corpus,
+        // returning an authoritative-looking WRONG answer with no error. We name the
+        // unknown key(s) and list the valid ones so the mistake self-corrects. Skip
+        // when the schema intentionally accepts extras (unknownKeys==="passthrough").
+        const obj = objectSchemaOf(entry.inputSchema);
+        if (obj && obj._def.unknownKeys !== "passthrough" && args && typeof args === "object") {
+            const known = new Set(Object.keys(obj.shape));
+            const unknown = Object.keys(args).filter((k) => !known.has(k));
+            if (unknown.length > 0) {
+                throw new ToolErrorCarrier({
+                    kind: "invalid_input",
+                    message: `Unknown input ${unknown.length > 1 ? "keys" : "key"} for ${name}: ` +
+                        `${unknown.map((k) => `'${k}'`).join(", ")}. ` +
+                        `Valid keys: ${[...known].sort().join(", ")}.`,
+                    retryable: false,
+                });
+            }
+        }
         const input = entry.inputSchema.parse(args);
         return await entry.handler(input, { sam });
     }