fdic-mcp-server 1.11.0 → 1.13.0

package/dist/index.js

@@ -32,7 +32,7 @@ var import_types = require("@modelcontextprotocol/sdk/types.js");
 var import_express2 = __toESM(require("express"));
 
 // src/constants.ts
-var VERSION = true ? "1.11.0" : process.env.npm_package_version ?? "0.0.0-dev";
+var VERSION = true ? "1.13.0" : process.env.npm_package_version ?? "0.0.0-dev";
 var FDIC_API_BASE_URL = "https://banks.data.fdic.gov/api";
 var CHARACTER_LIMIT = 5e4;
 var DEFAULT_FDIC_MAX_RESPONSE_BYTES = 5 * 1024 * 1024;
@@ -34351,6 +34351,3013 @@ Override precedence: cert derives defaults, then explicit params override them.`
   );
 }
 
+// src/tools/bankHealth.ts
+var import_zod9 = require("zod");
+
+// src/tools/shared/camelsScoring.ts
+var SCORING_RULES = {
+  // Capital
+  tier1_leverage: { thresholds: [8, 6, 5, 4], higher_is_better: true, weight: 0.35, label: "Tier 1 Leverage Ratio", unit: "%" },
+  tier1_rbc: { thresholds: [10, 8, 6, 4], higher_is_better: true, weight: 0.35, label: "Tier 1 Risk-Based Capital", unit: "%" },
+  equity_ratio: { thresholds: [10, 8, 7, 5], higher_is_better: true, weight: 0.3, label: "Equity / Assets", unit: "%" },
+  // Asset Quality
+  noncurrent_loans_ratio: { thresholds: [1, 2, 3, 5], higher_is_better: false, weight: 0.3, label: "Noncurrent Loans / Loans", unit: "%" },
+  net_chargeoff_ratio: { thresholds: [0.25, 0.5, 1, 2], higher_is_better: false, weight: 0.25, label: "Net Charge-Off Ratio", unit: "%" },
+  reserve_coverage: { thresholds: [150, 100, 80, 50], higher_is_better: true, weight: 0.25, label: "Reserve Coverage", unit: "%" },
+  noncurrent_assets_ratio: { thresholds: [0.5, 1, 2, 4], higher_is_better: false, weight: 0.2, label: "Noncurrent Assets / Assets", unit: "%" },
+  // Earnings
+  roa: { thresholds: [1, 0.75, 0.5, 0], higher_is_better: true, weight: 0.3, label: "Return on Assets", unit: "%" },
+  nim: { thresholds: [3.5, 3, 2.5, 2], higher_is_better: true, weight: 0.25, label: "Net Interest Margin", unit: "%" },
+  efficiency_ratio: { thresholds: [55, 60, 70, 85], higher_is_better: false, weight: 0.25, label: "Efficiency Ratio", unit: "%" },
+  roe: { thresholds: [10, 8, 5, 0], higher_is_better: true, weight: 0.2, label: "Return on Equity", unit: "%" },
+  // Liquidity
+  core_deposit_ratio: { thresholds: [80, 70, 60, 45], higher_is_better: true, weight: 0.3, label: "Core Deposits / Deposits", unit: "%" },
+  loan_to_deposit: { thresholds: [80, 85, 95, 105], higher_is_better: false, weight: 0.25, label: "Loan-to-Deposit Ratio", unit: "%" },
+  brokered_deposit_ratio: { thresholds: [5, 10, 15, 25], higher_is_better: false, weight: 0.25, label: "Brokered Deposits / Deposits", unit: "%" },
+  cash_ratio: { thresholds: [8, 5, 3, 1], higher_is_better: true, weight: 0.2, label: "Cash / Assets", unit: "%" },
+  // Sensitivity
+  nim_4q_change: { thresholds: [0.1, 0, -0.15, -0.3], higher_is_better: true, weight: 0.5, label: "NIM 4Q Change", unit: "pp" },
+  securities_to_assets: { thresholds: [25, 30, 40, 50], higher_is_better: false, weight: 0.5, label: "Securities / Assets", unit: "%" }
+};
+var COMPONENT_METRIC_MAP = {
+  C: ["tier1_leverage", "tier1_rbc", "equity_ratio"],
+  A: ["noncurrent_loans_ratio", "net_chargeoff_ratio", "reserve_coverage", "noncurrent_assets_ratio"],
+  E: ["roa", "nim", "efficiency_ratio", "roe"],
+  L: ["core_deposit_ratio", "loan_to_deposit", "brokered_deposit_ratio", "cash_ratio"],
+  S: ["nim_4q_change", "securities_to_assets"]
+};
+var RATING_LABELS = {
+  1: "Strong",
+  2: "Satisfactory",
+  3: "Fair",
+  4: "Marginal",
+  5: "Unsatisfactory"
+};
+var CAMELS_FIELDS = [
+  "CERT",
+  "REPDTE",
+  "ASSET",
+  "EQTOT",
+  "EQV",
+  "IDT1CER",
+  "IDT1RWAJR",
+  "NPERFV",
+  "NCLNLSR",
+  "NTLNLSR",
+  "LNATRESR",
+  "LNRESNCR",
+  "ELNATRY",
+  "ROA",
+  "ROAPTX",
+  "ROE",
+  "NIMY",
+  "EEFFR",
+  "NETINC",
+  "INTINC",
+  "EINTEXP",
+  "NONII",
+  "NONIX",
+  "DEP",
+  "COREDEP",
+  "BROR",
+  "LNLSDEPR",
+  "DEPDASTR",
+  "CHBALR",
+  "SC"
+].join(",");
+function safe(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : null;
+}
+function safeDivide(num, den) {
+  if (num === null || den === null || den === 0) return null;
+  return num / den;
+}
+function computeCamelsMetrics(current, prior) {
+  const dep = safe(current.DEP);
+  const asset = safe(current.ASSET);
+  const coredep = safe(current.COREDEP);
+  const sc = safe(current.SC);
+  const intinc = safe(current.INTINC);
+  const eintexp = safe(current.EINTEXP);
+  const nonii = safe(current.NONII);
+  const nii = intinc !== null && eintexp !== null ? intinc - eintexp : null;
+  const totalRevenue = nii !== null && nonii !== null ? nii + nonii : null;
+  const nimNow = safe(current.NIMY);
+  const nim4qAgo = prior && prior.length >= 4 ? safe(prior[3].NIMY) : null;
+  const nim4qChange = nimNow !== null && nim4qAgo !== null ? nimNow - nim4qAgo : null;
+  const coreDepRatio = safeDivide(coredep, dep);
+  const secToAssets = safeDivide(sc, asset);
+  const niiShare = totalRevenue !== null && totalRevenue > 0 && nonii !== null ? nonii / totalRevenue * 100 : null;
+  return {
+    equity_ratio: safe(current.EQV),
+    tier1_leverage: safe(current.IDT1CER),
+    tier1_rbc: safe(current.IDT1RWAJR),
+    noncurrent_assets_ratio: safe(current.NPERFV),
+    noncurrent_loans_ratio: safe(current.NCLNLSR),
+    net_chargeoff_ratio: safe(current.NTLNLSR),
+    reserve_to_loans: safe(current.LNATRESR),
+    reserve_coverage: safe(current.LNRESNCR),
+    provision_ratio: safe(current.ELNATRY),
+    roa: safe(current.ROA),
+    roe: safe(current.ROE),
+    nim: nimNow,
+    efficiency_ratio: safe(current.EEFFR),
+    pretax_roa: safe(current.ROAPTX),
+    noninterest_income_share: niiShare,
+    loan_to_deposit: safe(current.LNLSDEPR),
+    deposits_to_assets: safe(current.DEPDASTR),
+    core_deposit_ratio: coreDepRatio !== null ? coreDepRatio * 100 : null,
+    brokered_deposit_ratio: safe(current.BROR),
+    cash_ratio: safe(current.CHBALR),
+    securities_to_assets: secToAssets !== null ? secToAssets * 100 : null,
+    nim_4q_change: nim4qChange
+  };
+}
+function scoreMetric(value, rule) {
+  if (value === null) return 3;
+  const [t1, t2, t3, t4] = rule.thresholds;
+  if (rule.higher_is_better) {
+    if (value >= t1) return 1;
+    if (value >= t2) return 2;
+    if (value >= t3) return 3;
+    if (value >= t4) return 4;
+    return 5;
+  }
+  if (value <= t1) return 1;
+  if (value <= t2) return 2;
+  if (value <= t3) return 3;
+  if (value <= t4) return 4;
+  return 5;
+}
+function scoreComponent(component, metrics) {
+  const metricNames = COMPONENT_METRIC_MAP[component];
+  let weightedSum = 0;
+  let totalWeight = 0;
+  const scored = [];
+  const flags = [];
+  for (const metricName of metricNames) {
+    const rule = SCORING_RULES[metricName];
+    const value = metrics[metricName];
+    const rating2 = scoreMetric(value, rule);
+    scored.push({
+      name: metricName,
+      label: rule.label,
+      value,
+      rating: rating2,
+      rating_label: RATING_LABELS[rating2],
+      unit: rule.unit
+    });
+    if (value !== null) {
+      weightedSum += rating2 * rule.weight;
+      totalWeight += rule.weight;
+    }
+    if (rating2 >= 4 && value !== null) {
+      flags.push(`${rule.label} at ${value.toFixed(2)}${rule.unit} rated ${RATING_LABELS[rating2]}`);
+    }
+  }
+  const raw = totalWeight > 0 ? weightedSum / totalWeight : 3;
+  const rating = Math.round(raw);
+  return { component, rating, label: RATING_LABELS[rating], metrics: scored, flags };
+}
+var COMPONENT_WEIGHTS = {
+  C: 0.25,
+  A: 0.25,
+  E: 0.2,
+  L: 0.15,
+  S: 0.15
+};
+function compositeScore(components) {
+  let sum = 0;
+  const allFlags = [];
+  for (const c of components) {
+    sum += c.rating * (COMPONENT_WEIGHTS[c.component] ?? 0);
+    allFlags.push(...c.flags);
+  }
+  const rating = Math.round(sum);
+  return { rating, label: RATING_LABELS[rating], components, flags: allFlags };
+}
+function analyzeTrend(metricName, timeseries, higherIsBetter) {
+  const label = SCORING_RULES[metricName]?.label ?? metricName;
+  const valid = timeseries.filter(
+    (t) => t.value !== null
+  );
+  if (valid.length < 2) {
+    return {
+      metric: metricName,
+      label,
+      values: valid,
+      direction: "stable",
+      magnitude: "minimal",
+      quarters_analyzed: valid.length
+    };
+  }
+  const n = valid.length;
+  const xMean = (n - 1) / 2;
+  const yMean = valid.reduce((s, v) => s + v.value, 0) / n;
+  let num = 0;
+  let den = 0;
+  for (let i = 0; i < n; i++) {
+    num += (i - xMean) * (valid[i].value - yMean);
+    den += (i - xMean) ** 2;
+  }
+  const slope = den !== 0 ? num / den : 0;
+  const relSlope = yMean !== 0 ? slope / Math.abs(yMean) : 0;
+  const direction = higherIsBetter && relSlope > 0.02 || !higherIsBetter && relSlope < -0.02 ? "improving" : higherIsBetter && relSlope < -0.02 || !higherIsBetter && relSlope > 0.02 ? "deteriorating" : "stable";
+  const absMag = Math.abs(relSlope);
+  const magnitude = absMag > 0.1 ? "significant" : absMag > 0.03 ? "moderate" : "minimal";
+  return {
+    metric: metricName,
+    label,
+    values: valid,
+    direction,
+    magnitude,
+    quarters_analyzed: n
+  };
+}
+function isStale(repdte) {
+  const year = Number.parseInt(repdte.slice(0, 4), 10);
+  const month = Number.parseInt(repdte.slice(4, 6), 10);
+  const day = Number.parseInt(repdte.slice(6, 8), 10);
+  const reportDate = new Date(Date.UTC(year, month - 1, day));
+  if (Number.isNaN(reportDate.getTime())) return true;
+  const daysSince = (Date.now() - reportDate.getTime()) / 864e5;
+  return daysSince > 120;
+}
+function formatRating(rating) {
+  return `${rating} - ${RATING_LABELS[rating]}`;
+}
+
+// src/tools/bankHealth.ts
+var COMPONENT_NAMES = {
+  C: "Capital Adequacy",
+  A: "Asset Quality",
+  E: "Earnings",
+  L: "Liquidity",
+  S: "Sensitivity to Market Risk"
+};
+var TREND_METRICS = [
+  { key: "tier1_leverage", fdic_field: "IDT1CER", higher_is_better: true },
+  { key: "noncurrent_loans_ratio", fdic_field: "NCLNLSR", higher_is_better: false },
+  { key: "roa", fdic_field: "ROA", higher_is_better: true },
+  { key: "nim", fdic_field: "NIMY", higher_is_better: true },
+  { key: "efficiency_ratio", fdic_field: "EEFFR", higher_is_better: false },
+  { key: "loan_to_deposit", fdic_field: "LNLSDEPR", higher_is_better: false }
+];
+function formatHealthSummaryText(summary) {
+  const parts = [];
+  const { institution: inst, composite } = summary;
+  parts.push(`CAMELS-Style Health Assessment: ${inst.name} (CERT ${inst.cert})`);
+  parts.push(`${inst.city}, ${inst.state} | Charter: ${inst.charter_class} | Assets: $${Math.round(inst.total_assets).toLocaleString()}k`);
+  parts.push(`Report Date: ${inst.report_date} | Data: ${inst.data_staleness}`);
+  parts.push("");
+  parts.push("NOTE: This is an analytical assessment based on public financial data, not an official regulatory CAMELS rating.");
+  parts.push("");
+  parts.push(`Composite Rating: ${formatRating(composite.rating)}`);
+  parts.push("");
+  for (const comp of summary.components) {
+    const name = COMPONENT_NAMES[comp.component] ?? comp.component;
+    parts.push(`${name} (${comp.component}): ${formatRating(comp.rating)}`);
+    for (const m of comp.metrics) {
+      const val = m.value !== null ? `${m.value.toFixed(2)}${m.unit}` : "n/a";
+      parts.push(`  ${m.label.padEnd(30)} ${val.padStart(10)}  ${m.rating_label}`);
+    }
+    if (comp.flags.length > 0) {
+      for (const flag of comp.flags) {
+        parts.push(`  \u26A0 ${flag}`);
+      }
+    }
+    parts.push("");
+  }
+  if (summary.trends.length > 0) {
+    parts.push("Trend Analysis:");
+    for (const t of summary.trends) {
+      if (t.direction !== "stable") {
+        parts.push(`  ${t.label}: ${t.direction} (${t.magnitude}, ${t.quarters_analyzed}Q analyzed)`);
+      }
+    }
+    parts.push("");
+  }
+  if (summary.risk_signals.length > 0) {
+    parts.push("Risk Signals:");
+    for (const signal of summary.risk_signals) {
+      parts.push(`  \u2022 ${signal}`);
+    }
+    parts.push("");
+  }
+  return parts.join("\n");
+}
+function getPriorQuarterDates(repdte, count) {
+  const dates = [];
+  const suffixes = ["0331", "0630", "0930", "1231"];
+  let year = Number.parseInt(repdte.slice(0, 4), 10);
+  let qIdx = suffixes.indexOf(repdte.slice(4));
+  if (qIdx === -1) return dates;
+  for (let i = 0; i < count; i++) {
+    qIdx--;
+    if (qIdx < 0) {
+      qIdx = 3;
+      year--;
+    }
+    dates.push(`${year}${suffixes[qIdx]}`);
+  }
+  return dates;
+}
+function collectRiskSignals(metrics, components, trends) {
+  const signals = [];
+  if (metrics.tier1_leverage !== null && metrics.tier1_leverage < 5) {
+    signals.push(`Tier 1 leverage ratio at ${metrics.tier1_leverage.toFixed(2)}% \u2014 below well-capitalized threshold (5%)`);
+  }
+  if (metrics.roa !== null && metrics.roa < 0) {
+    signals.push(`Operating losses: ROA at ${metrics.roa.toFixed(2)}%`);
+  }
+  if (metrics.reserve_coverage !== null && metrics.reserve_coverage < 50) {
+    signals.push(`Reserve coverage critically low at ${metrics.reserve_coverage.toFixed(1)}%`);
+  }
+  if (metrics.brokered_deposit_ratio !== null && metrics.brokered_deposit_ratio > 15) {
+    signals.push(`High brokered deposit reliance: ${metrics.brokered_deposit_ratio.toFixed(1)}%`);
+  }
+  if (metrics.noncurrent_loans_ratio !== null && metrics.noncurrent_loans_ratio > 3) {
+    signals.push(`Elevated noncurrent loans: ${metrics.noncurrent_loans_ratio.toFixed(2)}%`);
+  }
+  for (const comp of components) {
+    if (comp.rating >= 4) {
+      const name = COMPONENT_NAMES[comp.component] ?? comp.component;
+      signals.push(`${name} component rated ${comp.rating} (${comp.label})`);
+    }
+  }
+  for (const t of trends) {
+    if (t.direction === "deteriorating" && t.magnitude === "significant") {
+      signals.push(`${t.label} deteriorating significantly over ${t.quarters_analyzed} quarters`);
+    }
+  }
+  return signals;
+}
+var BankHealthInputSchema = import_zod9.z.object({
+  cert: import_zod9.z.number().int().positive().describe("FDIC Certificate Number of the institution to analyze."),
+  repdte: import_zod9.z.string().regex(/^\d{8}$/).optional().describe(
+    "Report Date (YYYYMMDD). Defaults to the most recent quarter likely to have published data."
+  ),
+  quarters: import_zod9.z.number().int().min(1).max(20).default(8).describe("Number of prior quarters to fetch for trend analysis (default 8).")
+});
+function registerBankHealthTools(server) {
+  server.registerTool(
+    "fdic_analyze_bank_health",
+    {
+      title: "Analyze Bank Health (CAMELS-Style)",
+      description: `Produce a CAMELS-style analytical assessment for a single FDIC-insured institution.
+
+Scores five components \u2014 Capital (C), Asset Quality (A), Earnings (E), Liquidity (L), Sensitivity (S) \u2014 using published FDIC financial data and derives a weighted composite rating (1=Strong to 5=Unsatisfactory).
+
+Output includes:
+  - Composite and component ratings with individual metric scores
+  - Trend analysis across prior quarters for key metrics
+  - Risk signals flagging critical and warning-level concerns
+  - Structured JSON for programmatic consumption
+
+NOTE: Management (M) is omitted \u2014 cannot be assessed from public data. Sensitivity (S) uses proxy metrics (NIM trend, securities concentration). This is an analytical tool, not an official regulatory rating.`,
+      inputSchema: BankHealthInputSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    async (rawParams, extra) => {
+      const params = { ...rawParams, repdte: rawParams.repdte ?? getDefaultReportDate() };
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), ANALYSIS_TIMEOUT_MS);
+      const progressToken = extra._meta?.progressToken;
+      try {
+        const dateError = validateQuarterEndDate(params.repdte, "repdte");
+        if (dateError) {
+          return formatToolError(new Error(dateError));
+        }
+        await sendProgressNotification(server.server, progressToken, 0.1, "Fetching institution profile");
+        const [profileResponse, financialsResponse] = await Promise.all([
+          queryEndpoint(
+            ENDPOINTS.INSTITUTIONS,
+            {
+              filters: `CERT:${params.cert}`,
+              fields: "CERT,NAME,CITY,STALP,BKCLASS,ASSET,ACTIVE",
+              limit: 1
+            },
+            { signal: controller.signal }
+          ),
+          queryEndpoint(
+            ENDPOINTS.FINANCIALS,
+            {
+              filters: `CERT:${params.cert} AND REPDTE:${params.repdte}`,
+              fields: CAMELS_FIELDS,
+              limit: 1
+            },
+            { signal: controller.signal }
+          )
+        ]);
+        const profileRecords = extractRecords(profileResponse);
+        if (profileRecords.length === 0) {
+          return formatToolError(new Error(`No institution found with CERT number ${params.cert}.`));
+        }
+        const profile = profileRecords[0];
+        const financialRecords = extractRecords(financialsResponse);
+        if (financialRecords.length === 0) {
+          return formatToolError(
+            new Error(
+              `No financial data for CERT ${params.cert} at report date ${params.repdte}. Try an earlier quarter-end date (0331, 0630, 0930, 1231).`
+            )
+          );
+        }
+        const currentFinancials = financialRecords[0];
+        await sendProgressNotification(server.server, progressToken, 0.3, "Fetching prior quarters for trend analysis");
+        const priorDates = getPriorQuarterDates(params.repdte, params.quarters);
+        let priorQuarters = [];
+        if (priorDates.length > 0) {
+          const dateFilter = priorDates.map((d) => `REPDTE:${d}`).join(" OR ");
+          const priorResponse = await queryEndpoint(
+            ENDPOINTS.FINANCIALS,
+            {
+              filters: `CERT:${params.cert} AND (${dateFilter})`,
+              fields: CAMELS_FIELDS,
+              sort_by: "REPDTE",
+              sort_order: "DESC",
+              limit: params.quarters
+            },
+            { signal: controller.signal }
+          );
+          priorQuarters = extractRecords(priorResponse);
+        }
+        await sendProgressNotification(server.server, progressToken, 0.6, "Computing CAMELS scores");
+        const metrics = computeCamelsMetrics(currentFinancials, priorQuarters);
+        const components = ["C", "A", "E", "L", "S"].map(
+          (c) => scoreComponent(c, metrics)
+        );
+        const composite = compositeScore(components);
+        await sendProgressNotification(server.server, progressToken, 0.8, "Analyzing trends");
+        const allQuarters = [currentFinancials, ...priorQuarters];
+        const trends = [];
+        for (const tm of TREND_METRICS) {
+          const timeseries = allQuarters.map((q) => ({
+            repdte: String(q.REPDTE ?? ""),
+            value: typeof q[tm.fdic_field] === "number" ? q[tm.fdic_field] : null
+          }));
+          timeseries.reverse();
+          trends.push(analyzeTrend(String(tm.key), timeseries, tm.higher_is_better));
+        }
+        const riskSignals = collectRiskSignals(metrics, components, trends);
+        const staleness = isStale(params.repdte) ? "stale (>120 days old)" : "current";
+        const summary = {
+          institution: {
+            cert: params.cert,
+            name: String(profile.NAME ?? ""),
+            city: String(profile.CITY ?? ""),
+            state: String(profile.STALP ?? ""),
+            charter_class: String(profile.BKCLASS ?? ""),
+            total_assets: typeof currentFinancials.ASSET === "number" ? currentFinancials.ASSET : 0,
+            report_date: params.repdte,
+            data_staleness: staleness
+          },
+          composite: { rating: composite.rating, label: composite.label },
+          components,
+          trends,
+          outliers: [],
+          risk_signals: riskSignals
+        };
+        const text = truncateIfNeeded(
+          formatHealthSummaryText(summary),
+          CHARACTER_LIMIT
+        );
+        return {
+          content: [{ type: "text", text }],
+          structuredContent: summary
+        };
+      } catch (err) {
+        return formatToolError(err);
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    }
+  );
+}
+
+// src/tools/peerHealth.ts
+var import_zod10 = require("zod");
+var PeerHealthInputSchema = import_zod10.z.object({
+  cert: import_zod10.z.number().int().positive().optional().describe("Subject institution CERT to highlight in the ranking. Optional."),
+  certs: import_zod10.z.array(import_zod10.z.number().int().positive()).max(50).optional().describe("Explicit list of CERTs to compare (max 50)."),
+  state: import_zod10.z.string().regex(/^[A-Z]{2}$/).optional().describe('Two-letter state code to select all active institutions (e.g., "WY").'),
+  asset_min: import_zod10.z.number().positive().optional().describe("Minimum total assets ($thousands) for peer selection."),
+  asset_max: import_zod10.z.number().positive().optional().describe("Maximum total assets ($thousands) for peer selection."),
+  repdte: import_zod10.z.string().regex(/^\d{8}$/).optional().describe("Report Date (YYYYMMDD). Defaults to the most recent quarter."),
+  sort_by: import_zod10.z.enum(["composite", "capital", "asset_quality", "earnings", "liquidity", "sensitivity"]).default("composite").describe("Sort results by composite or a specific CAMELS component rating."),
+  limit: import_zod10.z.number().int().min(1).max(100).default(25).describe("Max institutions to return in the response.")
+});
+function sortKeyToComponent(key) {
+  const map = {
+    capital: "C",
+    asset_quality: "A",
+    earnings: "E",
+    liquidity: "L",
+    sensitivity: "S"
+  };
+  return map[key] ?? null;
+}
+function registerPeerHealthTools(server) {
+  server.registerTool(
+    "fdic_compare_peer_health",
+    {
+      title: "Compare Peer Health (CAMELS Rankings)",
+      description: `Compare CAMELS-style health scores across a group of FDIC-insured institutions.
+
+Three usage modes:
+  - Explicit list: provide certs (up to 50) for a specific comparison set
+  - State-wide scan: provide state to compare all active institutions in that state
+  - Asset-based: provide asset_min/asset_max to compare institutions by size
+
+Optionally provide cert to highlight a subject institution's position in the ranking.
+
+Output: Ranked list of institutions with CAMELS composite and component scores, sorted by composite or any individual component.
+
+NOTE: This is an analytical assessment, not official regulatory ratings.`,
+      inputSchema: PeerHealthInputSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    async (rawParams, extra) => {
+      const params = { ...rawParams, repdte: rawParams.repdte ?? getDefaultReportDate() };
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), ANALYSIS_TIMEOUT_MS);
+      const progressToken = extra._meta?.progressToken;
+      try {
+        if (!params.certs && !params.state && params.asset_min === void 0 && params.asset_max === void 0 && !params.cert) {
+          return formatToolError(new Error("At least one selection criteria required: certs, state, asset_min/asset_max, or cert."));
+        }
+        const dateError = validateQuarterEndDate(params.repdte, "repdte");
+        if (dateError) {
+          return formatToolError(new Error(dateError));
+        }
+        await sendProgressNotification(server.server, progressToken, 0.1, "Building peer roster");
+        let peerCerts;
+        if (params.certs) {
+          peerCerts = [...params.certs];
+          if (params.cert && !peerCerts.includes(params.cert)) {
+            peerCerts.push(params.cert);
+          }
+        } else {
+          const filterParts = ["ACTIVE:1"];
+          if (params.state) filterParts.push(`STALP:${params.state}`);
+          if (params.asset_min !== void 0 || params.asset_max !== void 0) {
+            const min = params.asset_min ?? 0;
+            const max = params.asset_max ?? "*";
+            filterParts.push(`ASSET:[${min} TO ${max}]`);
+          }
+          if (params.cert && !params.state && params.asset_min === void 0) {
+            const profileResp = await queryEndpoint(
+              ENDPOINTS.INSTITUTIONS,
+              {
+                filters: `CERT:${params.cert}`,
+                fields: "CERT,ASSET,STALP,BKCLASS",
+                limit: 1
+              },
+              { signal: controller.signal }
+            );
+            const profileRecs = extractRecords(profileResp);
+            if (profileRecs.length === 0) {
+              return formatToolError(new Error(`No institution found with CERT ${params.cert}.`));
+            }
+            const subjectAsset = asNumber(profileRecs[0].ASSET);
+            if (subjectAsset !== null) {
+              filterParts.push(`ASSET:[${subjectAsset * 0.5} TO ${subjectAsset * 2}]`);
+            }
+            const bkclass = profileRecs[0].BKCLASS;
+            if (typeof bkclass === "string") {
+              filterParts.push(`BKCLASS:${bkclass}`);
+            }
+          }
+          const rosterResp = await queryEndpoint(
+            ENDPOINTS.INSTITUTIONS,
+            {
+              filters: filterParts.join(" AND "),
+              fields: "CERT",
+              limit: 1e4,
+              sort_by: "CERT",
+              sort_order: "ASC"
+            },
+            { signal: controller.signal }
+          );
+          peerCerts = extractRecords(rosterResp).map((r) => asNumber(r.CERT)).filter((c) => c !== null);
+        }
+        if (peerCerts.length === 0) {
+          return formatToolError(new Error("No institutions matched the specified criteria."));
+        }
+        await sendProgressNotification(server.server, progressToken, 0.4, `Fetching financials for ${peerCerts.length} institutions`);
+        const certFilters = buildCertFilters(peerCerts);
+        const financialResponses = await mapWithConcurrency(
+          certFilters,
+          MAX_CONCURRENCY,
+          async (certFilter) => queryEndpoint(
+            ENDPOINTS.FINANCIALS,
+            {
+              filters: `(${certFilter}) AND REPDTE:${params.repdte}`,
+              fields: CAMELS_FIELDS,
+              limit: 1e4,
+              sort_by: "CERT",
+              sort_order: "ASC"
+            },
+            { signal: controller.signal }
+          )
+        );
+        const allFinancials = financialResponses.flatMap(extractRecords);
+        const rosterResp2 = await queryEndpoint(
+          ENDPOINTS.INSTITUTIONS,
+          {
+            filters: peerCerts.length <= 25 ? peerCerts.map((c) => `CERT:${c}`).join(" OR ") : `CERT:[${Math.min(...peerCerts)} TO ${Math.max(...peerCerts)}]`,
+            fields: "CERT,NAME,CITY,STALP",
+            limit: 1e4,
+            sort_by: "CERT",
+            sort_order: "ASC"
+          },
+          { signal: controller.signal }
+        );
+        const profileMap = /* @__PURE__ */ new Map();
+        for (const r of extractRecords(rosterResp2)) {
+          const c = asNumber(r.CERT);
+          if (c !== null) profileMap.set(c, r);
+        }
+        await sendProgressNotification(server.server, progressToken, 0.7, "Computing CAMELS scores");
+        const entries = [];
+        for (const fin of allFinancials) {
+          const cert = asNumber(fin.CERT);
+          if (cert === null) continue;
+          const metrics = computeCamelsMetrics(fin);
+          const components = ["C", "A", "E", "L", "S"].map(
+            (c) => scoreComponent(c, metrics)
+          );
+          const comp = compositeScore(components);
+          const profile = profileMap.get(cert);
+          entries.push({
+            cert,
+            name: String(profile?.NAME ?? `CERT ${cert}`),
+            city: profile?.CITY ? String(profile.CITY) : null,
+            state: profile?.STALP ? String(profile.STALP) : null,
+            total_assets: asNumber(fin.ASSET),
+            composite_rating: comp.rating,
+            composite_label: comp.label,
+            component_ratings: Object.fromEntries(components.map((c) => [c.component, c.rating])),
+            flags: comp.flags
+          });
+        }
+        const sortComponent = sortKeyToComponent(params.sort_by);
+        entries.sort((a, b) => {
+          const aVal = sortComponent ? a.component_ratings[sortComponent] ?? 3 : a.composite_rating;
+          const bVal = sortComponent ? b.component_ratings[sortComponent] ?? 3 : b.composite_rating;
+          if (aVal !== bVal) return aVal - bVal;
+          return (b.total_assets ?? 0) - (a.total_assets ?? 0);
+        });
+        const subjectRank = params.cert ? entries.findIndex((e) => e.cert === params.cert) + 1 : null;
+        const returned = entries.slice(0, params.limit);
+        await sendProgressNotification(server.server, progressToken, 0.9, "Formatting results");
+        const parts = [];
+        parts.push(`CAMELS Peer Health Comparison \u2014 ${entries.length} institutions ranked by ${params.sort_by}`);
+        parts.push(`Report Date: ${params.repdte}`);
+        parts.push("NOTE: Analytical assessment, not official regulatory ratings.");
+        parts.push("");
+        if (subjectRank && subjectRank > 0 && params.cert) {
+          const subj = entries[subjectRank - 1];
+          parts.push(`Subject: ${subj.name} (CERT ${subj.cert}) \u2014 Rank ${subjectRank} of ${entries.length}, Composite: ${formatRating(subj.composite_rating)}`);
+          parts.push("");
+        }
+        for (let i = 0; i < returned.length; i++) {
+          const e = returned[i];
+          const rank = entries.indexOf(e) + 1;
+          const marker = params.cert && e.cert === params.cert ? " \u25C4 SUBJECT" : "";
+          const location = [e.city, e.state].filter(Boolean).join(", ");
+          const compStr = ["C", "A", "E", "L", "S"].map((c) => `${c}:${e.component_ratings[c] ?? "?"}`).join(" ");
+          const assetStr = e.total_assets !== null ? `$${Math.round(e.total_assets).toLocaleString()}k` : "n/a";
+          parts.push(
+            `${String(rank).padStart(3)}. ${e.name} (${location}) CERT ${e.cert}${marker}`
+          );
+          parts.push(
+            `     Composite: ${formatRating(e.composite_rating)} | ${compStr} | Assets: ${assetStr}`
+          );
+          if (e.flags.length > 0) {
+            parts.push(`     Flags: ${e.flags.join("; ")}`);
+          }
+        }
+        if (entries.length > returned.length) {
+          parts.push("");
+          parts.push(`Showing ${returned.length} of ${entries.length}. Increase limit to see more.`);
+        }
+        const text = truncateIfNeeded(parts.join("\n"), CHARACTER_LIMIT);
+        return {
+          content: [{ type: "text", text }],
+          structuredContent: {
+            report_date: params.repdte,
+            sort_by: params.sort_by,
+            total_institutions: entries.length,
+            returned_count: returned.length,
+            subject_cert: params.cert ?? null,
+            subject_rank: subjectRank,
+            institutions: returned
+          }
+        };
+      } catch (err) {
+        return formatToolError(err);
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    }
+  );
+}
+
+// src/tools/riskSignals.ts
+var import_zod11 = require("zod");
+var TREND_METRICS2 = [
+  { key: "tier1_leverage", fdic_field: "IDT1CER", higher_is_better: true, category: "capital" },
+  { key: "noncurrent_loans_ratio", fdic_field: "NCLNLSR", higher_is_better: false, category: "asset_quality" },
+  { key: "roa", fdic_field: "ROA", higher_is_better: true, category: "earnings" },
+  { key: "nim", fdic_field: "NIMY", higher_is_better: true, category: "earnings" },
+  { key: "efficiency_ratio", fdic_field: "EEFFR", higher_is_better: false, category: "earnings" },
+  { key: "loan_to_deposit", fdic_field: "LNLSDEPR", higher_is_better: false, category: "liquidity" }
+];
+function classifyRiskSignals(metrics, trends) {
+  const signals = [];
+  if (metrics.tier1_leverage !== null && metrics.tier1_leverage < 5) {
+    signals.push({ severity: "critical", category: "capital", message: `Tier 1 leverage at ${metrics.tier1_leverage.toFixed(2)}% \u2014 below well-capitalized threshold (5%)` });
+  }
+  if (metrics.tier1_rbc !== null && metrics.tier1_rbc < 6) {
+    signals.push({ severity: "critical", category: "capital", message: `Tier 1 risk-based capital at ${metrics.tier1_rbc.toFixed(2)}% \u2014 below well-capitalized threshold (6%)` });
+  }
+  if (metrics.roa !== null && metrics.roa < 0) {
+    signals.push({ severity: "critical", category: "earnings", message: `Operating losses: ROA at ${metrics.roa.toFixed(2)}%` });
+  }
+  if (metrics.reserve_coverage !== null && metrics.reserve_coverage < 50) {
+    signals.push({ severity: "critical", category: "asset_quality", message: `Reserve coverage critically low at ${metrics.reserve_coverage.toFixed(1)}%` });
+  }
+  if (metrics.noncurrent_loans_ratio !== null && metrics.noncurrent_loans_ratio > 3) {
+    signals.push({ severity: "warning", category: "asset_quality", message: `Noncurrent loans elevated at ${metrics.noncurrent_loans_ratio.toFixed(2)}%` });
+  }
+  if (metrics.brokered_deposit_ratio !== null && metrics.brokered_deposit_ratio > 15) {
+    signals.push({ severity: "warning", category: "liquidity", message: `High brokered deposit reliance: ${metrics.brokered_deposit_ratio.toFixed(1)}%` });
+  }
+  if (metrics.nim_4q_change !== null && metrics.nim_4q_change < -0.3) {
+    signals.push({ severity: "warning", category: "sensitivity", message: `NIM compressed ${Math.abs(metrics.nim_4q_change).toFixed(2)}pp over 4 quarters` });
+  }
+  const components = ["C", "A", "E", "L", "S"].map(
+    (c) => scoreComponent(c, metrics)
+  );
+  const componentCategoryMap = {
+    C: "capital",
+    A: "asset_quality",
+    E: "earnings",
+    L: "liquidity",
+    S: "sensitivity"
+  };
+  const componentNames = {
+    C: "Capital",
+    A: "Asset Quality",
+    E: "Earnings",
+    L: "Liquidity",
+    S: "Sensitivity"
+  };
+  for (const comp of components) {
+    if (comp.rating >= 4) {
+      signals.push({
+        severity: "warning",
+        category: componentCategoryMap[comp.component],
+        message: `${componentNames[comp.component]} component rated ${formatRating(comp.rating)}`
+      });
+    }
+  }
+  const trendCategoryMap = {
+    tier1_leverage: "capital",
+    noncurrent_loans_ratio: "asset_quality",
+    roa: "earnings",
+    nim: "earnings",
+    efficiency_ratio: "earnings",
+    loan_to_deposit: "liquidity"
+  };
+  for (const t of trends) {
+    if (t.direction === "deteriorating") {
+      const cat = trendCategoryMap[t.metric] ?? "trend";
+      if (t.magnitude === "significant") {
+        signals.push({ severity: "warning", category: cat, message: `${t.label} deteriorating significantly over ${t.quarters_analyzed} quarters` });
+      } else if (t.magnitude === "moderate") {
+        signals.push({ severity: "info", category: cat, message: `${t.label} deteriorating moderately over ${t.quarters_analyzed} quarters` });
+      }
+    }
+  }
+  return signals;
+}
+function getPriorQuarterDates2(repdte, count) {
+  const dates = [];
+  const suffixes = ["0331", "0630", "0930", "1231"];
+  let year = Number.parseInt(repdte.slice(0, 4), 10);
+  let qIdx = suffixes.indexOf(repdte.slice(4));
+  if (qIdx === -1) return dates;
+  for (let i = 0; i < count; i++) {
+    qIdx--;
+    if (qIdx < 0) {
+      qIdx = 3;
+      year--;
+    }
+    dates.push(`${year}${suffixes[qIdx]}`);
+  }
+  return dates;
+}
+var SEVERITY_ORDER = { critical: 0, warning: 1, info: 2 };
+var RiskSignalsInputSchema = import_zod11.z.object({
+  state: import_zod11.z.string().regex(/^[A-Z]{2}$/).optional().describe("Scan all active institutions in this state."),
+  certs: import_zod11.z.array(import_zod11.z.number().int().positive()).max(50).optional().describe("Specific CERTs to scan (max 50)."),
+  asset_min: import_zod11.z.number().positive().optional().describe("Minimum total assets ($thousands) filter."),
+  asset_max: import_zod11.z.number().positive().optional().describe("Maximum total assets ($thousands) filter."),
+  repdte: import_zod11.z.string().regex(/^\d{8}$/).optional().describe("Report Date (YYYYMMDD). Defaults to the most recent quarter."),
+  min_severity: import_zod11.z.enum(["info", "warning", "critical"]).default("warning").describe("Minimum severity level to include in results (default: warning)."),
+  quarters: import_zod11.z.number().int().min(1).max(12).default(4).describe("Prior quarters to fetch for trend analysis (default 4)."),
+  limit: import_zod11.z.number().int().min(1).max(100).default(25).describe("Max flagged institutions to return.")
+});
+function registerRiskSignalTools(server) {
+  server.registerTool(
+    "fdic_detect_risk_signals",
+    {
+      title: "Detect Risk Signals (Early Warning)",
+      description: `Scan FDIC-insured institutions for early warning risk signals using CAMELS-style analysis.
+
+Scans institutions for:
+  - Critical: undercapitalized (Tier 1 < 5%), operating losses (ROA < 0), reserve coverage < 50%
+  - Warning: CAMELS component rated 4+, significant deteriorating trends, brokered deposits > 15%, noncurrent loans > 3%
+  - Info: moderate deteriorating trends
+
+Three scan modes:
+  - State-wide: provide state to scan all active institutions
+  - Explicit list: provide certs (up to 50)
+  - Asset-based: provide asset_min/asset_max
+
+Output: Ranked list of flagged institutions sorted by signal severity count.
+
+NOTE: Analytical screening tool, not official supervisory ratings.`,
+      inputSchema: RiskSignalsInputSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    async (rawParams, extra) => {
+      const params = { ...rawParams, repdte: rawParams.repdte ?? getDefaultReportDate() };
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), ANALYSIS_TIMEOUT_MS);
+      const progressToken = extra._meta?.progressToken;
+      try {
+        if (!params.certs && !params.state && params.asset_min === void 0 && params.asset_max === void 0) {
+          return formatToolError(new Error("At least one selection criteria required: certs, state, or asset_min/asset_max."));
+        }
+        const dateError = validateQuarterEndDate(params.repdte, "repdte");
+        if (dateError) {
+          return formatToolError(new Error(dateError));
+        }
+        await sendProgressNotification(server.server, progressToken, 0.1, "Building institution roster");
+        let targetCerts;
+        if (params.certs) {
+          targetCerts = [...params.certs];
+        } else {
+          const filterParts = ["ACTIVE:1"];
+          if (params.state) filterParts.push(`STALP:${params.state}`);
+          if (params.asset_min !== void 0 || params.asset_max !== void 0) {
+            const min = params.asset_min ?? 0;
+            const max = params.asset_max ?? "*";
+            filterParts.push(`ASSET:[${min} TO ${max}]`);
+          }
+          const rosterResp = await queryEndpoint(
+            ENDPOINTS.INSTITUTIONS,
+            {
+              filters: filterParts.join(" AND "),
+              fields: "CERT",
+              limit: 1e4,
+              sort_by: "CERT",
+              sort_order: "ASC"
+            },
+            { signal: controller.signal }
+          );
+          targetCerts = extractRecords(rosterResp).map((r) => asNumber(r.CERT)).filter((c) => c !== null);
+        }
+        if (targetCerts.length === 0) {
+          return formatToolError(new Error("No institutions matched the specified criteria."));
+        }
+        await sendProgressNotification(server.server, progressToken, 0.3, `Fetching financials for ${targetCerts.length} institutions`);
+        const certFilters = buildCertFilters(targetCerts);
+        const currentResponses = await mapWithConcurrency(
+          certFilters,
+          MAX_CONCURRENCY,
+          async (certFilter) => queryEndpoint(
+            ENDPOINTS.FINANCIALS,
+            {
+              filters: `(${certFilter}) AND REPDTE:${params.repdte}`,
+              fields: CAMELS_FIELDS,
+              limit: 1e4,
+              sort_by: "CERT",
+              sort_order: "ASC"
+            },
+            { signal: controller.signal }
+          )
+        );
+        const allCurrentFinancials = currentResponses.flatMap(extractRecords);
+        const priorDates = getPriorQuarterDates2(params.repdte, params.quarters);
+        let priorByInstitution = /* @__PURE__ */ new Map();
+        if (priorDates.length > 0) {
+          await sendProgressNotification(server.server, progressToken, 0.5, "Fetching prior quarters for trends");
+          const dateFilter = priorDates.map((d) => `REPDTE:${d}`).join(" OR ");
+          const priorResponses = await mapWithConcurrency(
+            certFilters,
+            MAX_CONCURRENCY,
+            async (certFilter) => queryEndpoint(
+              ENDPOINTS.FINANCIALS,
+              {
+                filters: `(${certFilter}) AND (${dateFilter})`,
+                fields: CAMELS_FIELDS,
+                limit: 1e4,
+                sort_by: "REPDTE",
+                sort_order: "DESC"
+              },
+              { signal: controller.signal }
+            )
+          );
+          for (const rec of priorResponses.flatMap(extractRecords)) {
+            const cert = asNumber(rec.CERT);
+            if (cert === null) continue;
+            const existing = priorByInstitution.get(cert) ?? [];
+            existing.push(rec);
+            priorByInstitution.set(cert, existing);
+          }
+        }
+        const profileResp = await queryEndpoint(
+          ENDPOINTS.INSTITUTIONS,
+          {
+            filters: targetCerts.length <= 25 ? targetCerts.map((c) => `CERT:${c}`).join(" OR ") : `CERT:[${Math.min(...targetCerts)} TO ${Math.max(...targetCerts)}]`,
+            fields: "CERT,NAME,CITY,STALP",
+            limit: 1e4,
+            sort_by: "CERT",
+            sort_order: "ASC"
+          },
+          { signal: controller.signal }
+        );
+        const profileMap = /* @__PURE__ */ new Map();
+        for (const r of extractRecords(profileResp)) {
+          const c = asNumber(r.CERT);
+          if (c !== null) profileMap.set(c, r);
+        }
+        await sendProgressNotification(server.server, progressToken, 0.7, "Analyzing risk signals");
+        const minSeverityOrder = SEVERITY_ORDER[params.min_severity];
+        const results = [];
+        for (const fin of allCurrentFinancials) {
+          const cert = asNumber(fin.CERT);
+          if (cert === null) continue;
+          const priorQuarters = priorByInstitution.get(cert) ?? [];
+          const metrics = computeCamelsMetrics(fin, priorQuarters);
+          const allQuarters = [fin, ...priorQuarters];
+          const trends = [];
+          for (const tm of TREND_METRICS2) {
+            const timeseries = allQuarters.map((q) => ({
+              repdte: String(q.REPDTE ?? ""),
+              value: typeof q[tm.fdic_field] === "number" ? q[tm.fdic_field] : null
+            }));
+            timeseries.reverse();
+            trends.push(analyzeTrend(String(tm.key), timeseries, tm.higher_is_better));
+          }
+          const allSignals = classifyRiskSignals(metrics, trends);
+          const filteredSignals = allSignals.filter((s) => SEVERITY_ORDER[s.severity] <= minSeverityOrder);
+          if (filteredSignals.length === 0) continue;
+          const components = ["C", "A", "E", "L", "S"].map((c) => scoreComponent(c, metrics));
+          const comp = compositeScore(components);
+          const profile = profileMap.get(cert);
+          results.push({
+            cert,
+            name: String(profile?.NAME ?? `CERT ${cert}`),
+            city: profile?.CITY ? String(profile.CITY) : null,
+            state: profile?.STALP ? String(profile.STALP) : null,
+            total_assets: asNumber(fin.ASSET),
+            composite_rating: comp.rating,
+            composite_label: comp.label,
+            signals: filteredSignals,
+            critical_count: filteredSignals.filter((s) => s.severity === "critical").length,
+            warning_count: filteredSignals.filter((s) => s.severity === "warning").length
+          });
+        }
+        results.sort((a, b) => {
+          if (a.critical_count !== b.critical_count) return b.critical_count - a.critical_count;
+          if (a.warning_count !== b.warning_count) return b.warning_count - a.warning_count;
+          return b.composite_rating - a.composite_rating;
+        });
+        const returned = results.slice(0, params.limit);
+        await sendProgressNotification(server.server, progressToken, 0.9, "Formatting results");
+        const parts = [];
+        parts.push(`Risk Signal Scan \u2014 ${results.length} flagged of ${allCurrentFinancials.length} institutions scanned`);
+        parts.push(`Report Date: ${params.repdte} | Min Severity: ${params.min_severity}`);
+        parts.push("NOTE: Analytical screening tool, not official supervisory ratings.");
+        parts.push("");
+        if (returned.length === 0) {
+          parts.push("No institutions flagged at the specified severity level.");
+        }
+        for (let i = 0; i < returned.length; i++) {
+          const r = returned[i];
+          const location = [r.city, r.state].filter(Boolean).join(", ");
+          const assetStr = r.total_assets !== null ? `$${Math.round(r.total_assets).toLocaleString()}k` : "n/a";
+          parts.push(`${i + 1}. ${r.name} (${location}) CERT ${r.cert} | Assets: ${assetStr}`);
+          parts.push(`   Composite: ${formatRating(r.composite_rating)} | Critical: ${r.critical_count} | Warnings: ${r.warning_count}`);
+          for (const s of r.signals) {
+            const icon = s.severity === "critical" ? "\u{1F534}" : s.severity === "warning" ? "\u{1F7E1}" : "\u{1F535}";
+            parts.push(`   ${icon} [${s.severity}] ${s.message}`);
+          }
+          parts.push("");
+        }
+        if (results.length > returned.length) {
+          parts.push(`Showing ${returned.length} of ${results.length} flagged institutions. Increase limit to see more.`);
+        }
+        const text = truncateIfNeeded(parts.join("\n"), CHARACTER_LIMIT);
+        return {
+          content: [{ type: "text", text }],
+          structuredContent: {
+            report_date: params.repdte,
+            min_severity: params.min_severity,
+            institutions_scanned: allCurrentFinancials.length,
+            institutions_flagged: results.length,
+            returned_count: returned.length,
+            institutions: returned
+          }
+        };
+      } catch (err) {
+        return formatToolError(err);
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    }
+  );
+}
+
+// src/tools/creditConcentration.ts
+var import_zod12 = require("zod");
+
+// src/tools/shared/creditConcentration.ts
+var CREDIT_FIELDS = [
+  "CERT",
+  "REPDTE",
+  "ASSET",
+  "EQTOT",
+  "EQV",
+  "LNLSNET",
+  "LNRE",
+  "LNRERES",
+  "LNRECONS",
+  "LNREMULT",
+  "LNRENRES",
+  "LNREAG",
+  "LNRELOC",
+  "LNCI",
+  "LNCON",
+  "LNAG",
+  "LNOTH",
+  "LNREDOM",
+  "LNREFOR"
+].join(",");
+function safePct(num, den) {
+  if (num === null || den === null || den === 0) return null;
+  return num / den * 100;
+}
+function computeCreditMetrics(raw) {
+  const lnlsnet = asNumber(raw.LNLSNET);
+  const lnrecons = asNumber(raw.LNRECONS);
+  const lnremult = asNumber(raw.LNREMULT);
+  const lnrenres = asNumber(raw.LNRENRES);
+  const eqtot = asNumber(raw.EQTOT);
+  const asset = asNumber(raw.ASSET);
+  const lnci = asNumber(raw.LNCI);
+  const lncon = asNumber(raw.LNCON);
+  const lnreres = asNumber(raw.LNRERES);
+  const lnag = asNumber(raw.LNAG);
+  const cre = lnrecons !== null && lnremult !== null && lnrenres !== null ? lnrecons + lnremult + lnrenres : null;
+  return {
+    total_loans: lnlsnet,
+    cre_to_total_loans: safePct(cre, lnlsnet),
+    cre_to_capital: safePct(cre, eqtot),
+    construction_to_capital: safePct(lnrecons, eqtot),
+    ci_share: safePct(lnci, lnlsnet),
+    consumer_share: safePct(lncon, lnlsnet),
+    residential_re_share: safePct(lnreres, lnlsnet),
+    ag_share: safePct(lnag, lnlsnet),
+    loans_to_assets: safePct(lnlsnet, asset)
+  };
+}
+function scoreCreditConcentration(m) {
+  const signals = [];
+  if (m.cre_to_capital !== null && m.cre_to_capital > 300) {
+    signals.push({
+      severity: "warning",
+      category: "credit_concentration",
+      message: `CRE concentration at ${m.cre_to_capital.toFixed(0)}% of capital exceeds 300% interagency guidance threshold`
+    });
+  }
+  if (m.construction_to_capital !== null && m.construction_to_capital > 100) {
+    signals.push({
+      severity: "warning",
+      category: "credit_concentration",
+      message: `construction loan concentration at ${m.construction_to_capital.toFixed(0)}% of capital exceeds 100% interagency guidance threshold`
+    });
+  }
+  if (m.loans_to_assets !== null && m.loans_to_assets > 80) {
+    signals.push({
+      severity: "info",
+      category: "credit_concentration",
+      message: `High loan-to-asset ratio at ${m.loans_to_assets.toFixed(1)}% indicates elevated lending relative to total assets`
+    });
+  }
+  return signals;
+}
+
+// src/tools/creditConcentration.ts
+function fmtPct(val) {
+  return val !== null ? `${val.toFixed(1)}%` : "n/a";
+}
+function fmtDollarsK(val) {
+  return val !== null ? `$${Math.round(val).toLocaleString()}K` : "n/a";
+}
+function formatCreditSummaryText(summary) {
+  const parts = [];
+  const { institution: inst, metrics: m, signals } = summary;
+  parts.push("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  parts.push(`  Credit Concentration Analysis: ${inst.name}`);
+  parts.push(`  ${inst.city}, ${inst.state} | CERT ${inst.cert} | Total Assets: ${fmtDollarsK(inst.total_assets)}`);
+  parts.push(`  Report Date: ${inst.report_date}`);
+  parts.push("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  parts.push("");
+  parts.push("Loan Portfolio Composition");
+  parts.push("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  parts.push(`  Total Loans:              ${fmtDollarsK(m.total_loans)}`);
+  parts.push(`  Loans / Assets:           ${fmtPct(m.loans_to_assets)}`);
+  parts.push("");
+  parts.push(`  CRE / Total Loans:        ${fmtPct(m.cre_to_total_loans)}`);
+  parts.push(`  CRE / Capital:            ${fmtPct(m.cre_to_capital)}`);
+  parts.push(`  Construction / Capital:   ${fmtPct(m.construction_to_capital)}`);
+  parts.push("");
+  parts.push(`  C&I Share:                ${fmtPct(m.ci_share)}`);
+  parts.push(`  Consumer Share:           ${fmtPct(m.consumer_share)}`);
+  parts.push(`  Residential RE Share:     ${fmtPct(m.residential_re_share)}`);
+  parts.push(`  Agricultural Share:       ${fmtPct(m.ag_share)}`);
+  if (signals.length > 0) {
+    parts.push("");
+    parts.push("\u26A0 Concentration Signals");
+    parts.push("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    for (const signal of signals) {
+      parts.push(`  \u2022 ${signal.message}`);
+    }
+  }
+  return parts.join("\n");
+}
+var CreditConcentrationSchema = import_zod12.z.object({
+  cert: import_zod12.z.number().int().positive().describe("FDIC Certificate Number"),
+  repdte: import_zod12.z.string().regex(/^\d{8}$/).optional().describe("Report date (YYYYMMDD). Defaults to most recent quarter.")
+});
+function registerCreditConcentrationTools(server) {
+  server.registerTool(
+    "fdic_analyze_credit_concentration",
+    {
+      title: "Analyze Credit Concentration",
+      description: `Analyze loan portfolio composition and credit concentration risk for an FDIC-insured institution. Computes CRE concentration relative to capital (per 2006 interagency guidance), loan-type breakdown, and flags concentration risks.
+
+Output includes:
+  - Loan portfolio composition (CRE, C&I, consumer, residential, agricultural shares)
+  - CRE and construction concentration relative to total capital
+  - Loan-to-asset ratio
+  - Concentration risk signals based on interagency guidance thresholds
+  - Structured JSON for programmatic consumption
+
+NOTE: This is an analytical tool based on public financial data.`,
+      inputSchema: CreditConcentrationSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    async (rawParams, extra) => {
+      const params = { ...rawParams, repdte: rawParams.repdte ?? getDefaultReportDate() };
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), ANALYSIS_TIMEOUT_MS);
+      const progressToken = extra._meta?.progressToken;
+      try {
+        const dateError = validateQuarterEndDate(params.repdte, "repdte");
+        if (dateError) {
+          return formatToolError(new Error(dateError));
+        }
+        await sendProgressNotification(server.server, progressToken, 0.1, "Fetching institution profile");
+        const [profileResponse, financialsResponse] = await Promise.all([
+          queryEndpoint(
+            ENDPOINTS.INSTITUTIONS,
+            {
+              filters: `CERT:${params.cert}`,
+              fields: "CERT,NAME,CITY,STALP,ASSET",
+              limit: 1
+            },
+            { signal: controller.signal }
+          ),
+          queryEndpoint(
+            ENDPOINTS.FINANCIALS,
+            {
+              filters: `CERT:${params.cert} AND REPDTE:${params.repdte}`,
+              fields: CREDIT_FIELDS,
+              limit: 1
+            },
+            { signal: controller.signal }
+          )
+        ]);
+        const profileRecords = extractRecords(profileResponse);
+        if (profileRecords.length === 0) {
+          return formatToolError(new Error(`No institution found with CERT number ${params.cert}.`));
+        }
+        const profile = profileRecords[0];
+        const financialRecords = extractRecords(financialsResponse);
+        if (financialRecords.length === 0) {
+          return formatToolError(
+            new Error(
+              `No financial data for CERT ${params.cert} at report date ${params.repdte}. Try an earlier quarter-end date (0331, 0630, 0930, 1231).`
+            )
+          );
+        }
+        const currentFinancials = financialRecords[0];
+        await sendProgressNotification(server.server, progressToken, 0.5, "Computing credit metrics");
+        const metrics = computeCreditMetrics(currentFinancials);
+        const signals = scoreCreditConcentration(metrics);
+        await sendProgressNotification(server.server, progressToken, 0.9, "Formatting results");
+        const summary = {
+          institution: {
+            cert: params.cert,
+            name: String(profile.NAME ?? ""),
+            city: String(profile.CITY ?? ""),
+            state: String(profile.STALP ?? ""),
+            total_assets: typeof currentFinancials.ASSET === "number" ? currentFinancials.ASSET : 0,
+            report_date: params.repdte
+          },
+          metrics,
+          signals
+        };
+        const text = truncateIfNeeded(
+          formatCreditSummaryText(summary),
+          CHARACTER_LIMIT
+        );
+        return {
+          content: [{ type: "text", text }],
+          structuredContent: summary
+        };
+      } catch (err) {
+        return formatToolError(err);
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    }
+  );
+}
+
+// src/tools/fundingProfile.ts
+var import_zod13 = require("zod");
+
+// src/tools/shared/fundingProfile.ts
+var FUNDING_FIELDS = "CERT,REPDTE,ASSET,DEP,DEPDOM,DEPFOR,COREDEP,BROR,FREPP,EFREPP,EINTEXP,DEPDASTR,CHBALR,LNLSDEPR";
+function safePct2(num, den) {
+  if (num === null || den === null || den === 0) return null;
+  return num / den * 100;
+}
+function computeFundingMetrics(raw) {
+  const asset = asNumber(raw.ASSET);
+  const dep = asNumber(raw.DEP);
+  const depfor = asNumber(raw.DEPFOR);
+  const coredep = asNumber(raw.COREDEP);
+  const bror = asNumber(raw.BROR);
+  const frepp = asNumber(raw.FREPP);
+  const chbalr = asNumber(raw.CHBALR);
+  const wholesaleNum = dep !== null && coredep !== null && frepp !== null ? dep - coredep + frepp : null;
+  return {
+    core_deposit_ratio: safePct2(coredep, dep),
+    brokered_deposit_ratio: bror,
+    wholesale_funding_ratio: safePct2(wholesaleNum, asset),
+    fhlb_to_assets: safePct2(frepp, asset),
+    foreign_deposit_share: safePct2(depfor, dep),
+    deposits_to_assets: safePct2(dep, asset),
+    cost_of_funds: null,
+    // needs prior quarter data — future enhancement
+    cash_ratio: chbalr
+  };
+}
+function scoreFundingRisks(m) {
+  const signals = [];
+  if (m.brokered_deposit_ratio !== null && m.brokered_deposit_ratio > 15) {
+    signals.push({
+      severity: "warning",
+      category: "funding_risk",
+      message: `Brokered deposits at ${m.brokered_deposit_ratio.toFixed(1)}% exceed 15% threshold, indicating potential funding volatility`
+    });
+  }
+  if (m.wholesale_funding_ratio !== null && m.wholesale_funding_ratio > 25) {
+    signals.push({
+      severity: "warning",
+      category: "funding_risk",
+      message: `Wholesale funding at ${m.wholesale_funding_ratio.toFixed(1)}% of assets exceeds 25% threshold`
+    });
+  }
+  if (m.core_deposit_ratio !== null && m.core_deposit_ratio < 60) {
+    signals.push({
+      severity: "warning",
+      category: "funding_risk",
+      message: `Core deposit ratio at ${m.core_deposit_ratio.toFixed(1)}% is below 60% threshold, indicating reliance on less stable funding`
+    });
+  }
+  if (m.fhlb_to_assets !== null && m.fhlb_to_assets > 15) {
+    signals.push({
+      severity: "info",
+      category: "funding_risk",
+      message: `FHLB borrowings at ${m.fhlb_to_assets.toFixed(1)}% of assets exceed 15%, indicating elevated reliance on wholesale borrowing`
+    });
+  }
+  return signals;
+}
+
+// src/tools/fundingProfile.ts
+function fmtPct2(val) {
+  return val !== null ? `${val.toFixed(1)}%` : "n/a";
+}
+function fmtDollarsK2(val) {
+  return val !== null ? `$${Math.round(val).toLocaleString()}K` : "n/a";
+}
+function formatFundingSummaryText(summary) {
+  const parts = [];
+  const { institution: inst, metrics: m, signals } = summary;
+  parts.push("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  parts.push(`  Funding Profile Analysis: ${inst.name}`);
+  parts.push(`  ${inst.city}, ${inst.state} | CERT ${inst.cert} | Total Assets: ${fmtDollarsK2(inst.total_assets)}`);
+  parts.push(`  Report Date: ${inst.report_date}`);
+  parts.push("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  parts.push("");
+  parts.push("Deposit Composition");
+  parts.push("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  parts.push(`  Deposits / Assets:        ${fmtPct2(m.deposits_to_assets)}`);
+  parts.push(`  Core Deposit Ratio:       ${fmtPct2(m.core_deposit_ratio)}`);
+  parts.push(`  Brokered Deposit Ratio:   ${fmtPct2(m.brokered_deposit_ratio)}`);
+  parts.push(`  Foreign Deposit Share:    ${fmtPct2(m.foreign_deposit_share)}`);
+  parts.push("");
+  parts.push("Wholesale Funding & Liquidity");
+  parts.push("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  parts.push(`  Wholesale Funding Ratio:  ${fmtPct2(m.wholesale_funding_ratio)}`);
+  parts.push(`  FHLB / Assets:            ${fmtPct2(m.fhlb_to_assets)}`);
+  parts.push(`  Cash Ratio:               ${fmtPct2(m.cash_ratio)}`);
+  if (signals.length > 0) {
+    parts.push("");
+    parts.push("\u26A0 Funding Risk Signals");
+    parts.push("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    for (const signal of signals) {
+      parts.push(`  \u2022 ${signal.message}`);
+    }
+  }
+  return parts.join("\n");
+}
+var FundingProfileSchema = import_zod13.z.object({
+  cert: import_zod13.z.number().int().positive().describe("FDIC Certificate Number"),
+  repdte: import_zod13.z.string().regex(/^\d{8}$/).optional().describe("Report date (YYYYMMDD). Defaults to most recent quarter.")
+});
+function registerFundingProfileTools(server) {
+  server.registerTool(
+    "fdic_analyze_funding_profile",
+    {
+      title: "Analyze Funding Profile",
+      description: `Analyze deposit composition, wholesale funding reliance, and funding risk for an FDIC-insured institution.
+
+Output includes:
+  - Deposit composition (core, brokered, foreign deposit shares)
+  - Wholesale funding reliance and FHLB advances relative to assets
+  - Cash ratio for near-term liquidity
+  - Funding risk signals based on supervisory thresholds
+  - Structured JSON for programmatic consumption
+
+NOTE: This is an analytical tool based on public financial data.`,
+      inputSchema: FundingProfileSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    async (rawParams, extra) => {
+      const params = { ...rawParams, repdte: rawParams.repdte ?? getDefaultReportDate() };
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), ANALYSIS_TIMEOUT_MS);
+      const progressToken = extra._meta?.progressToken;
+      try {
+        const dateError = validateQuarterEndDate(params.repdte, "repdte");
+        if (dateError) {
+          return formatToolError(new Error(dateError));
+        }
+        await sendProgressNotification(server.server, progressToken, 0.1, "Fetching institution profile");
+        const [profileResponse, financialsResponse] = await Promise.all([
+          queryEndpoint(
+            ENDPOINTS.INSTITUTIONS,
+            {
+              filters: `CERT:${params.cert}`,
+              fields: "CERT,NAME,CITY,STALP,ASSET",
+              limit: 1
+            },
+            { signal: controller.signal }
+          ),
+          queryEndpoint(
+            ENDPOINTS.FINANCIALS,
+            {
+              filters: `CERT:${params.cert} AND REPDTE:${params.repdte}`,
+              fields: FUNDING_FIELDS,
+              limit: 1
+            },
+            { signal: controller.signal }
+          )
+        ]);
+        const profileRecords = extractRecords(profileResponse);
+        if (profileRecords.length === 0) {
+          return formatToolError(new Error(`No institution found with CERT number ${params.cert}.`));
+        }
+        const profile = profileRecords[0];
+        const financialRecords = extractRecords(financialsResponse);
+        if (financialRecords.length === 0) {
+          return formatToolError(
+            new Error(
+              `No financial data for CERT ${params.cert} at report date ${params.repdte}. Try an earlier quarter-end date (0331, 0630, 0930, 1231).`
+            )
+          );
+        }
+        const currentFinancials = financialRecords[0];
+        await sendProgressNotification(server.server, progressToken, 0.5, "Computing funding metrics");
+        const metrics = computeFundingMetrics(currentFinancials);
+        const signals = scoreFundingRisks(metrics);
+        await sendProgressNotification(server.server, progressToken, 0.9, "Formatting results");
+        const summary = {
+          institution: {
+            cert: params.cert,
+            name: String(profile.NAME ?? ""),
+            city: String(profile.CITY ?? ""),
+            state: String(profile.STALP ?? ""),
+            total_assets: typeof currentFinancials.ASSET === "number" ? currentFinancials.ASSET : 0,
+            report_date: params.repdte
+          },
+          metrics,
+          signals
+        };
+        const text = truncateIfNeeded(
+          formatFundingSummaryText(summary),
+          CHARACTER_LIMIT
+        );
+        return {
+          content: [{ type: "text", text }],
+          structuredContent: summary
+        };
+      } catch (err) {
+        return formatToolError(err);
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    }
+  );
+}
+
+// src/tools/securitiesPortfolio.ts
+var import_zod14 = require("zod");
+
+// src/tools/shared/securitiesPortfolio.ts
+var SECURITIES_FIELDS = "CERT,REPDTE,ASSET,EQTOT,SC,SCRES";
+function safePct3(num, den) {
+  if (num === null || den === null || den === 0) return null;
+  return num / den * 100;
+}
+function computeSecuritiesMetrics(raw) {
+  const asset = asNumber(raw.ASSET);
+  const eqtot = asNumber(raw.EQTOT);
+  const sc = asNumber(raw.SC);
+  const scres = asNumber(raw.SCRES);
+  return {
+    securities_to_assets: safePct3(sc, asset),
+    securities_to_capital: safePct3(sc, eqtot),
+    mbs_share: safePct3(scres, sc),
+    afs_share: null,
+    // SCAFS not available in FDIC API
+    htm_share: null
+    // SCHTML not available in FDIC API
+  };
+}
+function scoreSecuritiesRisks(m) {
+  const signals = [];
+  if (m.securities_to_assets !== null && m.securities_to_assets > 40) {
+    signals.push({
+      severity: "info",
+      category: "securities_risk",
+      message: `Securities at ${m.securities_to_assets.toFixed(1)}% of assets indicates high concentration in the investment portfolio`
+    });
+  }
+  if (m.securities_to_capital !== null && m.securities_to_capital > 300) {
+    signals.push({
+      severity: "warning",
+      category: "securities_risk",
+      message: `Securities at ${m.securities_to_capital.toFixed(0)}% of capital exceeds 300% threshold, indicating significant portfolio exposure`
+    });
+  }
+  if (m.mbs_share !== null && m.mbs_share > 60) {
+    signals.push({
+      severity: "info",
+      category: "securities_risk",
+      message: `MBS concentration at ${m.mbs_share.toFixed(1)}% of securities portfolio indicates elevated interest rate risk`
+    });
+  }
+  return signals;
+}
+
+// src/tools/securitiesPortfolio.ts
+function fmtPct3(val) {
+  return val !== null ? `${val.toFixed(1)}%` : "n/a";
+}
+function fmtDollarsK3(val) {
+  return val !== null ? `$${Math.round(val).toLocaleString()}K` : "n/a";
+}
+function formatSecuritiesSummaryText(summary) {
+  const parts = [];
+  const { institution: inst, metrics: m, signals } = summary;
+  parts.push("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  parts.push(`  Securities Portfolio Analysis: ${inst.name}`);
+  parts.push(`  ${inst.city}, ${inst.state} | CERT ${inst.cert} | Total Assets: ${fmtDollarsK3(inst.total_assets)}`);
+  parts.push(`  Report Date: ${inst.report_date}`);
+  parts.push("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  parts.push("");
+  parts.push("Portfolio Overview");
+  parts.push("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  parts.push(`  Securities / Assets:      ${fmtPct3(m.securities_to_assets)}`);
+  parts.push(`  Securities / Capital:     ${fmtPct3(m.securities_to_capital)}`);
+  parts.push("");
+  parts.push("Composition");
+  parts.push("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  parts.push(`  MBS Concentration:        ${fmtPct3(m.mbs_share)}`);
+  parts.push(`  AFS Share:                ${fmtPct3(m.afs_share)}`);
+  parts.push(`  HTM Share:                ${fmtPct3(m.htm_share)}`);
+  if (signals.length > 0) {
+    parts.push("");
+    parts.push("\u26A0 Securities Risk Signals");
+    parts.push("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    for (const signal of signals) {
+      parts.push(`  \u2022 ${signal.message}`);
+    }
+  }
+  return parts.join("\n");
+}
+var SecuritiesPortfolioSchema = import_zod14.z.object({
+  cert: import_zod14.z.number().int().positive().describe("FDIC Certificate Number"),
+  repdte: import_zod14.z.string().regex(/^\d{8}$/).optional().describe("Report date (YYYYMMDD). Defaults to most recent quarter.")
+});
+function registerSecuritiesPortfolioTools(server) {
+  server.registerTool(
+    "fdic_analyze_securities_portfolio",
+    {
+      title: "Analyze Securities Portfolio",
+      description: `Analyze securities portfolio size, composition, and concentration risk for an FDIC-insured institution.
+
+Output includes:
+  - Securities relative to total assets and capital
+  - MBS concentration within the securities portfolio
+  - AFS/HTM breakdown (when available)
+  - Risk signals for portfolio concentration and interest rate exposure
+  - Structured JSON for programmatic consumption
+
+NOTE: This is an analytical tool based on public financial data. AFS/HTM breakdown is not currently available from the FDIC API.`,
+      inputSchema: SecuritiesPortfolioSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    async (rawParams, extra) => {
+      const params = { ...rawParams, repdte: rawParams.repdte ?? getDefaultReportDate() };
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), ANALYSIS_TIMEOUT_MS);
+      const progressToken = extra._meta?.progressToken;
+      try {
+        const dateError = validateQuarterEndDate(params.repdte, "repdte");
+        if (dateError) {
+          return formatToolError(new Error(dateError));
+        }
+        await sendProgressNotification(server.server, progressToken, 0.1, "Fetching institution profile");
+        const [profileResponse, financialsResponse] = await Promise.all([
+          queryEndpoint(
+            ENDPOINTS.INSTITUTIONS,
+            {
+              filters: `CERT:${params.cert}`,
+              fields: "CERT,NAME,CITY,STALP,ASSET",
+              limit: 1
+            },
+            { signal: controller.signal }
+          ),
+          queryEndpoint(
+            ENDPOINTS.FINANCIALS,
+            {
+              filters: `CERT:${params.cert} AND REPDTE:${params.repdte}`,
+              fields: SECURITIES_FIELDS,
+              limit: 1
+            },
+            { signal: controller.signal }
+          )
+        ]);
+        const profileRecords = extractRecords(profileResponse);
+        if (profileRecords.length === 0) {
+          return formatToolError(new Error(`No institution found with CERT number ${params.cert}.`));
+        }
+        const profile = profileRecords[0];
+        const financialRecords = extractRecords(financialsResponse);
+        if (financialRecords.length === 0) {
+          return formatToolError(
+            new Error(
+              `No financial data for CERT ${params.cert} at report date ${params.repdte}. Try an earlier quarter-end date (0331, 0630, 0930, 1231).`
+            )
+          );
+        }
+        const currentFinancials = financialRecords[0];
+        await sendProgressNotification(server.server, progressToken, 0.5, "Computing securities metrics");
+        const metrics = computeSecuritiesMetrics(currentFinancials);
+        const signals = scoreSecuritiesRisks(metrics);
+        await sendProgressNotification(server.server, progressToken, 0.9, "Formatting results");
+        const summary = {
+          institution: {
+            cert: params.cert,
+            name: String(profile.NAME ?? ""),
+            city: String(profile.CITY ?? ""),
+            state: String(profile.STALP ?? ""),
+            total_assets: typeof currentFinancials.ASSET === "number" ? currentFinancials.ASSET : 0,
+            report_date: params.repdte
+          },
+          metrics,
+          signals
+        };
+        const text = truncateIfNeeded(
+          formatSecuritiesSummaryText(summary),
+          CHARACTER_LIMIT
+        );
+        return {
+          content: [{ type: "text", text }],
+          structuredContent: summary
+        };
+      } catch (err) {
+        return formatToolError(err);
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    }
+  );
+}
+
+// src/tools/ubprAnalysis.ts
+var import_zod15 = require("zod");
+
+// src/tools/shared/ubprRatios.ts
+var UBPR_FIELDS = "CERT,REPDTE,ASSET,ROA,ROE,ROAPTX,NIMY,EEFFR,INTINC,EINTEXP,NONII,NONIX,NETINC,ELNATRY,LNLSNET,LNRE,LNCI,LNCON,LNAG,LNOTH,DEP,COREDEP,DEPDOM,DEPFOR,BROR,FREPP,IDT1CER,IDT1RWAJR,EQV,EQTOT,LNLSDEPR,DEPDASTR,CHBALR,NPERFV,NCLNLSR,NTLNLSR,LNATRESR,LNRESNCR,SC";
+function safePct4(num, den) {
+  if (num === null || den === null || den === 0) return null;
+  return num / den * 100;
+}
+function growthRate(current, prior) {
+  if (current === null || prior === null || prior === 0) return null;
+  return (current - prior) / prior * 100;
+}
+function computeUbprRatios(raw) {
+  const lnlsnet = asNumber(raw.LNLSNET);
+  const lnre = asNumber(raw.LNRE);
+  const lnci = asNumber(raw.LNCI);
+  const lncon = asNumber(raw.LNCON);
+  const lnag = asNumber(raw.LNAG);
+  const dep = asNumber(raw.DEP);
+  const coredep = asNumber(raw.COREDEP);
+  const asset = asNumber(raw.ASSET);
+  const eqtot = asNumber(raw.EQTOT);
+  return {
+    summary: {
+      roa: asNumber(raw.ROA),
+      roe: asNumber(raw.ROE),
+      nim: asNumber(raw.NIMY),
+      efficiency_ratio: asNumber(raw.EEFFR),
+      pretax_roa: asNumber(raw.ROAPTX)
+    },
+    loan_mix: {
+      re_share: safePct4(lnre, lnlsnet),
+      ci_share: safePct4(lnci, lnlsnet),
+      consumer_share: safePct4(lncon, lnlsnet),
+      ag_share: safePct4(lnag, lnlsnet)
+    },
+    capital: {
+      tier1_leverage: asNumber(raw.IDT1CER),
+      tier1_rbc: asNumber(raw.IDT1RWAJR),
+      equity_ratio: safePct4(eqtot, asset)
+    },
+    liquidity: {
+      loan_to_deposit: safePct4(lnlsnet, dep),
+      core_deposit_ratio: safePct4(coredep, dep),
+      brokered_ratio: asNumber(raw.BROR),
+      cash_ratio: asNumber(raw.CHBALR)
+    }
+  };
+}
+function computeGrowthRates(current, prior) {
+  return {
+    asset_growth: growthRate(asNumber(current.ASSET), asNumber(prior.ASSET)),
+    loan_growth: growthRate(asNumber(current.LNLSNET), asNumber(prior.LNLSNET)),
+    deposit_growth: growthRate(asNumber(current.DEP), asNumber(prior.DEP))
+  };
+}
+
+// src/tools/ubprAnalysis.ts
+function fmtPct4(val) {
+  return val !== null ? `${val.toFixed(2)}%` : "n/a";
+}
+function fmtDollarsK4(val) {
+  return val !== null ? `$${Math.round(val).toLocaleString()}K` : "n/a";
+}
+function formatUbprSummaryText(summary) {
+  const parts = [];
+  const { institution: inst, ratios, growth } = summary;
+  parts.push("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  parts.push(`  UBPR-Equivalent Ratio Analysis: ${inst.name}`);
+  parts.push(`  ${inst.city}, ${inst.state} | CERT ${inst.cert} | Total Assets: ${fmtDollarsK4(inst.total_assets)}`);
+  parts.push(`  Report Date: ${inst.report_date} (vs. year-ago: ${inst.prior_report_date})`);
+  parts.push("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  parts.push("");
+  parts.push("Summary Ratios");
+  parts.push("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  parts.push(`  Return on Assets (ROA):     ${fmtPct4(ratios.summary.roa)}`);
+  parts.push(`  Return on Equity (ROE):     ${fmtPct4(ratios.summary.roe)}`);
+  parts.push(`  Net Interest Margin:        ${fmtPct4(ratios.summary.nim)}`);
+  parts.push(`  Efficiency Ratio:           ${fmtPct4(ratios.summary.efficiency_ratio)}`);
+  parts.push(`  Pretax ROA:                 ${fmtPct4(ratios.summary.pretax_roa)}`);
+  parts.push("");
+  parts.push("Loan Mix");
+  parts.push("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  parts.push(`  Real Estate:   ${fmtPct4(ratios.loan_mix.re_share)}`);
+  parts.push(`  Commercial:    ${fmtPct4(ratios.loan_mix.ci_share)}`);
+  parts.push(`  Consumer:      ${fmtPct4(ratios.loan_mix.consumer_share)}`);
+  parts.push(`  Agricultural:  ${fmtPct4(ratios.loan_mix.ag_share)}`);
+  parts.push("");
+  parts.push("Capital Adequacy");
+  parts.push("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  parts.push(`  Tier 1 Leverage:      ${fmtPct4(ratios.capital.tier1_leverage)}`);
+  parts.push(`  Tier 1 Risk-Based:    ${fmtPct4(ratios.capital.tier1_rbc)}`);
+  parts.push(`  Equity / Assets:      ${fmtPct4(ratios.capital.equity_ratio)}`);
+  parts.push("");
+  parts.push("Liquidity");
+  parts.push("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  parts.push(`  Loans / Deposits:     ${fmtPct4(ratios.liquidity.loan_to_deposit)}`);
+  parts.push(`  Core Deposits / Deposits: ${fmtPct4(ratios.liquidity.core_deposit_ratio)}`);
+  parts.push(`  Brokered Deposits:    ${fmtPct4(ratios.liquidity.brokered_ratio)}`);
+  parts.push(`  Cash / Assets:        ${fmtPct4(ratios.liquidity.cash_ratio)}`);
+  parts.push("");
+  parts.push("Year-over-Year Growth");
+  parts.push("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  parts.push(`  Asset Growth:         ${fmtPct4(growth.asset_growth)}`);
+  parts.push(`  Loan Growth:          ${fmtPct4(growth.loan_growth)}`);
+  parts.push(`  Deposit Growth:       ${fmtPct4(growth.deposit_growth)}`);
+  parts.push("");
+  parts.push("Note: Ratios computed from FDIC Call Report data. These are");
+  parts.push("UBPR-equivalent calculations, not official FFIEC UBPR output.");
+  return parts.join("\n");
+}
+var UbprAnalysisSchema = import_zod15.z.object({
+  cert: import_zod15.z.number().int().positive().describe("FDIC Certificate Number"),
+  repdte: import_zod15.z.string().length(8).optional().describe("Report date (YYYYMMDD). Defaults to most recent quarter.")
+});
+function registerUbprAnalysisTools(server) {
+  server.registerTool(
+    "fdic_ubpr_analysis",
+    {
+      title: "UBPR-Equivalent Ratio Analysis",
+      description: `Compute UBPR-equivalent ratio analysis for an FDIC-insured institution. Includes summary ratios (ROA, ROE, NIM, efficiency), loan mix, capital adequacy, liquidity metrics, and year-over-year growth rates. Ratios are computed from Call Report data and are UBPR-equivalent, not official FFIEC UBPR output.
+
+Output includes:
+  - Summary ratios: ROA, ROE, NIM, efficiency ratio, pretax ROA
+  - Loan mix: real estate, commercial, consumer, agricultural shares
+  - Capital adequacy: Tier 1 leverage, Tier 1 risk-based, equity ratio
+  - Liquidity: loan-to-deposit, core deposit ratio, brokered deposits, cash ratio
+  - Year-over-year growth: assets, loans, deposits
+  - Structured JSON for programmatic consumption
+
+NOTE: This is an analytical tool based on public financial data.`,
+      inputSchema: UbprAnalysisSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    async (rawParams, extra) => {
+      const params = { ...rawParams, repdte: rawParams.repdte ?? getDefaultReportDate() };
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), ANALYSIS_TIMEOUT_MS);
+      const progressToken = extra._meta?.progressToken;
+      try {
+        const dateError = validateQuarterEndDate(params.repdte, "repdte");
+        if (dateError) {
+          return formatToolError(new Error(dateError));
+        }
+        const priorRepdte = getReportDateOneYearPrior(params.repdte);
+        await sendProgressNotification(server.server, progressToken, 0.1, "Fetching institution profile");
+        const [profileResponse, currentResponse, priorResponse] = await Promise.all([
+          queryEndpoint(
+            ENDPOINTS.INSTITUTIONS,
+            {
+              filters: `CERT:${params.cert}`,
+              fields: "CERT,NAME,CITY,STALP,ASSET",
+              limit: 1
+            },
+            { signal: controller.signal }
+          ),
+          queryEndpoint(
+            ENDPOINTS.FINANCIALS,
+            {
+              filters: `CERT:${params.cert} AND REPDTE:${params.repdte}`,
+              fields: UBPR_FIELDS,
+              limit: 1
+            },
+            { signal: controller.signal }
+          ),
+          queryEndpoint(
+            ENDPOINTS.FINANCIALS,
+            {
+              filters: `CERT:${params.cert} AND REPDTE:${priorRepdte}`,
+              fields: UBPR_FIELDS,
+              limit: 1
+            },
+            { signal: controller.signal }
+          )
+        ]);
+        const profileRecords = extractRecords(profileResponse);
+        if (profileRecords.length === 0) {
+          return formatToolError(new Error(`No institution found with CERT number ${params.cert}.`));
+        }
+        const profile = profileRecords[0];
+        const currentRecords = extractRecords(currentResponse);
+        if (currentRecords.length === 0) {
+          return formatToolError(
+            new Error(
+              `No financial data for CERT ${params.cert} at report date ${params.repdte}. Try an earlier quarter-end date (0331, 0630, 0930, 1231).`
+            )
+          );
+        }
+        const currentFinancials = currentRecords[0];
+        await sendProgressNotification(server.server, progressToken, 0.5, "Computing UBPR-equivalent ratios");
+        const ratios = computeUbprRatios(currentFinancials);
+        const priorRecords = extractRecords(priorResponse);
+        const priorFinancials = priorRecords.length > 0 ? priorRecords[0] : {};
+        const growth = computeGrowthRates(currentFinancials, priorFinancials);
+        await sendProgressNotification(server.server, progressToken, 0.9, "Formatting results");
+        const summary = {
+          institution: {
+            cert: params.cert,
+            name: String(profile.NAME ?? ""),
+            city: String(profile.CITY ?? ""),
+            state: String(profile.STALP ?? ""),
+            total_assets: typeof currentFinancials.ASSET === "number" ? currentFinancials.ASSET : 0,
+            report_date: params.repdte,
+            prior_report_date: priorRepdte
+          },
+          ratios,
+          growth,
+          disclaimer: "Ratios computed from FDIC Call Report data. UBPR-equivalent, not official FFIEC output."
+        };
+        const text = truncateIfNeeded(
+          formatUbprSummaryText(summary),
+          CHARACTER_LIMIT
+        );
+        return {
+          content: [{ type: "text", text }],
+          structuredContent: summary
+        };
+      } catch (err) {
+        return formatToolError(err);
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    }
+  );
+}
+
+// src/tools/marketShareAnalysis.ts
+var import_zod16 = require("zod");
+
+// src/tools/shared/marketShare.ts
+function computeMarketShare(branches) {
+  if (branches.length === 0) return [];
+  const byInstitution = /* @__PURE__ */ new Map();
+  for (const branch of branches) {
+    const existing = byInstitution.get(branch.cert);
+    if (existing) {
+      existing.deposits += branch.deposits;
+      existing.branches += 1;
+    } else {
+      byInstitution.set(branch.cert, {
+        name: branch.name,
+        deposits: branch.deposits,
+        branches: 1
+      });
+    }
+  }
+  const totalDeposits = Array.from(byInstitution.values()).reduce(
+    (sum, inst) => sum + inst.deposits,
+    0
+  );
+  const participants = [];
+  for (const [cert, inst] of byInstitution.entries()) {
+    participants.push({
+      cert,
+      name: inst.name,
+      total_deposits: inst.deposits,
+      branch_count: inst.branches,
+      market_share: totalDeposits > 0 ? inst.deposits / totalDeposits * 100 : 0,
+      rank: 0
+      // assigned below
+    });
+  }
+  participants.sort((a, b) => b.total_deposits - a.total_deposits);
+  for (let i = 0; i < participants.length; i++) {
+    participants[i].rank = i + 1;
+  }
+  return participants;
+}
+function computeHHI(shares) {
+  return shares.reduce((sum, s) => sum + s * s, 0);
+}
+function classifyConcentration(hhi) {
+  if (hhi < 1500) return "unconcentrated";
+  if (hhi <= 2500) return "moderately_concentrated";
+  return "highly_concentrated";
+}
+function buildMarketConcentration(participants) {
+  const shares = participants.map((p) => p.market_share);
+  const hhi = computeHHI(shares);
+  return {
+    hhi: Math.round(hhi * 100) / 100,
+    classification: classifyConcentration(hhi),
+    total_deposits: participants.reduce((s, p) => s + p.total_deposits, 0),
+    institution_count: participants.length
+  };
+}
+
+// src/tools/marketShareAnalysis.ts
+var SOD_FIELDS = "CERT,UNINAME,DEPSUMBR,BRNUM,MSANAMEBR,CNTYBR,STALPBR,YEAR";
+var SOD_FETCH_LIMIT = 1e4;
+function fmtNum(val) {
+  return Math.round(val).toLocaleString("en-US");
+}
+function formatMarketShareText(summary) {
+  const parts = [];
+  const { market, concentration } = summary;
+  parts.push("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  parts.push("  Deposit Market Share Analysis");
+  parts.push(`  ${market.name} | ${market.year} SOD Data`);
+  parts.push("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  parts.push("");
+  parts.push("Market Overview");
+  parts.push("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  parts.push(`  Total Market Deposits:  $${fmtNum(concentration.total_deposits)}K`);
+  parts.push(`  Institutions:           ${concentration.institution_count}`);
+  parts.push(
+    `  HHI:                    ${fmtNum(concentration.hhi)} (${concentration.classification.replace(/_/g, " ")})`
+  );
+  if (summary.highlighted_institution) {
+    const h = summary.highlighted_institution;
+    parts.push("");
+    parts.push(
+      `  \u2605 ${h.name} (CERT ${h.cert}): Rank #${h.rank}, ${h.market_share.toFixed(1)}% share, $${fmtNum(h.total_deposits)}K`
+    );
+  }
+  parts.push("");
+  parts.push("Top 20 Institutions");
+  parts.push("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  parts.push(
+    "  Rank  Institution                    Deposits ($K)    Share    Branches"
+  );
+  parts.push(
+    "  \u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500   \u2500\u2500\u2500\u2500\u2500\u2500   \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"
+  );
+  const top = summary.participants.slice(0, 20);
+  for (const p of top) {
+    const rank = String(p.rank).padStart(4);
+    const name = p.name.length > 29 ? p.name.slice(0, 26) + "..." : p.name;
+    const deposits = fmtNum(p.total_deposits).padStart(13);
+    const share = `${p.market_share.toFixed(1)}%`.padStart(6);
+    const branches = String(p.branch_count).padStart(8);
+    parts.push(
+      `  ${rank}   ${name.padEnd(29)}  ${deposits}   ${share}   ${branches}`
+    );
+  }
+  return parts.join("\n");
+}
+function getDefaultSodYear() {
+  return (/* @__PURE__ */ new Date()).getFullYear() - 1;
+}
+var MarketShareInputSchema = import_zod16.z.object({
+  msa: import_zod16.z.string().optional().describe(
+    'MSA name to filter (e.g., "Dallas-Fort Worth-Arlington"). Use MSANAMEBR field.'
+  ),
+  county: import_zod16.z.string().optional().describe('County name (e.g., "Travis"). Requires state.'),
+  state: import_zod16.z.string().length(2).optional().describe(
+    "Two-letter state abbreviation (e.g., TX). Required when using county filter."
+  ),
+  year: import_zod16.z.number().int().min(1994).optional().describe("SOD report year (1994-present). Defaults to most recent."),
+  cert: import_zod16.z.number().int().positive().optional().describe("Highlight a specific institution in the results.")
+});
+function registerMarketShareAnalysisTools(server) {
+  server.registerTool(
+    "fdic_market_share_analysis",
+    {
+      title: "Deposit Market Share Analysis",
+      description: `Analyze deposit market share and concentration for an MSA or county market using FDIC Summary of Deposits (SOD) data.
+
+Computes market share for all institutions in a geographic market, ranks them by deposits, and calculates the Herfindahl-Hirschman Index (HHI) for market concentration analysis per DOJ/FTC merger guidelines.
+
+Output includes:
+  - Market overview with total deposits, institution count, and HHI classification
+  - Optional highlighted institution showing rank and share
+  - Top institutions ranked by deposit market share
+  - Structured JSON for programmatic consumption
+
+Requires at least one of: msa, or county + state.`,
+      inputSchema: MarketShareInputSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    async (rawParams, extra) => {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), ANALYSIS_TIMEOUT_MS);
+      const progressToken = extra._meta?.progressToken;
+      try {
+        if (!rawParams.msa && !rawParams.county) {
+          return formatToolError(
+            new Error(
+              "At least one of 'msa' or 'county' (with 'state') must be provided."
+            )
+          );
+        }
+        if (rawParams.county && !rawParams.state) {
+          return formatToolError(
+            new Error(
+              "'state' is required when using 'county' filter."
+            )
+          );
+        }
+        const year = rawParams.year ?? getDefaultSodYear();
+        let filterStr;
+        let marketName;
+        if (rawParams.msa) {
+          filterStr = `MSANAMEBR:"${rawParams.msa}" AND YEAR:${year}`;
+          marketName = rawParams.msa;
+        } else {
+          filterStr = `CNTYBR:"${rawParams.county}" AND STALPBR:${rawParams.state} AND YEAR:${year}`;
+          marketName = `${rawParams.county} County, ${rawParams.state}`;
+        }
+        await sendProgressNotification(
+          server.server,
+          progressToken,
+          0.1,
+          "Fetching SOD records for market"
+        );
+        const response = await queryEndpoint(
+          ENDPOINTS.SOD,
+          {
+            filters: filterStr,
+            fields: SOD_FIELDS,
+            limit: SOD_FETCH_LIMIT,
+            sort_by: "DEPSUMBR",
+            sort_order: "DESC"
+          },
+          { signal: controller.signal }
+        );
+        const records = extractRecords(response);
+        if (records.length === 0) {
+          return formatToolError(
+            new Error(
+              `No SOD records found for ${marketName} in ${year}. Verify the market name and year.`
+            )
+          );
+        }
+        await sendProgressNotification(
+          server.server,
+          progressToken,
+          0.5,
+          "Computing market shares"
+        );
+        const branches = records.map((r) => ({
+          cert: Number(r.CERT),
+          name: String(r.UNINAME ?? ""),
+          deposits: typeof r.DEPSUMBR === "number" ? r.DEPSUMBR : 0
+        }));
+        const participants = computeMarketShare(branches);
+        const concentration = buildMarketConcentration(participants);
+        await sendProgressNotification(
+          server.server,
+          progressToken,
+          0.8,
+          "Formatting results"
+        );
+        let highlighted;
+        if (rawParams.cert) {
+          const found = participants.find((p) => p.cert === rawParams.cert);
+          if (found) {
+            highlighted = {
+              cert: found.cert,
+              name: found.name,
+              rank: found.rank,
+              market_share: found.market_share,
+              total_deposits: found.total_deposits,
+              branch_count: found.branch_count
+            };
+          }
+        }
+        const summary = {
+          market: { name: marketName, year },
+          concentration,
+          highlighted_institution: highlighted,
+          participants: participants.slice(0, 50)
+        };
+        const text = truncateIfNeeded(formatMarketShareText(summary), CHARACTER_LIMIT);
+        return {
+          content: [{ type: "text", text }],
+          structuredContent: summary
+        };
+      } catch (err) {
+        return formatToolError(err);
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    }
+  );
+}
+
+// src/tools/franchiseFootprint.ts
+var import_zod17 = require("zod");
+var SOD_BRANCH_FIELDS = "CERT,UNINAME,DEPSUMBR,BRNUM,MSANAMEBR,CNTYBR,STALPBR,YEAR";
+var SOD_FETCH_LIMIT2 = 1e4;
+var NON_MSA_LABEL = "Non-MSA / Rural";
+function fmtNum2(val) {
+  return Math.round(val).toLocaleString("en-US");
+}
+function formatFranchiseFootprintText(summary) {
+  const parts = [];
+  const { institution: inst } = summary;
+  parts.push("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  parts.push(`  Franchise Footprint: ${inst.name}`);
+  parts.push(`  CERT ${inst.cert} | ${inst.year} SOD Data`);
+  parts.push("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  parts.push("");
+  parts.push(`  Total Branches: ${summary.summary.total_branches}`);
+  parts.push(`  Total Deposits: $${fmtNum2(summary.summary.total_deposits)}K`);
+  parts.push(`  Markets:        ${summary.summary.market_count}`);
+  parts.push("");
+  parts.push("Market Breakdown");
+  parts.push("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  parts.push(
+    "  Market                           Branches  Deposits ($K)   % of Total"
+  );
+  parts.push(
+    "  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500   \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"
+  );
+  for (const m of summary.markets) {
+    const name = m.market_name.length > 31 ? m.market_name.slice(0, 28) + "..." : m.market_name;
+    const branches = String(m.branch_count).padStart(8);
+    const deposits = fmtNum2(m.total_deposits).padStart(13);
+    const pct = `${m.pct_of_total.toFixed(1)}%`.padStart(10);
+    parts.push(`  ${name.padEnd(31)}  ${branches}  ${deposits}   ${pct}`);
+  }
+  return parts.join("\n");
+}
+function getDefaultSodYear2() {
+  return (/* @__PURE__ */ new Date()).getFullYear() - 1;
+}
+var FranchiseFootprintInputSchema = import_zod17.z.object({
+  cert: import_zod17.z.number().int().positive().describe("FDIC Certificate Number"),
+  year: import_zod17.z.number().int().min(1994).optional().describe("SOD report year. Defaults to most recent.")
+});
+function registerFranchiseFootprintTools(server) {
+  server.registerTool(
+    "fdic_franchise_footprint",
+    {
+      title: "Institution Franchise Footprint",
+      description: `Analyze the geographic franchise footprint of an FDIC-insured institution using Summary of Deposits (SOD) data.
+
+Shows how an institution's branches and deposits are distributed across metropolitan statistical areas (MSAs), providing a market-by-market breakdown of branch count, deposit totals, and percentage of the institution's total deposits.
+
+Output includes:
+  - Total branch count, deposits, and market count
+  - Market-by-market breakdown sorted by deposits
+  - Structured JSON for programmatic consumption
+
+Branches outside MSAs are grouped under "Non-MSA / Rural".`,
+      inputSchema: FranchiseFootprintInputSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    async (rawParams, extra) => {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), ANALYSIS_TIMEOUT_MS);
+      const progressToken = extra._meta?.progressToken;
+      try {
+        const year = rawParams.year ?? getDefaultSodYear2();
+        await sendProgressNotification(
+          server.server,
+          progressToken,
+          0.1,
+          "Fetching institution profile"
+        );
+        const [profileResponse, sodResponse] = await Promise.all([
+          queryEndpoint(
+            ENDPOINTS.INSTITUTIONS,
+            {
+              filters: `CERT:${rawParams.cert}`,
+              fields: "CERT,NAME",
+              limit: 1
+            },
+            { signal: controller.signal }
+          ),
+          queryEndpoint(
+            ENDPOINTS.SOD,
+            {
+              filters: `CERT:${rawParams.cert} AND YEAR:${year}`,
+              fields: SOD_BRANCH_FIELDS,
+              limit: SOD_FETCH_LIMIT2,
+              sort_by: "DEPSUMBR",
+              sort_order: "DESC"
+            },
+            { signal: controller.signal }
+          )
+        ]);
+        const profileRecords = extractRecords(profileResponse);
+        if (profileRecords.length === 0) {
+          return formatToolError(
+            new Error(`No institution found with CERT number ${rawParams.cert}.`)
+          );
+        }
+        const instName = String(profileRecords[0].NAME ?? "");
+        const branchRecords = extractRecords(sodResponse);
+        if (branchRecords.length === 0) {
+          return formatToolError(
+            new Error(
+              `No SOD branch records found for CERT ${rawParams.cert} in ${year}. The institution may not have reported SOD data for this year.`
+            )
+          );
+        }
+        await sendProgressNotification(
+          server.server,
+          progressToken,
+          0.5,
+          "Grouping branches by market"
+        );
+        const byMarket = /* @__PURE__ */ new Map();
+        for (const rec of branchRecords) {
+          const msaName = typeof rec.MSANAMEBR === "string" && rec.MSANAMEBR.trim() !== "" ? rec.MSANAMEBR.trim() : NON_MSA_LABEL;
+          const deposits = typeof rec.DEPSUMBR === "number" ? rec.DEPSUMBR : 0;
+          const existing = byMarket.get(msaName);
+          if (existing) {
+            existing.branches += 1;
+            existing.deposits += deposits;
+          } else {
+            byMarket.set(msaName, { branches: 1, deposits });
+          }
+        }
+        const totalDeposits = Array.from(byMarket.values()).reduce(
+          (s, m) => s + m.deposits,
+          0
+        );
+        const markets = Array.from(
+          byMarket.entries()
+        ).map(([name, data]) => ({
+          market_name: name,
+          branch_count: data.branches,
+          total_deposits: data.deposits,
+          pct_of_total: totalDeposits > 0 ? data.deposits / totalDeposits * 100 : 0
+        }));
+        markets.sort((a, b) => b.total_deposits - a.total_deposits);
+        await sendProgressNotification(
+          server.server,
+          progressToken,
+          0.8,
+          "Formatting results"
+        );
+        const summary = {
+          institution: { cert: rawParams.cert, name: instName, year },
+          summary: {
+            total_branches: branchRecords.length,
+            total_deposits: totalDeposits,
+            market_count: byMarket.size
+          },
+          markets
+        };
+        const text = truncateIfNeeded(
+          formatFranchiseFootprintText(summary),
+          CHARACTER_LIMIT
+        );
+        return {
+          content: [{ type: "text", text }],
+          structuredContent: summary
+        };
+      } catch (err) {
+        return formatToolError(err);
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    }
+  );
+}
+
+// src/tools/holdingCompanyProfile.ts
+var import_zod18 = require("zod");
+
+// src/tools/shared/holdingCompany.ts
+var INDEPENDENT_LABEL = "(Independent)";
+function groupByHoldingCompany(institutions) {
+  const map = /* @__PURE__ */ new Map();
+  for (const inst of institutions) {
+    const key = inst.hc_name ?? INDEPENDENT_LABEL;
+    const group = map.get(key);
+    if (group) {
+      group.push(inst);
+    } else {
+      map.set(key, [inst]);
+    }
+  }
+  const groups = [];
+  for (const [hc_name, subsidiaries] of map) {
+    groups.push({ hc_name, subsidiaries });
+  }
+  groups.sort((a, b) => {
+    const assetsA = a.subsidiaries.reduce((sum, s) => sum + s.total_assets, 0);
+    const assetsB = b.subsidiaries.reduce((sum, s) => sum + s.total_assets, 0);
+    return assetsB - assetsA;
+  });
+  return groups;
+}
+function aggregateSubsidiaryMetrics(subs) {
+  let totalAssets = 0;
+  let totalDeposits = 0;
+  const stateSet = /* @__PURE__ */ new Set();
+  let roaWeightedSum = 0;
+  let roaAssetSum = 0;
+  let equityWeightedSum = 0;
+  let equityAssetSum = 0;
+  for (const sub of subs) {
+    totalAssets += sub.total_assets;
+    totalDeposits += sub.total_deposits;
+    if (sub.state) {
+      stateSet.add(sub.state);
+    }
+    if (sub.roa !== null) {
+      roaWeightedSum += sub.roa * sub.total_assets;
+      roaAssetSum += sub.total_assets;
+    }
+    if (sub.equity_ratio !== null) {
+      equityWeightedSum += sub.equity_ratio * sub.total_assets;
+      equityAssetSum += sub.total_assets;
+    }
+  }
+  const states = Array.from(stateSet).sort();
+  return {
+    total_assets: totalAssets,
+    total_deposits: totalDeposits,
+    subsidiary_count: subs.length,
+    states,
+    weighted_roa: roaAssetSum > 0 ? roaWeightedSum / roaAssetSum : null,
+    weighted_equity_ratio: equityAssetSum > 0 ? equityWeightedSum / equityAssetSum : null
+  };
+}
+function buildSubsidiaryRecord(inst, financials) {
+  return {
+    cert: typeof inst.CERT === "number" ? inst.CERT : 0,
+    name: String(inst.NAME ?? ""),
+    hc_name: inst.NAMHCR ? String(inst.NAMHCR) : null,
+    total_assets: typeof inst.ASSET === "number" ? inst.ASSET : 0,
+    total_deposits: typeof inst.DEP === "number" ? inst.DEP : 0,
+    roa: financials ? asNumber(financials.ROA) : null,
+    equity_ratio: financials ? asNumber(financials.EQV) : null,
+    state: String(inst.STALP ?? ""),
+    active: inst.ACTIVE === 1 || inst.ACTIVE === true
+  };
+}
+
+// src/tools/holdingCompanyProfile.ts
+var INSTITUTION_FIELDS = "CERT,NAME,STALP,CITY,ASSET,DEP,NAMHCR,HCTMULT,ACTIVE,SPECGRP,CHRTAGNT";
+var FINANCIAL_FIELDS2 = "CERT,ROA,EQV";
+function fmtPct5(val) {
+  return val !== null ? `${val.toFixed(2)}%` : "n/a";
+}
+function fmtDollarsK5(val) {
+  return `$${Math.round(val).toLocaleString()}K`;
+}
+function formatHoldingCompanyProfileText(result) {
+  const parts = [];
+  const { holding_company: hc, aggregate: agg, subsidiaries: subs } = result;
+  parts.push("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  parts.push(`  Holding Company Profile: ${hc.name}`);
+  parts.push(`  Subsidiaries: ${hc.subsidiary_count} | States: ${hc.states.join(", ")}`);
+  parts.push("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  parts.push("");
+  parts.push("Consolidated Summary");
+  parts.push("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  parts.push(`  Total Assets:            ${fmtDollarsK5(agg.total_assets)}`);
+  parts.push(`  Total Deposits:          ${fmtDollarsK5(agg.total_deposits)}`);
+  parts.push(`  Weighted ROA:            ${fmtPct5(agg.weighted_roa)}`);
+  parts.push(`  Weighted Equity Ratio:   ${fmtPct5(agg.weighted_equity_ratio)}`);
+  parts.push("");
+  parts.push("Subsidiaries");
+  parts.push("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  parts.push(
+    "  CERT   Name                           State   Assets ($K)    ROA     Equity"
+  );
+  parts.push(
+    "  \u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500   \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500   \u2500\u2500\u2500\u2500\u2500   \u2500\u2500\u2500\u2500\u2500\u2500"
+  );
+  const sorted = [...subs].sort((a, b) => b.total_assets - a.total_assets);
+  for (const sub of sorted) {
+    const cert = String(sub.cert).padEnd(5);
+    const name = sub.name.slice(0, 29).padEnd(29);
+    const state = sub.state.padEnd(5);
+    const assets = Math.round(sub.total_assets).toLocaleString().padStart(11);
+    const roa = sub.roa !== null ? `${sub.roa.toFixed(2)}%`.padStart(6) : "  n/a ";
+    const equity = sub.equity_ratio !== null ? `${sub.equity_ratio.toFixed(1)}%`.padStart(6) : "  n/a ";
+    parts.push(`  ${cert}  ${name}  ${state}   ${assets}   ${roa}   ${equity}`);
+  }
+  return parts.join("\n");
+}
+var HoldingCompanyProfileSchema = import_zod18.z.object({
+  hc_name: import_zod18.z.string().optional().describe(
+    'Holding company name (e.g., "JPMORGAN CHASE & CO"). Uses NAMHCR field.'
+  ),
+  cert: import_zod18.z.number().int().positive().optional().describe(
+    "CERT of any subsidiary \u2014 looks up its holding company, then profiles the entire HC."
+  )
+});
+function registerHoldingCompanyProfileTools(server) {
+  server.registerTool(
+    "fdic_holding_company_profile",
+    {
+      title: "Holding Company Profile",
+      description: `Profile a bank holding company by grouping its FDIC-insured subsidiaries and aggregating financial metrics. Look up by holding company name or by any subsidiary's CERT number.
+
+Output includes:
+  - Consolidated summary with total assets, deposits, and asset-weighted ROA/equity ratio
+  - List of all FDIC-insured subsidiaries with individual metrics
+  - Structured JSON for programmatic consumption
+
+NOTE: This is an analytical tool based on public financial data.`,
+      inputSchema: HoldingCompanyProfileSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    async (rawParams, extra) => {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), ANALYSIS_TIMEOUT_MS);
+      const progressToken = extra._meta?.progressToken;
+      try {
+        if (!rawParams.hc_name && !rawParams.cert) {
+          return formatToolError(
+            new Error(
+              "At least one of hc_name or cert is required. Provide a holding company name or a subsidiary CERT number."
+            )
+          );
+        }
+        let hcName;
+        if (rawParams.cert && !rawParams.hc_name) {
+          await sendProgressNotification(
+            server.server,
+            progressToken,
+            0.1,
+            "Looking up subsidiary to find holding company"
+          );
+          const certResponse = await queryEndpoint(
+            ENDPOINTS.INSTITUTIONS,
+            {
+              filters: `CERT:${rawParams.cert}`,
+              fields: "CERT,NAMHCR",
+              limit: 1
+            },
+            { signal: controller.signal }
+          );
+          const certRecords = extractRecords(certResponse);
+          if (certRecords.length === 0) {
+            return formatToolError(
+              new Error(`No institution found with CERT number ${rawParams.cert}.`)
+            );
+          }
+          const namhcr = certRecords[0].NAMHCR;
+          if (!namhcr || String(namhcr).trim() === "") {
+            return formatToolError(
+              new Error(
+                `Institution with CERT ${rawParams.cert} is not part of a holding company (NAMHCR is empty).`
+              )
+            );
+          }
+          hcName = String(namhcr);
+        } else {
+          hcName = rawParams.hc_name;
+        }
+        await sendProgressNotification(
+          server.server,
+          progressToken,
+          0.2,
+          `Fetching subsidiaries for ${hcName}`
+        );
+        const instResponse = await queryEndpoint(
+          ENDPOINTS.INSTITUTIONS,
+          {
+            filters: `NAMHCR:"${hcName}"`,
+            fields: INSTITUTION_FIELDS,
+            limit: 500,
+            sort_by: "ASSET",
+            sort_order: "DESC"
+          },
+          { signal: controller.signal }
+        );
+        const instRecords = extractRecords(instResponse);
+        if (instRecords.length === 0) {
+          return formatToolError(
+            new Error(
+              `No institutions found for holding company "${hcName}". Check the name spelling (use NAMHCR value from FDIC data).`
+            )
+          );
+        }
+        await sendProgressNotification(
+          server.server,
+          progressToken,
+          0.4,
+          "Fetching financial data for subsidiaries"
+        );
+        const activeCerts = instRecords.filter((r) => r.ACTIVE === 1 || r.ACTIVE === true).map((r) => r.CERT);
+        const repdte = getDefaultReportDate();
+        const financialsMap = /* @__PURE__ */ new Map();
+        if (activeCerts.length > 0) {
+          const certFilterChunks = buildCertFilters(activeCerts);
+          const chunkResults = await mapWithConcurrency(
+            certFilterChunks,
+            MAX_CONCURRENCY,
+            async (certFilter) => {
+              const response = await queryEndpoint(
+                ENDPOINTS.FINANCIALS,
+                {
+                  filters: `(${certFilter}) AND REPDTE:${repdte}`,
+                  fields: FINANCIAL_FIELDS2,
+                  limit: activeCerts.length
+                },
+                { signal: controller.signal }
+              );
+              return extractRecords(response);
+            }
+          );
+          for (const records of chunkResults) {
+            for (const rec of records) {
+              if (typeof rec.CERT === "number") {
+                financialsMap.set(rec.CERT, rec);
+              }
+            }
+          }
+        }
+        await sendProgressNotification(
+          server.server,
+          progressToken,
+          0.7,
+          "Aggregating metrics"
+        );
+        const subsidiaries = instRecords.map((inst) => {
+          const cert = typeof inst.CERT === "number" ? inst.CERT : 0;
+          return buildSubsidiaryRecord(inst, financialsMap.get(cert));
+        });
+        const groups = groupByHoldingCompany(subsidiaries);
+        const targetGroup = groups.find((g) => g.hc_name === hcName);
+        const targetSubs = targetGroup ? targetGroup.subsidiaries : subsidiaries;
+        const aggregate = aggregateSubsidiaryMetrics(targetSubs);
+        await sendProgressNotification(
+          server.server,
+          progressToken,
+          0.9,
+          "Formatting results"
+        );
+        const profileResult = {
+          holding_company: {
+            name: hcName,
+            subsidiary_count: aggregate.subsidiary_count,
+            states: aggregate.states
+          },
+          aggregate,
+          subsidiaries: targetSubs.map((s) => ({
+            cert: s.cert,
+            name: s.name,
+            state: s.state,
+            total_assets: s.total_assets,
+            total_deposits: s.total_deposits,
+            roa: s.roa,
+            equity_ratio: s.equity_ratio,
+            active: s.active
+          }))
+        };
+        const text = truncateIfNeeded(
+          formatHoldingCompanyProfileText(profileResult),
+          CHARACTER_LIMIT
+        );
+        return {
+          content: [{ type: "text", text }],
+          structuredContent: profileResult
+        };
+      } catch (err) {
+        return formatToolError(err);
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    }
+  );
+}
+
+// src/tools/regionalContext.ts
+var import_zod19 = require("zod");
+
+// src/services/fredClient.ts
+var import_axios2 = __toESM(require("axios"));
+var FRED_BASE_URL = "https://api.stlouisfed.org/fred";
+function buildFredUrl(seriesId, opts) {
+  const params = new URLSearchParams({
+    series_id: seriesId,
+    observation_start: opts.start,
+    observation_end: opts.end,
+    file_type: "json"
+  });
+  if (opts.apiKey) {
+    params.set("api_key", opts.apiKey);
+  }
+  return `${FRED_BASE_URL}/series/observations?${params.toString()}`;
+}
+function parseFredResponse(raw) {
+  if (typeof raw !== "object" || raw === null || !("observations" in raw) || !Array.isArray(raw.observations)) {
+    return [];
+  }
+  const observations = raw.observations;
+  const results = [];
+  for (const obs of observations) {
+    if (typeof obs !== "object" || obs === null) continue;
+    const entry = obs;
+    const date = entry.date;
+    const rawValue = entry.value;
+    if (typeof date !== "string" || typeof rawValue !== "string") continue;
+    if (rawValue === ".") continue;
+    const numValue = Number.parseFloat(rawValue);
+    if (Number.isNaN(numValue)) continue;
+    results.push({ date, value: numValue });
+  }
+  return results;
+}
+async function fetchFredSeries(seriesId, start, end) {
+  const apiKey = process.env.FRED_API_KEY;
+  const url = buildFredUrl(seriesId, { start, end, apiKey });
+  const response = await import_axios2.default.get(url, {
+    timeout: 15e3,
+    headers: {
+      Accept: "application/json",
+      "User-Agent": `fdic-mcp-server/${VERSION}`
+    }
+  });
+  return parseFredResponse(response.data);
+}
+function stateFredSeries(state) {
+  const s = state.toUpperCase();
+  return {
+    unemployment: `${s}UR`,
+    gdp: `${s}NGSP`
+  };
+}
+
+// src/tools/shared/regionalContext.ts
+function lastN(arr, n) {
+  return arr.slice(Math.max(0, arr.length - n));
+}
+function latestValue(obs) {
+  if (obs.length === 0) return null;
+  return obs[obs.length - 1].value;
+}
+function assessMacroContext(inputs) {
+  const stateUnemp = inputs.state_unemployment;
+  const natUnemp = inputs.national_unemployment;
+  const fedFunds = inputs.fed_funds;
+  const latestStateUnemp = latestValue(stateUnemp);
+  const latestNatUnemp = latestValue(natUnemp);
+  const latestFedFunds = latestValue(fedFunds);
+  let unemployment_trend = "stable";
+  const recentState = lastN(stateUnemp, 3);
+  if (recentState.length >= 2) {
+    const earliest = recentState[0].value;
+    const latest = recentState[recentState.length - 1].value;
+    const diff = latest - earliest;
+    if (diff > 0.3) unemployment_trend = "rising";
+    else if (diff < -0.3) unemployment_trend = "falling";
+  }
+  let state_vs_national_unemployment = "at_parity";
+  if (latestStateUnemp !== null && latestNatUnemp !== null) {
+    const gap = latestStateUnemp - latestNatUnemp;
+    if (gap > 0.3) state_vs_national_unemployment = "above";
+    else if (gap < -0.3) state_vs_national_unemployment = "below";
+  }
+  let rate_environment = "moderate";
+  if (latestFedFunds !== null) {
+    if (latestFedFunds < 2) rate_environment = "low";
+    else if (latestFedFunds > 4) rate_environment = "elevated";
+  }
+  const narrative = buildNarrative({
+    latestStateUnemp,
+    latestNatUnemp,
+    latestFedFunds,
+    unemployment_trend,
+    state_vs_national_unemployment,
+    rate_environment
+  });
+  return {
+    unemployment_trend,
+    state_vs_national_unemployment,
+    rate_environment,
+    latest_state_unemployment: latestStateUnemp,
+    latest_national_unemployment: latestNatUnemp,
+    latest_fed_funds: latestFedFunds,
+    narrative
+  };
+}
+function buildNarrative(params) {
+  const {
+    latestStateUnemp,
+    latestNatUnemp,
+    latestFedFunds,
+    unemployment_trend,
+    state_vs_national_unemployment,
+    rate_environment
+  } = params;
+  if (latestStateUnemp === null && latestNatUnemp === null && latestFedFunds === null) {
+    return "Economic data is unavailable. Consider manually reviewing state unemployment trends, federal funds rate environment, and regional housing and employment conditions.";
+  }
+  const parts = [];
+  if (latestStateUnemp !== null) {
+    let sentence = `The state unemployment rate is ${latestStateUnemp.toFixed(1)}%`;
+    if (latestNatUnemp !== null) {
+      const compWord = state_vs_national_unemployment === "above" ? "above" : state_vs_national_unemployment === "below" ? "below" : "in line with";
+      sentence += `, ${compWord} the national rate of ${latestNatUnemp.toFixed(1)}%`;
+    }
+    const trendWord = unemployment_trend === "rising" ? " and rising over the past three quarters" : unemployment_trend === "falling" ? " and falling over the past three quarters" : " and stable over the past three quarters";
+    sentence += `${trendWord}.`;
+    parts.push(sentence);
+  }
+  if (latestFedFunds !== null) {
+    const envWord = rate_environment === "low" ? "a low" : rate_environment === "elevated" ? "an elevated" : "a moderate";
+    let impact = rate_environment === "elevated" ? "which may pressure bank net interest margins and borrower repayment capacity" : rate_environment === "low" ? "which supports borrower affordability but may compress bank net interest margins" : "which provides a balanced environment for bank lending and deposit pricing";
+    parts.push(
+      `The federal funds rate at ${latestFedFunds.toFixed(2)}% indicates ${envWord} rate environment, ${impact}.`
+    );
+  }
+  return parts.join(" ");
+}
+
+// src/tools/regionalContext.ts
+function fdicToFredDate(yyyymmdd) {
+  return `${yyyymmdd.slice(0, 4)}-${yyyymmdd.slice(4, 6)}-${yyyymmdd.slice(6, 8)}`;
+}
+function twoYearsBefore(yyyymmdd) {
+  const year = Number.parseInt(yyyymmdd.slice(0, 4), 10);
+  return `${year - 2}-${yyyymmdd.slice(4, 6)}-${yyyymmdd.slice(6, 8)}`;
+}
+function fmtVal(val, suffix = "%") {
+  return val !== null ? `${val.toFixed(2)}${suffix}` : "n/a";
+}
+function trendLabel(trend) {
+  return trend === "rising" ? "rising" : trend === "falling" ? "falling" : "stable";
+}
+function comparisonLabel(comp) {
+  return comp === "above" ? "above national" : comp === "below" ? "below national" : "at parity with national";
+}
+function envLabel(env) {
+  return env;
+}
+function formatRegionalContextText(summary) {
+  const parts = [];
+  if (!summary.fred_available) {
+    parts.push(`Regional Economic Context: ${summary.state}`);
+    parts.push("");
+    parts.push(
+      "\u26A0 FRED API data unavailable. Set FRED_API_KEY environment variable"
+    );
+    parts.push("for reliable access to economic indicators.");
+    parts.push("");
+    parts.push("Without economic context, consider manually reviewing:");
+    parts.push("  \u2022 State unemployment trends");
+    parts.push("  \u2022 Federal funds rate environment");
+    parts.push("  \u2022 Regional housing and employment conditions");
+    return parts.join("\n");
+  }
+  const ctx = summary.context;
+  parts.push("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  parts.push(`  Regional Economic Context: ${summary.state}`);
+  if (summary.institution) {
+    parts.push(`  ${summary.institution.name}`);
+  }
+  parts.push(`  Data Period: ${summary.date_range.start} to ${summary.date_range.end}`);
+  parts.push("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  parts.push("");
+  parts.push("Economic Indicators");
+  parts.push("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  parts.push(`  State Unemployment:     ${fmtVal(ctx.latest_state_unemployment)} (${trendLabel(ctx.unemployment_trend)})`);
+  parts.push(`  National Unemployment:  ${fmtVal(ctx.latest_national_unemployment)} (state is ${comparisonLabel(ctx.state_vs_national_unemployment)})`);
+  parts.push(`  Federal Funds Rate:     ${fmtVal(ctx.latest_fed_funds)} (${envLabel(ctx.rate_environment)})`);
+  parts.push("");
+  parts.push("Assessment");
+  parts.push("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  parts.push(ctx.narrative);
+  parts.push("");
+  parts.push("Note: Economic data from FRED (Federal Reserve Economic Data).");
+  return parts.join("\n");
+}
+var RegionalContextSchema = import_zod19.z.object({
+  cert: import_zod19.z.number().int().positive().optional().describe(
+    "FDIC Certificate Number \u2014 auto-detects state from institution record."
+  ),
+  state: import_zod19.z.string().length(2).optional().describe(
+    "Two-letter state abbreviation (e.g., TX). Alternative to cert-based lookup."
+  ),
+  repdte: import_zod19.z.string().regex(/^\d{8}$/).optional().describe(
+    "Reference report date (YYYYMMDD). FRED data fetched for 2 years before this date."
+  )
+});
+function registerRegionalContextTools(server) {
+  server.registerTool(
+    "fdic_regional_context",
+    {
+      title: "Regional Economic Context",
+      description: `Overlay macro/regional economic data on a bank's geographic context. Uses FRED (Federal Reserve Economic Data) for state unemployment, national unemployment, and federal funds rate. Provides trend analysis and narrative context for bank performance assessment. Gracefully degrades if FRED API is unavailable.
+
+Output includes:
+  - State and national unemployment rates with trend analysis
+  - Federal funds rate and rate environment classification
+  - Narrative assessment of macro conditions for bank performance
+  - Structured JSON for programmatic consumption
+
+NOTE: Requires FRED_API_KEY environment variable for reliable data access. Degrades gracefully without it.`,
+      inputSchema: RegionalContextSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    async (rawParams, extra) => {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), ANALYSIS_TIMEOUT_MS);
+      const progressToken = extra._meta?.progressToken;
+      try {
+        if (!rawParams.cert && !rawParams.state) {
+          return formatToolError(
+            new Error(
+              "At least one of 'cert' or 'state' is required. Provide a CERT number to auto-detect the state, or a two-letter state abbreviation directly."
+            )
+          );
+        }
+        const repdte = rawParams.repdte ?? getDefaultReportDate();
+        await sendProgressNotification(
+          server.server,
+          progressToken,
+          0.1,
+          "Resolving state"
+        );
+        let state;
+        let institution;
+        if (rawParams.cert) {
+          const profileResponse = await queryEndpoint(
+            ENDPOINTS.INSTITUTIONS,
+            {
+              filters: `CERT:${rawParams.cert}`,
+              fields: "CERT,NAME,STALP",
+              limit: 1
+            },
+            { signal: controller.signal }
+          );
+          const records = extractRecords(profileResponse);
+          if (records.length === 0) {
+            return formatToolError(
+              new Error(
+                `No institution found with CERT number ${rawParams.cert}.`
+              )
+            );
+          }
+          const profile = records[0];
+          state = String(profile.STALP ?? "").toUpperCase();
+          institution = {
+            cert: rawParams.cert,
+            name: String(profile.NAME ?? "")
+          };
+          if (!state || state.length !== 2) {
+            return formatToolError(
+              new Error(
+                `Could not determine state for CERT ${rawParams.cert}. Try providing the 'state' parameter directly.`
+              )
+            );
+          }
+        } else {
+          state = rawParams.state.toUpperCase();
+        }
+        const endDate = fdicToFredDate(repdte);
+        const startDate = twoYearsBefore(repdte);
+        await sendProgressNotification(
+          server.server,
+          progressToken,
+          0.3,
+          "Fetching FRED economic data"
+        );
+        const series = stateFredSeries(state);
+        const [stateUnempResult, natUnempResult, fedFundsResult] = await Promise.allSettled([
+          fetchFredSeries(series.unemployment, startDate, endDate),
+          fetchFredSeries("UNRATE", startDate, endDate),
+          fetchFredSeries("FEDFUNDS", startDate, endDate)
+        ]);
+        const stateUnemp = stateUnempResult.status === "fulfilled" ? stateUnempResult.value : [];
+        const natUnemp = natUnempResult.status === "fulfilled" ? natUnempResult.value : [];
+        const fedFunds = fedFundsResult.status === "fulfilled" ? fedFundsResult.value : [];
+        const allFailed = stateUnempResult.status === "rejected" && natUnempResult.status === "rejected" && fedFundsResult.status === "rejected";
+        if (allFailed) {
+          const summary2 = {
+            state,
+            institution,
+            date_range: { start: startDate, end: endDate },
+            context: {
+              unemployment_trend: "stable",
+              state_vs_national_unemployment: "at_parity",
+              rate_environment: "moderate",
+              latest_state_unemployment: null,
+              latest_national_unemployment: null,
+              latest_fed_funds: null,
+              narrative: "Economic data is unavailable. Consider manually reviewing state unemployment trends, federal funds rate environment, and regional housing and employment conditions."
+            },
+            fred_available: false
+          };
+          const text2 = formatRegionalContextText(summary2);
+          return {
+            content: [{ type: "text", text: text2 }],
+            structuredContent: summary2
+          };
+        }
+        await sendProgressNotification(
+          server.server,
+          progressToken,
+          0.7,
+          "Computing macro context"
+        );
+        const context = assessMacroContext({
+          state_unemployment: stateUnemp,
+          national_unemployment: natUnemp,
+          fed_funds: fedFunds
+        });
+        const summary = {
+          state,
+          institution,
+          date_range: { start: startDate, end: endDate },
+          context,
+          fred_available: true
+        };
+        const text = truncateIfNeeded(
+          formatRegionalContextText(summary),
+          CHARACTER_LIMIT
+        );
+        return {
+          content: [{ type: "text", text }],
+          structuredContent: summary
+        };
+      } catch (err) {
+        return formatToolError(err);
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    }
+  );
+}
+
 // src/resources/schemaResources.ts
 var RESOURCE_SCHEME = "fdic";
 var INDEX_URI = `${RESOURCE_SCHEME}://schemas/index`;
@@ -34436,6 +37443,17 @@ function createServer() {
   registerDemographicsTools(server);
   registerAnalysisTools(server);
   registerPeerGroupTools(server);
+  registerBankHealthTools(server);
+  registerPeerHealthTools(server);
+  registerRiskSignalTools(server);
+  registerCreditConcentrationTools(server);
+  registerFundingProfileTools(server);
+  registerSecuritiesPortfolioTools(server);
+  registerUbprAnalysisTools(server);
+  registerMarketShareAnalysisTools(server);
+  registerFranchiseFootprintTools(server);
+  registerHoldingCompanyProfileTools(server);
+  registerRegionalContextTools(server);
   registerSchemaResources(server);
   return server;
 }