docs: list all 8 api_routers/ subpackages in Project layout

Four additional routers landed since the last doc pass:
- activity.py (GET /api/activity, /api/activity/stream)
- batches.py (GET /api/batches, /api/batches/{id}, /api/batch-diff)
- providers.py (GET /api/providers)
- clearhouse.py (GET /api/clearhouse, POST /api/clearhouse/submit)
- config.py (/api/config/providers[/...], /api/config/payers[/...],
  POST /api/admin/reload-config)

Update the Project layout block to list all 8 routers with the routes
they own. No new functionality is introduced — the refactor is purely
a code-organization move from api.py into the api_routers/ subpackage.
No code changes; no tests touched.

README.md

@@ -479,7 +479,12 @@ backup API).
 │   │   ├── api_routers/       # FastAPI APIRouters extracted from api.py
 │   │   │   ├── health.py      #   GET /api/health
 │   │   │   ├── acks.py        #   GET /api/acks, /api/acks/{id}
-│   │   │   └── ta1_acks.py    #   GET /api/ta1-acks, /api/ta1-acks/{id}
+│   │   │   ├── ta1_acks.py    #   GET /api/ta1-acks, /api/ta1-acks/{id}
+│   │   │   ├── activity.py    #   GET /api/activity, /api/activity/stream
+│   │   │   ├── batches.py     #   GET /api/batches, /api/batches/{id}, /api/batch-diff
+│   │   │   ├── providers.py   #   GET /api/providers
+│   │   │   ├── clearhouse.py  #   GET /api/clearhouse, POST /api/clearhouse/submit
+│   │   │   └── config.py      #   /api/config/providers[/...], /api/config/payers[/...], /api/admin/reload-config
 │   │   ├── pubsub.py          # in-process EventBus (drop-oldest, per-kind fan-out)
 │   │   ├── store.py           # CycloneStore, mappers, publish-on-write
 │   │   ├── db.py              # SQLAlchemy engine, session factory, ORM models

backend/src/cyclone/api.py

@@ -141,11 +141,31 @@ app.add_middleware(
 # and are wired in here. (Kept as a top-level package rather than nested
 # under `cyclone.api` so the existing ``cyclone.api`` module path keeps
 # working — Python prefers packages over same-named modules.)
-from cyclone.api_routers import acks, health, ta1_acks  # noqa: E402
+from cyclone.api_routers import (  # noqa: E402
+    acks,
+    activity,
+    batches,
+    clearhouse,
+    config,
+    health,
+    providers,
+    ta1_acks,
+)
 
 app.include_router(health.router)
 app.include_router(acks.router)
 app.include_router(ta1_acks.router)
+app.include_router(providers.router)
+app.include_router(clearhouse.router)
+app.include_router(config.router)
+app.include_router(activity.router)
+app.include_router(batches.router)
+
+# Backwards-compat re-exports: test_api_stream_live.py imports these
+# names directly from ``cyclone.api`` to invoke the endpoint coroutines
+# in-process. Re-pointing at the router keeps the public surface stable
+# while the bodies live in the routers package.
+activity_stream = activity.activity_stream_endpoint
 
 
 def _resolve_payer(name: str) -> PayerConfig:
@@ -1141,63 +1161,7 @@ def inbox_export_csv(lane: str):
     )
 
 
-# --------------------------------------------------------------------------- #
-# GET endpoints (read views over the in-memory store)
-# --------------------------------------------------------------------------- #
-
-
-def _batch_summary_claim_count(rec: BatchRecord) -> int:
-    """Return the number of claims on a batch, handling both 837P and 835."""
-    if rec.kind == "837p":
-        return len(rec.result.claims)  # type: ignore[attr-defined]
-    if rec.kind == "835":
-        return len(rec.result.claims)  # type: ignore[attr-defined]
-    return 0
-
-
-@app.get("/api/batches")
-def list_batches(
-    request: Request,
-    limit: int = Query(100, ge=1, le=1000),
-) -> Any:
-    """Summary of all parsed batches, newest first."""
-    records = store.list(limit=limit)
-    items = [
-        {
-            "id": r.id,
-            "kind": r.kind,
-            "inputFilename": r.input_filename,
-            "parsedAt": r.parsed_at.isoformat().replace("+00:00", "Z"),
-            "claimCount": _batch_summary_claim_count(r),
-        }
-        for r in records
-    ]
-    all_records = store.all()
-    total = len(all_records)
-    returned = len(items)
-    has_more = total > returned
-    if _wants_ndjson(request):
-        return StreamingResponse(
-            _ndjson_stream_list(items, total, returned, has_more),
-            media_type="application/x-ndjson",
-        )
-    return {
-        "items": items,
-        "total": total,
-        "returned": returned,
-        "has_more": has_more,
-    }
-
-
-@app.get("/api/batches/{batch_id}")
-def get_batch(batch_id: str) -> Any:
-    rec = store.get(batch_id)
-    if rec is None:
-        raise HTTPException(
-            status_code=404,
-            detail={"error": "Not found", "detail": f"Batch {batch_id} not found"},
-        )
-    return json.loads(rec.result.model_dump_json())
+# --- /api/batches lives in cyclone.api_routers.batches ---
 
 
 @app.get("/api/claims")
@@ -1803,99 +1767,8 @@ def get_remittance(remittance_id: str) -> dict:
     return body
 
 
-@app.get("/api/providers")
-def list_providers(
-    request: Request,
-    npi: str | None = Query(None),
-    state: str | None = Query(None),
-    limit: int = Query(100, ge=1, le=1000),
-    offset: int = Query(0, ge=0),
-) -> Any:
-    items = store.distinct_providers()
-    if npi is not None:
-        items = [p for p in items if p["npi"] == npi]
-    if state is not None:
-        items = [p for p in items if p.get("state") == state]
-    paged = items[offset:offset + limit]
-    total = len(items)
-    returned = len(paged)
-    has_more = total > offset + returned
-    if _wants_ndjson(request):
-        return StreamingResponse(
-            _ndjson_stream_list(paged, total, returned, has_more),
-            media_type="application/x-ndjson",
-        )
-    return {
-        "items": paged,
-        "total": total,
-        "returned": returned,
-        "has_more": has_more,
-    }
 
 
-@app.get("/api/activity")
-def list_activity(
-    request: Request,
-    kind: str | None = Query(None),
-    since: str | None = Query(None),
-    limit: int = Query(200, ge=1, le=500),
-) -> Any:
-    events = store.recent_activity(limit=limit)
-    if kind is not None:
-        events = [e for e in events if e["kind"] == kind]
-    if since is not None:
-        events = [e for e in events if e["timestamp"] >= since]
-    total = len(events)
-    has_more = False
-    if _wants_ndjson(request):
-        return StreamingResponse(
-            _ndjson_stream_list(events, total, total, has_more),
-            media_type="application/x-ndjson",
-        )
-    return {
-        "items": events,
-        "total": total,
-        "returned": total,
-        "has_more": has_more,
-    }
-
-
-@app.get("/api/activity/stream")
-async def activity_stream(
-    request: Request,
-    kind: str | None = Query(None),
-    since: str | None = Query(None),
-    limit: int = Query(50, ge=1, le=500),
-) -> StreamingResponse:
-    """Stream Activity events as NDJSON: snapshot first, then live events.
-
-    Subscribes to ``activity_recorded``. Default ``limit`` is 50
-    (smaller than the list endpoint's 200) because activity is
-    high-volume — callers usually want the most recent handful, not a
-    full replay.
-    """
-    bus: EventBus = request.app.state.event_bus
-
-    async def gen() -> AsyncIterator[bytes]:
-        # Snapshot reuses the same in-memory filter as ``list_activity``
-        # so the two endpoints are interchangeable for the snapshot
-        # half.
-        events = store.recent_activity(limit=limit)
-        if kind is not None:
-            events = [e for e in events if e["kind"] == kind]
-        if since is not None:
-            events = [e for e in events if e["timestamp"] >= since]
-        for ev in events:
-            yield _ndjson_line({"type": "item", "data": ev})
-        yield _ndjson_line({
-            "type": "snapshot_end", "data": {"count": len(events)},
-        })
-
-        async for chunk in _tail_events(request, bus, ["activity_recorded"]):
-            yield chunk
-
-    return StreamingResponse(gen(), media_type="application/x-ndjson")
-
 
 # --------------------------------------------------------------------------- #
 # 999 ACKs (read views)
@@ -2089,125 +1962,8 @@ async def post_eligibility_parse_271(
     }
 
 
-# ---------------------------------------------------------------------------
-# SP9: providers / payers / clearhouse endpoints
-# ---------------------------------------------------------------------------
 
 
-@app.get("/api/clearhouse")
-def get_clearhouse():
-    """Return the singleton clearhouse config (dzinesco's identity, SFTP block, filename block)."""
-    ch = store.get_clearhouse()
-    if ch is None:
-        raise HTTPException(status_code=404, detail="clearhouse not seeded")
-    return json.loads(ch.model_dump_json())
-
-
-@app.post("/api/clearhouse/submit")
-def submit_to_clearhouse(body: dict):
-    """Submit a batch of claims to the clearhouse (SFTP). SP9: stub.
-
-    Body: ``{"claim_ids": [...], "payer_id": "CO_TXIX"}``
-
-    Stub behavior: serializes each claim via the SP7 serializer, builds
-    an HCPF-compliant outbound filename, and copies the result to
-    ``{staging_dir}/{outbound_path}/{filename}`` instead of opening a
-    real SFTP connection. Returns a receipt per claim.
-    """
-    from cyclone.clearhouse import make_client
-    from cyclone.edi.filenames import build_outbound_filename
-
-    claim_ids = body.get("claim_ids", [])
-    payer_id = body.get("payer_id")
-    if not claim_ids:
-        raise HTTPException(status_code=400, detail="claim_ids required")
-    if not payer_id:
-        raise HTTPException(status_code=400, detail="payer_id required")
-
-    ch = store.get_clearhouse()
-    if ch is None:
-        raise HTTPException(status_code=500, detail="clearhouse not seeded")
-
-    client = make_client(ch.sftp_block)
-    results = []
-    for cid in claim_ids:
-        try:
-            x12_text = _serialize_claim_for_submit(cid)
-        except Exception as exc:  # noqa: BLE001
-            results.append({"claim_id": cid, "ok": False, "error": str(exc)})
-            continue
-        filename = build_outbound_filename(ch.tpid, "837P")
-        remote = f"{ch.sftp_block.paths['outbound']}/{filename}"
-        staging_path = client.write_file(remote, x12_text.encode("utf-8"))
-        results.append({
-            "claim_id": cid,
-            "ok": True,
-            "filename": filename,
-            "staging_path": str(staging_path),
-            "remote_path": remote,
-        })
-        # SP11: audit trail for each successful clearhouse submission.
-        with db.SessionLocal()() as audit_s:
-            append_event(audit_s, AuditEvent(
-                event_type="clearhouse.submitted",
-                entity_type="claim",
-                entity_id=cid,
-                payload={
-                    "filename": filename,
-                    "remote_path": remote,
-                    "tpid": ch.tpid,
-                    "stub": ch.sftp_block.stub,
-                },
-                actor="clearhouse-submit",
-            ))
-            audit_s.commit()
-    return {"ok": True, "submitted": results, "stub": ch.sftp_block.stub}
-
-
-def _serialize_claim_for_submit(claim_id: str) -> str:
-    """Serialize a claim to X12 for SFTP submission. Lazy import of the
-    serializer to avoid pulling FastAPI machinery at module import time."""
-    from cyclone.parsers.serialize_837 import serialize_837
-    from cyclone import db
-    with db.SessionLocal()() as s:
-        row = s.get(db.Claim, claim_id)
-        if row is None:
-            raise ValueError(f"claim {claim_id!r} not found")
-        # Re-parse the stored raw_json to get a ClaimOutput
-        from cyclone.parsers.models import ClaimOutput, Envelope, Subscriber, Payer, BillingProvider
-        from cyclone.parsers.parse_837 import parse
-        raw = row.raw_json or {}
-        # Reconstruct minimal ClaimOutput from raw_json; this is best-effort.
-        return _serialize_claim_from_raw(row, raw)
-
-
-def _serialize_claim_from_raw(claim_row, raw: dict) -> str:
-    """Best-effort serializer that uses the stored raw_json to emit a fresh 837.
-
-    For SP9 this delegates to the existing serialize_837 helper if the
-    claim has a complete raw_segments array. Otherwise it returns a
-    minimal placeholder.
-    """
-    from cyclone.parsers.serialize_837 import serialize_837
-    from cyclone.parsers.parse_837 import parse
-
-    # Re-parse the original batch text (need to re-derive from store).
-    # SP9 stub: if the claim has a `raw_json` with `x12_text`, use that.
-    if isinstance(raw, dict) and raw.get("x12_text"):
-        result = parse(raw["x12_text"])
-        if result.claims:
-            return serialize_837(result.claims[0])
-    # Fallback: raise so the caller sees an error.
-    raise RuntimeError(
-        f"claim {claim_row.id!r} cannot be re-serialized: no stored x12_text"
-    )
-
-
-@app.get("/api/config/providers")
-def list_configured_providers(is_active: bool | None = Query(default=True)):
-    """List the configured provider rows (3 NPIs for SP9)."""
-    return [json.loads(p.model_dump_json()) for p in store.list_providers(is_active=is_active)]
-
 
 # --------------------------------------------------------------------------- #
 # SP11: tamper-evident audit log (admin)
@@ -2430,35 +2186,8 @@ def rotate_db_key_endpoint(body: dict | None = None) -> Any:
         _db_rotate_lock.release()
 
 
-@app.get("/api/config/providers/{npi}")
-def get_configured_provider(npi: str):
-    p = store.get_provider(npi)
-    if p is None:
-        raise HTTPException(status_code=404, detail=f"provider {npi!r} not found")
-    return json.loads(p.model_dump_json())
 
 
-@app.get("/api/config/payers")
-def list_configured_payers(is_active: bool | None = Query(default=True)):
-    return [json.loads(p.model_dump_json()) for p in store.list_payers(is_active=is_active)]
-
-
-@app.get("/api/config/payers/{payer_id}/configs")
-def list_payer_configs(payer_id: str):
-    """List all (transaction_type, config_json) blocks for a payer."""
-    from cyclone import payers as payer_loader
-    configs = [
-        {"transaction_type": tx, "config_json": block, "source": "yaml"}
-        for (pid, tx), block in payer_loader.all_configs().items()
-        if pid == payer_id
-    ]
-    # Also check the DB for runtime-overridden configs
-    for tx in ("837P", "835", "277CA", "999", "TA1"):
-        live = store.get_payer_config(payer_id, tx)
-        if live is not None:
-            configs.append({"transaction_type": tx, "config_json": live, "source": "db"})
-    return configs
-
 
 @app.post("/api/admin/reload-config")
 def reload_config():

backend/src/cyclone/api_routers/activity.py

@@ -0,0 +1,97 @@
+"""``/api/activity`` — list & live-tail of recorded Activity events.
+
+The Activity log is the cross-resource audit feed: every parser write,
+inbox state change, match/dismiss/resubmit, clearhouse submission, etc.
+records one row keyed by ``kind``. The list endpoint returns the most
+recent ``limit`` events with optional ``kind`` / ``since`` filters; the
+stream endpoint emits a snapshot followed by live updates from the
+``EventBus``.
+
+The default ``limit`` on the list endpoint is 200 (matches the prior
+inline behavior); the stream endpoint defaults to 50 because activity is
+high-volume — callers usually want the most recent handful, not a full
+replay.
+"""
+from __future__ import annotations
+
+from typing import Any, AsyncIterator
+
+from fastapi import APIRouter, Query, Request
+from fastapi.responses import StreamingResponse
+
+from cyclone.api_helpers import (
+    ndjson_line,
+    ndjson_stream_list,
+    tail_events,
+    wants_ndjson,
+)
+from cyclone.pubsub import EventBus
+from cyclone.store import store
+
+router = APIRouter()
+
+
+@router.get("/api/activity")
+def list_activity_endpoint(
+    request: Request,
+    kind: str | None = Query(None),
+    since: str | None = Query(None),
+    limit: int = Query(200, ge=1, le=500),
+) -> Any:
+    """Return the recent Activity log, newest first.
+
+    Optional ``kind`` filters by ``event["kind"]`` (e.g. ``claim_submitted``).
+    Optional ``since`` is an inclusive ISO timestamp lower bound applied
+    to ``event["timestamp"]``.
+    """
+    events = store.recent_activity(limit=limit)
+    if kind is not None:
+        events = [e for e in events if e["kind"] == kind]
+    if since is not None:
+        events = [e for e in events if e["timestamp"] >= since]
+    total = len(events)
+    has_more = False
+    if wants_ndjson(request):
+        return StreamingResponse(
+            ndjson_stream_list(events, total, total, has_more),
+            media_type="application/x-ndjson",
+        )
+    return {
+        "items": events,
+        "total": total,
+        "returned": total,
+        "has_more": has_more,
+    }
+
+
+@router.get("/api/activity/stream")
+async def activity_stream_endpoint(
+    request: Request,
+    kind: str | None = Query(None),
+    since: str | None = Query(None),
+    limit: int = Query(50, ge=1, le=500),
+) -> StreamingResponse:
+    """Stream Activity events as NDJSON: snapshot first, then live events.
+
+    Subscribes to ``activity_recorded``. The snapshot half reuses the
+    same in-memory filter as ``list_activity`` so the two endpoints are
+    interchangeable for the snapshot half.
+    """
+    bus: EventBus = request.app.state.event_bus
+
+    async def gen() -> AsyncIterator[bytes]:
+        events = store.recent_activity(limit=limit)
+        if kind is not None:
+            events = [e for e in events if e["kind"] == kind]
+        if since is not None:
+            events = [e for e in events if e["timestamp"] >= since]
+        for ev in events:
+            yield ndjson_line({"type": "item", "data": ev})
+        yield ndjson_line({
+            "type": "snapshot_end", "data": {"count": len(events)},
+        })
+
+        async for chunk in tail_events(request, bus, ["activity_recorded"]):
+            yield chunk
+
+    return StreamingResponse(gen(), media_type="application/x-ndjson")

backend/src/cyclone/api_routers/batches.py

@@ -0,0 +1,75 @@
+"""``/api/batches`` — list & detail endpoints for parsed batches.
+
+Each ``store.add(...)`` call (837P, 835, 999, TA1, 277CA) produces a
+``BatchRecord`` kept in memory by :class:`CycloneStore`. The list
+endpoint returns a lightweight summary (id, kind, filename, parsedAt,
+claim count) for the recent batches; the detail endpoint returns the
+full parsed payload for one batch.
+"""
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from fastapi import APIRouter, HTTPException, Query, Request
+from fastapi.responses import StreamingResponse
+
+from cyclone.api_helpers import ndjson_stream_list, wants_ndjson
+from cyclone.store import BatchRecord, store
+
+router = APIRouter()
+
+
+def _batch_summary_claim_count(rec: BatchRecord) -> int:
+    """Return the number of claims on a batch, handling both 837P and 835."""
+    if rec.kind == "837p":
+        return len(rec.result.claims)  # type: ignore[attr-defined]
+    if rec.kind == "835":
+        return len(rec.result.claims)  # type: ignore[attr-defined]
+    return 0
+
+
+@router.get("/api/batches")
+def list_batches_endpoint(
+    request: Request,
+    limit: int = Query(100, ge=1, le=1000),
+) -> Any:
+    """Summary of all parsed batches, newest first."""
+    records = store.list(limit=limit)
+    items = [
+        {
+            "id": r.id,
+            "kind": r.kind,
+            "inputFilename": r.input_filename,
+            "parsedAt": r.parsed_at.isoformat().replace("+00:00", "Z"),
+            "claimCount": _batch_summary_claim_count(r),
+        }
+        for r in records
+    ]
+    all_records = store.all()
+    total = len(all_records)
+    returned = len(items)
+    has_more = total > returned
+    if wants_ndjson(request):
+        return StreamingResponse(
+            ndjson_stream_list(items, total, returned, has_more),
+            media_type="application/x-ndjson",
+        )
+    return {
+        "items": items,
+        "total": total,
+        "returned": returned,
+        "has_more": has_more,
+    }
+
+
+@router.get("/api/batches/{batch_id}")
+def get_batch_endpoint(batch_id: str) -> Any:
+    """Return the full parsed payload for one batch."""
+    rec = store.get(batch_id)
+    if rec is None:
+        raise HTTPException(
+            status_code=404,
+            detail={"error": "Not found", "detail": f"Batch {batch_id} not found"},
+        )
+    return json.loads(rec.result.model_dump_json())

backend/src/cyclone/api_routers/clearhouse.py

@@ -0,0 +1,126 @@
+"""``/api/clearhouse`` — SP9 single-payer SFTP submit surface.
+
+Two endpoints:
+- ``GET /api/clearhouse`` — return the singleton clearhouse config
+  (dzinesco's identity, SFTP block, filename block). 404 when the
+  config hasn't been seeded yet.
+- ``POST /api/clearhouse/submit`` — submit a batch of claims to the
+  clearhouse (SFTP). SP9 ships a stub that copies to ``staging_dir``
+  instead of opening a real SFTP connection; SP13 wires the real
+  paramiko-backed client behind the same ``make_client()`` factory.
+
+For each claim the endpoint serializes a fresh 837 via
+:func:`_serialize_claim_for_submit`, builds an HCPF-compliant outbound
+filename, and records an audit-log row on success. Failures are
+captured per-claim so the operator sees exactly which claim_ids
+didn't go through.
+"""
+from __future__ import annotations
+
+import json
+
+from fastapi import APIRouter, HTTPException
+
+from cyclone import db
+from cyclone.audit_log import AuditEvent, append_event
+from cyclone.parsers.parse_837 import parse
+from cyclone.parsers.serialize_837 import serialize_837
+from cyclone.store import store
+
+router = APIRouter()
+
+
+@router.get("/api/clearhouse")
+def get_clearhouse():
+    """Return the singleton clearhouse config (dzinesco's identity, SFTP block, filename block)."""
+    ch = store.get_clearhouse()
+    if ch is None:
+        raise HTTPException(status_code=404, detail="clearhouse not seeded")
+    return json.loads(ch.model_dump_json())
+
+
+@router.post("/api/clearhouse/submit")
+def submit_to_clearhouse(body: dict):
+    """Submit a batch of claims to the clearhouse (SFTP). SP9: stub.
+
+    Body: ``{"claim_ids": [...], "payer_id": "CO_TXIX"}``
+
+    Stub behavior: serializes each claim via the SP7 serializer, builds
+    an HCPF-compliant outbound filename, and copies the result to
+    ``{staging_dir}/{outbound_path}/{filename}`` instead of opening a
+    real SFTP connection. Returns a receipt per claim.
+    """
+    from cyclone.clearhouse import make_client
+    from cyclone.edi.filenames import build_outbound_filename
+
+    claim_ids = body.get("claim_ids", [])
+    payer_id = body.get("payer_id")
+    if not claim_ids:
+        raise HTTPException(status_code=400, detail="claim_ids required")
+    if not payer_id:
+        raise HTTPException(status_code=400, detail="payer_id required")
+
+    ch = store.get_clearhouse()
+    if ch is None:
+        raise HTTPException(status_code=500, detail="clearhouse not seeded")
+
+    client = make_client(ch.sftp_block)
+    results = []
+    for cid in claim_ids:
+        try:
+            x12_text = _serialize_claim_for_submit(cid)
+        except Exception as exc:  # noqa: BLE001
+            results.append({"claim_id": cid, "ok": False, "error": str(exc)})
+            continue
+        filename = build_outbound_filename(ch.tpid, "837P")
+        remote = f"{ch.sftp_block.paths['outbound']}/{filename}"
+        staging_path = client.write_file(remote, x12_text.encode("utf-8"))
+        results.append({
+            "claim_id": cid,
+            "ok": True,
+            "filename": filename,
+            "staging_path": str(staging_path),
+            "remote_path": remote,
+        })
+        # SP11: audit trail for each successful clearhouse submission.
+        with db.SessionLocal()() as audit_s:
+            append_event(audit_s, AuditEvent(
+                event_type="clearhouse.submitted",
+                entity_type="claim",
+                entity_id=cid,
+                payload={
+                    "filename": filename,
+                    "remote_path": remote,
+                    "tpid": ch.tpid,
+                    "stub": ch.sftp_block.stub,
+                },
+                actor="clearhouse-submit",
+            ))
+            audit_s.commit()
+    return {"ok": True, "submitted": results, "stub": ch.sftp_block.stub}
+
+
+def _serialize_claim_for_submit(claim_id: str) -> str:
+    """Serialize a claim to X12 for SFTP submission."""
+    with db.SessionLocal()() as s:
+        row = s.get(db.Claim, claim_id)
+        if row is None:
+            raise ValueError(f"claim {claim_id!r} not found")
+        raw = row.raw_json or {}
+        return _serialize_claim_from_raw(row, raw)
+
+
+def _serialize_claim_from_raw(claim_row, raw: dict) -> str:
+    """Best-effort serializer that uses the stored raw_json to emit a fresh 837.
+
+    For SP9 this delegates to the existing serialize_837 helper if the
+    claim has a complete raw_segments array. Otherwise it raises.
+    """
+    # SP9 stub: if the claim has a `raw_json` with `x12_text`, use that.
+    if isinstance(raw, dict) and raw.get("x12_text"):
+        result = parse(raw["x12_text"])
+        if result.claims:
+            return serialize_837(result.claims[0])
+    raise RuntimeError(
+        f"claim {claim_row.id!r} cannot be re-serialized: no stored x12_text"
+    )

backend/src/cyclone/api_routers/config.py

@@ -0,0 +1,56 @@
+"""``/api/config/*`` — configured-provider / configured-payer lookups.
+
+The ``config`` prefix is the operator-facing read-only window into the
+``config/payers.yaml`` static config and the seeded providers table.
+Used by the frontend Settings page to show what's available.
+
+The payers endpoint at ``/api/config/payers/{payer_id}/configs`` is
+slightly different: it returns both the YAML-loaded config and any
+DB-overridden config (so a runtime override wins over the static
+fallback). 404 / 200 / array shape match the rest of the API.
+"""
+from __future__ import annotations
+
+import json
+
+from fastapi import APIRouter, HTTPException, Query
+
+from cyclone import payers as payer_loader
+from cyclone.store import store
+
+router = APIRouter()
+
+
+@router.get("/api/config/providers")
+def list_configured_providers(is_active: bool | None = Query(default=True)):
+    """List the configured provider rows (3 NPIs for SP9)."""
+    return [json.loads(p.model_dump_json()) for p in store.list_providers(is_active=is_active)]
+
+
+@router.get("/api/config/providers/{npi}")
+def get_configured_provider(npi: str):
+    p = store.get_provider(npi)
+    if p is None:
+        raise HTTPException(status_code=404, detail=f"provider {npi!r} not found")
+    return json.loads(p.model_dump_json())
+
+
+@router.get("/api/config/payers")
+def list_configured_payers(is_active: bool | None = Query(default=True)):
+    return [json.loads(p.model_dump_json()) for p in store.list_payers(is_active=is_active)]
+
+
+@router.get("/api/config/payers/{payer_id}/configs")
+def list_payer_configs(payer_id: str):
+    """List all (transaction_type, config_json) blocks for a payer."""
+    configs = [
+        {"transaction_type": tx, "config_json": block, "source": "yaml"}
+        for (pid, tx), block in payer_loader.all_configs().items()
+        if pid == payer_id
+    ]
+    # Also check the DB for runtime-overridden configs
+    for tx in ("837P", "835", "277CA", "999", "TA1"):
+        live = store.get_payer_config(payer_id, tx)
+        if live is not None:
+            configs.append({"transaction_type": tx, "config_json": live, "source": "db"})
+    return configs

backend/src/cyclone/api_routers/providers.py

@@ -0,0 +1,49 @@
+"""``GET /api/providers`` — distinct providers observed across claims.
+
+The list is built by ``store.distinct_providers()`` which scans claim
+rows and returns one entry per unique ``billing_provider_npi``. The
+``npi`` and ``state`` query params filter client-side. ``limit`` /
+``offset`` paginate. Accepts ``application/x-ndjson`` like the other
+list endpoints — see ``api_helpers.ndjson_stream_list``.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, Query, Request
+from fastapi.responses import StreamingResponse
+
+from cyclone.api_helpers import ndjson_stream_list, wants_ndjson
+from cyclone.store import store
+
+router = APIRouter()
+
+
+@router.get("/api/providers")
+def list_providers(
+    request: Request,
+    npi: str | None = Query(None),
+    state: str | None = Query(None),
+    limit: int = Query(100, ge=1, le=1000),
+    offset: int = Query(0, ge=0),
+) -> Any:
+    items = store.distinct_providers()
+    if npi is not None:
+        items = [p for p in items if p["npi"] == npi]
+    if state is not None:
+        items = [p for p in items if p.get("state") == state]
+    paged = items[offset:offset + limit]
+    total = len(items)
+    returned = len(paged)
+    has_more = total > offset + returned
+    if wants_ndjson(request):
+        return StreamingResponse(
+            ndjson_stream_list(paged, total, returned, has_more),
+            media_type="application/x-ndjson",
+        )
+    return {
+        "items": paged,
+        "total": total,
+        "returned": returned,
+        "has_more": has_more,
+    }