@pipeworx/mcp-bankruptcy 0.1.0

package/.pipeworx-staged-ok

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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mojibake Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,166 @@
+# Bankruptcy — US business bankruptcy filings
+
+Business bankruptcy filings from US federal bankruptcy courts: **1.55 million
+filings**, searchable by company name, court and date. No API key.
+
+Part of [Pipeworx](https://pipeworx.io) — an MCP gateway connecting AI agents to 1663+ live data sources.
+
+## Auth
+
+None.
+
+## What this is, and what it is not
+
+This is **docket metadata**: that a case exists, who filed, in which court, when
+it was filed, when it terminated, and which judge was assigned. It contains
+**no filings** — no petitions, schedules, motions or orders. Those live in
+RECAP, a separate corpus that is not keyless.
+
+An agent that has this data knows a company filed. It does not know what the
+company said.
+
+## Consumer bankruptcy is deliberately excluded
+
+Of CourtListener's 71,677,647 dockets, **35,312,051 are individual bankruptcy
+filings** — half the corpus. They carry no business signal and are PII-adjacent,
+so they are excluded.
+
+The docket export has **no chapter column**, so business and consumer are
+separated by a legal-entity-suffix test on the debtor name (`Inc`, `LLC`,
+`Corp`, `Holdings`, `Construction`, and so on), applied only inside bankruptcy
+courts. Two consequences worth knowing before relying on a negative result:
+
+- **A sole proprietorship filing under a personal name will not appear here.**
+- "No filings found" means "no *business* filing matched", never "this entity
+  has never filed".
+
+## Tools
+
+| Tool | Returns |
+|---|---|
+| `bankruptcy_search` | Filings matching a company name, with court, dates and judge |
+| `bankruptcy_recent` | Recent filings, newest first, optionally one court |
+
+Court ids follow CourtListener's convention: `nysb` (S.D.N.Y. Bankruptcy),
+`deb` (Delaware), `txsb` (S.D. Tex.), `cacb` (C.D. Cal.), `ilnb` (N.D. Ill.).
+
+## Caveats
+
+- **Quarterly snapshot.** Every response carries `snapshot_date`. Anything filed
+  after it is not here.
+- **`date_terminated` is 78.3% filled**, so a missing termination date means
+  *not recorded*, never *still open*. Responses say this on every row.
+- **`nature_of_suit` is sparse** (14.8% corpus-wide) and cannot be relied on to
+  filter by case type.
+- Case names are as the court recorded them, including abbreviations and
+  inconsistent entity suffixes. Search matches substrings for that reason.
+
+## Attribution
+
+Data is CourtListener / Free Law Project, published under the Public Domain
+Mark. Free Law Project funds and maintains the corpus. If this pack is useful
+to you, <https://free.law/donate/> is where that goes.
+
+## Quick Start
+
+Add to your MCP client (Claude Desktop, Cursor, Windsurf, etc.):
+
+```json
+{
+  "mcpServers": {
+    "bankruptcy": {
+      "url": "https://gateway.pipeworx.io/bankruptcy/mcp"
+    }
+  }
+}
+```
+
+### What this endpoint actually serves
+
+`tools/list` at `https://gateway.pipeworx.io/bankruptcy/mcp` returns the tools in the table
+above **plus the shared Pipeworx meta-tools** — `ask_pipeworx`,
+`discover_tools`, `search_within`, `remember`/`recall` and the rest of the
+gateway-wide set. So the tool count you see is larger than this table: a
+single-pack endpoint currently lists roughly 30 shared tools alongside the
+pack's own. The connection's `initialize` response states its exact scope, and
+is the authoritative answer for a given day.
+
+This is deliberate, not multiplexing by accident. The meta-tools are what let a
+scoped connection answer a question this pack does not cover — via
+`ask_pipeworx`, which routes across the whole catalog — without you adding a
+second MCP server. There is currently no way to mount a pack endpoint without
+them; if the extra schemas cost you more context than the routing is worth,
+connect to the full gateway once rather than to several pack endpoints.
+
+Or connect to the full Pipeworx gateway to get every pack's tools listed
+directly, instead of just this one's:
+
+```json
+{
+  "mcpServers": {
+    "pipeworx": {
+      "url": "https://gateway.pipeworx.io/mcp"
+    }
+  }
+}
+```
+
+Both URLs reach the same gateway and the same 1663+ data sources. The
+only difference is which pack's tools are listed **directly**; `ask_pipeworx`
+reaches all of them from either one.
+
+## No MCP client? Call it over HTTP
+
+```bash
+curl -X POST https://gateway.pipeworx.io/v1/tools/bankruptcy_search \
+  -H 'Content-Type: application/json' \
+  -d '{"company":"Kmart","limit":5}'
+```
+
+No account needed for the first calls. Inspect any tool: `GET https://gateway.pipeworx.io/v1/tools/bankruptcy_search`. Find one: `POST https://gateway.pipeworx.io/v1/tools/search_packs` with `{"query":"..."}`.
+
+## Standalone (no gateway account)
+
+This package also runs as a local stdio MCP server — no Pipeworx account, no
+gateway round-trip:
+
+```json
+{
+  "mcpServers": {
+    "bankruptcy": {
+      "command": "npx",
+      "args": ["-y", "@pipeworx/mcp-bankruptcy"]
+    }
+  }
+}
+```
+
+Or run it directly to confirm it starts:
+
+```bash
+npx -y @pipeworx/mcp-bankruptcy
+```
+
+It speaks MCP over stdin/stdout and answers `initialize`/`tools/list`/`tools/call`
+for **only** this pack's tools — none of the shared meta-tools the gateway
+connection above adds. Same source, same tools, no ask_pipeworx routing.
+
+## Using with ask_pipeworx
+
+Instead of calling tools directly, you can ask questions in plain English —
+this works on the pack endpoint above as well as on the full gateway:
+
+```
+ask_pipeworx({ question: "your question about Bankruptcy data" })
+```
+
+The gateway picks the right tool and fills the arguments automatically.
+
+## More
+
+- [Docs and guides](https://pipeworx.io/docs)
+- [pipeworx.io](https://pipeworx.io)
+
+## License
+
+MIT

package/bin/cli.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+//
+// Entry point for `npx @pipeworx/mcp-<slug>`.
+//
+// Packs ship as raw TypeScript (no build step — see publish-pack.sh for why:
+// tsx sidesteps every extensionless-import / bare-JSON-import edge case a
+// per-pack tsc build would have to solve one pack at a time). This file
+// registers tsx's ESM loader programmatically, then hands off to src/server.ts,
+// which wraps the pack's {tools, callTool} export in a stdio MCP server.
+//
+// Copied verbatim into every published pack repo by scripts/publish-pack.sh —
+// edit this file, not a per-pack copy.
+import { register } from 'tsx/esm/api';
+
+register();
+
+await import('../src/server.ts');

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@pipeworx/mcp-bankruptcy",
+  "version": "0.1.0",
+  "description": "Business bankruptcy filings — US federal bankruptcy courts.",
+  "type": "module",
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "bin": {
+    "mcp-bankruptcy": "bin/cli.js"
+  },
+  "keywords": ["mcp", "mcp-server", "model-context-protocol", "pipeworx", "bankruptcy"],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pipeworx-io/mcp-bankruptcy.git"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "tsx": "^4.19.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3",
+    "@cloudflare/workers-types": "^4.20260405.1"
+  }
+}

package/server.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "io.github.pipeworx-io/bankruptcy",
+  "title": "Bankruptcy",
+  "description": "Business bankruptcy filings — US federal bankruptcy courts.",
+  "version": "0.1.0",
+  "websiteUrl": "https://pipeworx.io/packs/bankruptcy",
+  "repository": {
+    "url": "https://github.com/pipeworx-io/mcp-bankruptcy",
+    "source": "github"
+  },
+  "remotes": [
+    {
+      "type": "streamable-http",
+      "url": "https://gateway.pipeworx.io/bankruptcy/mcp"
+    }
+  ]
+}

package/src/index.ts

@@ -0,0 +1,373 @@
+interface McpToolDefinition {
+  name: string;
+  description: string;
+  /** Human-facing one-liner (fleet #1967). Optional; consumers fall back to
+   *  description. Kept in step with shared/src/types.ts — scripts/lib/
+   *  check-inlined-types.mjs reports drift at publish time. */
+  summary?: string;
+  inputSchema: {
+    type: 'object';
+    properties: Record<string, unknown>;
+    required?: string[];
+    anyOf?: Array<{ required: string[] }>;
+    oneOf?: Array<{ required: string[] }>;
+    allOf?: Array<{ required: string[] }>;
+  };
+  outputSchema?: Record<string, unknown>;
+}
+
+interface McpToolExport {
+  tools: McpToolDefinition[];
+  callTool: (name: string, args: Record<string, unknown>) => Promise<unknown>;
+  meter?: { credits: number };
+  cost?: Record<string, unknown>;
+  provider?: string;
+}
+
+/**
+ * Shared query layer for CourtListener docket data.
+ *
+ * Four packs — bankruptcy, federal-criminal, federal-civil, federal-appellate —
+ * read the SAME table with different filters. They are separate packs because
+ * routing is embedding cosine over tool descriptions, and four descriptions
+ * tuned to four questions match far better than one generic "search dockets".
+ * They share one table because splitting the storage would quadruple the
+ * operational surface and the bill to buy nothing.
+ *
+ * This lives in shared rather than being copied four times, so a fix to the
+ * query shape lands once. publish-pack.sh inlines it when a pack ships
+ * standalone.
+ *
+ * Data: 36.4M dockets, consumer bankruptcy excluded. A docket records that a
+ * case EXISTS — parties, court, dates, judge. It contains none of the filings;
+ * those are RECAP, which is a separate and non-keyless corpus. Any tool built
+ * on this must not imply otherwise.
+ */
+
+interface DocketMirror {
+  url: string;
+  key: string;
+}
+
+interface DocketRow {
+  id: number;
+  case_name: string | null;
+  case_name_full: string | null;
+  docket_number: string | null;
+  court_id: string;
+  court_class: string;
+  is_criminal: boolean;
+  is_business_bankruptcy: boolean;
+  date_filed: string | null;
+  date_terminated: string | null;
+  date_last_filing: string | null;
+  cause: string | null;
+  nature_of_suit: string | null;
+  jurisdiction_type: string | null;
+  assigned_to_str: string | null;
+  pacer_case_id: string | null;
+  snapshot_date: string;
+}
+
+function docketMirror(args: Record<string, unknown>): DocketMirror | null {
+  const url = (args._supabaseUrl as string | undefined)?.trim();
+  const key = (args._supabaseKey as string | undefined)?.trim();
+  return url && key ? { url, key } : null;
+}
+
+function docketUnavailable(tool: string) {
+  return {
+    found: false,
+    reason: 'mirror_unavailable',
+    message: `${tool} is not reachable from this deployment.`,
+    hint: 'Case law (opinions, full text) is served by the court-listener pack and is unaffected.',
+  };
+}
+
+/** Present a docket without implying we hold the filings. */
+function shapeDocket(d: DocketRow) {
+  return {
+    docket_id: d.id,
+    case_name: d.case_name,
+    case_name_full: d.case_name_full,
+    docket_number: d.docket_number,
+    court: d.court_id,
+    court_class: d.court_class,
+    date_filed: d.date_filed,
+    date_terminated: d.date_terminated,
+    // Absence is not closure: date_terminated is 78.3% filled, so a null means
+    // "not recorded", never "still open". Stating that on the row keeps a
+    // caller from reading an open case out of a missing field.
+    status: d.date_terminated ? 'terminated' : 'no termination date recorded',
+    date_last_filing: d.date_last_filing,
+    cause: d.cause,
+    nature_of_suit: d.nature_of_suit,
+    assigned_judge: d.assigned_to_str,
+    pacer_case_id: d.pacer_case_id,
+    courtlistener_url: `https://www.courtlistener.com/docket/${d.id}/`,
+  };
+}
+
+/**
+ * Query the docket mirror.
+ *
+ * Throws on failure rather than returning an empty array. The first version
+ * swallowed every error into [], which meant a pack pointed at the WRONG
+ * DATABASE reported "no dockets matched" — indistinguishable from a genuine
+ * miss, and the caller would have believed it. An empty result must mean the
+ * data is not there, never that we could not ask.
+ */
+async function query(m: DocketMirror, qs: string): Promise<DocketRow[]> {
+  const res = await fetch(`${m.url}/rest/v1/courtlistener_dockets?${qs}`, {
+    headers: { apikey: m.key, Authorization: `Bearer ${m.key}` },
+  });
+  if (!res.ok) {
+    const body = (await res.text()).slice(0, 200);
+    throw new Error(
+      `Docket query failed (HTTP ${res.status}) against ${m.url.replace(/https?:\/\//, '').split('.')[0]}: ${body}`,
+    );
+  }
+  return (await res.json()) as DocketRow[];
+}
+
+interface DocketSearch {
+  party?: string;
+  court?: string;
+  /**
+   * Filter for real on both paths: parameters to search_dockets_by_name on the
+   * party path (since migration 080), PostgREST filters on the browse path.
+   * They used to be a client-side trim of the page the RPC had already cut to
+   * `limit`, which quietly returned fewer rows than asked for and gave the
+   * planner nothing to work with. The tool schemas describe them as filters;
+   * keep them honest if this ever changes.
+   */
+  filedAfter?: string;
+  filedBefore?: string;
+  limit?: number;
+}
+
+/**
+ * Search dockets within one court class.
+ *
+ * Party match is a name substring rather than full-text: docket case names are
+ * short and adversarial ("Acme Corp v. Smith"), so a caller searching one party
+ * needs to match a fragment, which tsquery does badly and ilike does well.
+ */
+async function searchDockets(
+  m: DocketMirror,
+  filters: { court_class?: string; is_criminal?: boolean; is_business_bankruptcy?: boolean },
+  s: DocketSearch,
+) {
+  const limit = Math.min(50, Math.max(1, s.limit ?? 10));
+
+  const fetchRows = async (filedAfter?: string, filedBefore?: string): Promise<DocketRow[]> => {
+  if (s.party) {
+    // Name search goes through the RPC, never a PostgREST ilike filter. An
+    // ilike scan over 36M rows exceeds the 8s statement timeout — which the
+    // packs reported as "no filings found" until this layer was made to throw.
+    // The RPC matches the expression the FTS index is built on; PostgREST's own
+    // fts operator generates a different one that the planner ignores.
+    return rpc(m, {
+      q: s.party.replace(/[*,()]/g, ' ').trim(),
+      p_court_class: filters.court_class ?? null,
+      p_is_criminal: filters.is_criminal ?? null,
+      p_business_bk: filters.is_business_bankruptcy ?? null,
+      p_court: s.court ?? null,
+      // The dates go to the RPC now, and did not before. Trimming them here, on
+      // rows the database had ALREADY cut to `limit`, meant a date-bounded
+      // search silently returned a subset of what was asked for: ask for 10
+      // dockets filed after 2020 and you got however many of the newest 10
+      // happened to qualify, with nothing in the response saying the rest had
+      // been dropped. It also denied the planner its one selective predicate.
+      // See migration 080.
+      p_filed_after: filedAfter ?? null,
+      p_filed_before: filedBefore ?? null,
+      lim: limit,
+    });
+  } else {
+    const parts: string[] = ['select=*'];
+    if (filters.court_class) parts.push(`court_class=eq.${filters.court_class}`);
+    if (filters.is_criminal !== undefined) parts.push(`is_criminal=is.${filters.is_criminal}`);
+    if (filters.is_business_bankruptcy !== undefined) {
+      parts.push(`is_business_bankruptcy=is.${filters.is_business_bankruptcy}`);
+    }
+    if (s.court) parts.push(`court_id=eq.${encodeURIComponent(s.court)}`);
+    if (filedAfter) parts.push(`date_filed=gte.${filedAfter}`);
+    if (filedBefore) parts.push(`date_filed=lte.${filedBefore}`);
+    parts.push('order=date_filed.desc.nullslast');
+    parts.push(`limit=${limit}`);
+    return query(m, parts.join('&'));
+  }
+  };
+
+  let rows: DocketRow[] = await fetchRows(s.filedAfter, s.filedBefore);
+  // A date window beyond what this dataset covers returns 0 rows as a clean
+  // success — "securities class actions filed after 2026-07-24" answered
+  // "none exist" when the truth was "the coverage ends earlier" (fleet #508's
+  // verbatim question died here after the routing fix). On a dated empty,
+  // retry once WITHOUT the dates: if data exists, return the newest available
+  // and say the window outran what is covered — the caller learns the
+  // coverage horizon instead of a false negative.
+  let dateWindowNote: string | undefined;
+  if (rows.length === 0 && (s.filedAfter || s.filedBefore)) {
+    const undated = await fetchRows(undefined, undefined);
+    if (undated.length > 0) {
+      rows = undated;
+      // WORDING IS LOAD-BEARING, same rule as labelAge's note in authority.ts:
+      // no "the mirror's" / "the mirror holds" — that is a claim about who
+      // stores what, not about what the data says. check:hosting-claims did
+      // not catch this before shared/ was wired into its string pass (task
+      // #2009); "pipeworx mirror of CourtListener bulk data" a few lines
+      // below was the same defect on the `source` field of every response on
+      // this rail, across all five packs that call searchDockets().
+      dateWindowNote =
+        `No dockets matched within the requested date window (${s.filedAfter ?? ''}..${s.filedBefore ?? ''}) — the newest matching docket on file is ${undated[0]?.date_filed ?? 'unknown'}, so the window likely outran what is covered. Returning the newest matching dockets available; treat absence WITHIN the window as UNKNOWN, not as zero filings.`;
+    }
+  }
+
+  return {
+    returned: rows.length,
+    dockets: rows.map(shapeDocket),
+    ...(dateWindowNote ? { date_window_note: dateWindowNote } : {}),
+    snapshot_date: rows[0]?.snapshot_date ?? null,
+    source: 'CourtListener bulk docket data',
+    attribution: 'CourtListener / Free Law Project — Public Domain Mark.',
+    // Said on every response, not just empty ones: a docket is the existence of
+    // a case, and an agent that assumes otherwise will describe filings it has
+    // never seen.
+    scope_note:
+      'Dockets record that a case exists — parties, court, dates, judge. They do NOT contain complaints, motions, orders or any filed document.',
+    ...(rows.length === 0
+      ? {
+          found: false,
+          hint: 'No docket matched. Names are matched by word, so try one distinctive party alone ("Theranos" rather than a full caption). Consumer bankruptcy filings are deliberately excluded from this dataset.',
+        }
+      : {}),
+  };
+}
+
+/** Word-matching name search against the FTS index. See searchDockets. */
+async function rpc(m: DocketMirror, body: Record<string, unknown>): Promise<DocketRow[]> {
+  for (let attempt = 0; ; attempt++) {
+    const res = await fetch(`${m.url}/rest/v1/rpc/search_dockets_by_name`, {
+      method: 'POST',
+      headers: {
+        apikey: m.key,
+        Authorization: `Bearer ${m.key}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(body),
+    });
+    if (res.ok) return (await res.json()) as DocketRow[];
+
+    const detail = (await res.text()).slice(0, 200);
+    const timedOut = detail.includes('57014');
+    // 57014 (statement_timeout) was NOT transient contention, whatever this
+    // comment used to say — it was the query plan, fixed in migration 080. What
+    // survives it is a genuinely cold first touch: a name matching tens of
+    // thousands of dockets has to read that many heap pages, and the first read
+    // of them can still run long while the same call moments later is warm. So
+    // the retry stays, and the message no longer tells the caller their date
+    // range is powerless — since 080 it is a real filter and does narrow the
+    // scan.
+    if (timedOut && attempt === 0) continue;
+    if (timedOut) {
+      throw new Error(
+        'Docket name search timed out twice (Postgres 57014). The name matches enough dockets that reading them cold exceeds the statement timeout; the identical call usually succeeds moments later, so retry it as-is. Narrowing filed_after/filed_before, or giving one distinctive party word rather than a common one, reduces the work and makes it less likely.',
+      );
+    }
+    throw new Error(`Docket name search failed (HTTP ${res.status}): ${detail}`);
+  }
+}
+/**
+ * Business bankruptcy filings — US federal bankruptcy courts.
+ *
+ * Covers US federal court dockets (36.4M).
+ * Consumer bankruptcy is deliberately EXCLUDED: of 71.7M dockets,
+ * 35.3M are individual filings — half the corpus, no business signal, and
+ * PII-adjacent. What is left is 1.55M business filings.
+ *
+ * Because the docket export has no chapter column, business vs consumer is
+ * decided by a legal-entity-suffix test on the debtor name. A sole
+ * proprietorship filing under a personal name is therefore absent, and the
+ * tool descriptions say so rather than implying complete coverage of
+ * commercial insolvency.
+ */
+
+
+const tools: McpToolExport['tools'] = [
+  {
+    name: 'bankruptcy_search',
+    description:
+      'Find US BUSINESS BANKRUPTCY filings by company name. Searches 1.55 million business filings across federal bankruptcy courts — no API key. Returns the case name, docket number, court, filing date, termination date and assigned judge. Use for "has this company filed for bankruptcy", corporate distress checks, counterparty risk and due diligence. Individual consumer bankruptcies are deliberately excluded.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        company: { type: 'string', description: 'Company name or a distinctive part of it, e.g. "Kmart".' },
+        court: { type: 'string', description: 'Optional court id, e.g. "cacb" (C.D. Cal. Bankruptcy).' },
+        filed_after: { type: 'string', description: 'Only filings on or after this date, YYYY-MM-DD.' },
+        filed_before: { type: 'string', description: 'Only filings on or before this date, YYYY-MM-DD.' },
+        limit: { type: 'number', description: 'Maximum filings to return (1-50, default 10).' },
+      },
+      required: ['company'],
+    },
+  },
+  {
+    name: 'bankruptcy_recent',
+    description:
+      'List recent US business bankruptcy filings, newest first, optionally limited to one bankruptcy court. No API key, no rate limit. Use for "what companies filed for bankruptcy recently" or to watch one district. Returns case name, docket number, court, filing and termination dates.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        court: { type: 'string', description: 'Optional bankruptcy court id, e.g. "nysb", "deb", "txsb".' },
+        filed_after: { type: 'string', description: 'Only filings on or after this date, YYYY-MM-DD.' },
+        limit: { type: 'number', description: 'Maximum filings to return (1-50, default 20).' },
+      },
+    },
+  },
+];
+
+async function callTool(name: string, args: Record<string, unknown>): Promise<unknown> {
+  const m = docketMirror(args);
+  if (!m) return docketUnavailable(name);
+
+  switch (name) {
+    case 'bankruptcy_search':
+      return {
+        company: args.company,
+        ...(await searchDockets(
+          m,
+          { court_class: 'federal_bankruptcy', is_business_bankruptcy: true },
+          {
+            party: String(args.company ?? ''),
+            court: args.court as string | undefined,
+            filedAfter: args.filed_after as string | undefined,
+            filedBefore: args.filed_before as string | undefined,
+            limit: Number(args.limit) || 10,
+          },
+        )),
+        coverage_note:
+          'Business filings only. Consumer bankruptcy is excluded, and a sole proprietorship filing under a personal name will not appear here.',
+      };
+
+    case 'bankruptcy_recent':
+      return {
+        ...(await searchDockets(
+          m,
+          { court_class: 'federal_bankruptcy', is_business_bankruptcy: true },
+          {
+            court: args.court as string | undefined,
+            filedAfter: args.filed_after as string | undefined,
+            limit: Number(args.limit) || 20,
+          },
+        )),
+        coverage_note:
+          'Business filings only, and coverage carries an as-of date — anything filed after snapshot_date is not here yet.',
+      };
+
+    default:
+      throw new Error(`Unknown tool: ${name}`);
+  }
+}
+
+export default { tools, callTool, meter: { credits: 1 } } satisfies McpToolExport;

package/src/server.ts

@@ -0,0 +1,45 @@
+/**
+ * Stdio MCP server entry point for @pipeworx/mcp-bankruptcy.
+ * Generated by scripts/publish-pack.sh — do not hand-edit in the pack repo;
+ * edit scripts/publish-pack.sh (the server.ts heredoc) and republish instead.
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import pack from './index.js';
+
+const server = new Server(
+  { name: '@pipeworx/mcp-bankruptcy', version: '0.1.0' },
+  { capabilities: { tools: {} } },
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: pack.tools.map((t) => ({
+    name: t.name,
+    description: t.description,
+    inputSchema: t.inputSchema,
+  })),
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  try {
+    const result = await pack.callTool(name, (args ?? {}) as Record<string, unknown>);
+    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+  } catch (err) {
+    return {
+      content: [{ type: 'text', text: err instanceof Error ? err.message : String(err) }],
+      isError: true,
+    };
+  }
+});
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+main().catch((err) => {
+  console.error('Fatal error running server:', err);
+  process.exit(1);
+});

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022"],
+    "types": ["@cloudflare/workers-types"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true
+  },
+  "include": ["src"],
+  "exclude": ["src/server.ts"]
+}