feat(parsers+api+ui): expose CARC-labeled CAS adjustments (SP3 P2)

backend/src/cyclone/store.py

@@ -335,14 +335,23 @@ def to_ui_remittance(
             f"CLP02 code {code} not in payer allowlist"
         )
 
+    # Aggregate adjustmentAmount across ALL service-line CAS rows, not just
+    # the first line. Mirrors the SUM the reconcile aggregator (T10)
+    # computes against persisted CasAdjustment rows; this inline version
+    # is the write-path equivalent (used when streaming 835 NDJSON
+    # responses before persistence finishes).
+    adjustment_total = Decimal("0")
+    for sp in cp.service_payments:
+        for adj in sp.adjustments:
+            adjustment_total += adj.amount
+
     parsed_iso = parsed_at.isoformat().replace("+00:00", "Z")
     return {
         "id": cp.payer_claim_control_number,
         "claimId": cp.original_claim_id or "",
         "payerName": payer_name,
         "paidAmount": float(cp.total_paid or 0.0),
-        # TODO: aggregate from CAS segments when reconciliation lands (sub-project 2)
-        "adjustmentAmount": 0.0,
+        "adjustmentAmount": float(adjustment_total),
         "status": status,
         "denialReason": denial_reason,
         "validationWarnings": validation_warnings,
@@ -443,6 +452,53 @@ def to_ui_remittance_from_orm(
     }
 
 
+def to_ui_remittance_with_adjustments(
+    row: Remittance,
+    *,
+    batch_id: str,
+    parsed_at: datetime,
+    cas_rows: list["db.CasAdjustment"] | None = None,
+) -> dict:
+    """Same shape as :func:`to_ui_remittance_from_orm` plus an ``adjustments`` array.
+
+    Each persisted ``CasAdjustment`` row is rendered as
+    ``{"group", "reason", "label", "amount", "quantity"}``. The ``label``
+    is resolved through :func:`cyclone.parsers.cas_codes.reason_label`
+    so the UI does not have to ship its own CARC dictionary.
+
+    ``cas_rows`` is optional so callers that don't have the rows handy
+    can still get the base dict; in that case ``adjustments`` is ``[]``.
+    Pass ``cas_rows`` to avoid an extra round-trip; the endpoint at
+    ``GET /api/remittances/{id}`` passes them in to keep this mapper a
+    pure function.
+    """
+    base = to_ui_remittance_from_orm(
+        row, batch_id=batch_id, parsed_at=parsed_at,
+    )
+    if not cas_rows:
+        base["adjustments"] = []
+        return base
+
+    # Lazy import to avoid the circular store ↔ parsers import that
+    # happens on cold start; mirrors the same pattern used elsewhere
+    # in this module.
+    from cyclone.parsers.cas_codes import reason_label
+
+    base["adjustments"] = [
+        {
+            "group": c.group_code,
+            "reason": c.reason_code,
+            "label": reason_label(c.group_code, c.reason_code),
+            "amount": float(c.amount or 0),
+            "quantity": (
+                float(c.quantity) if c.quantity is not None else None
+            ),
+        }
+        for c in cas_rows
+    ]
+    return base
+
+
 def to_ui_provider(
     *,
     npi: str,
@@ -766,6 +822,35 @@ class CycloneStore:
             )
             return [self._row_to_record(r) for r in rows]
 
+    def get_remittance(self, remittance_id: str) -> dict | None:
+        """Return a UI-shaped remittance dict with ``adjustments`` array.
+
+        Joins the persisted ``CasAdjustment`` rows for ``remittance_id``
+        and labels each via :mod:`cyclone.parsers.cas_codes`. Returns
+        ``None`` when the remittance is not found so the API layer can
+        map that to a 404.
+        """
+        with db.SessionLocal()() as s:
+            row = s.get(Remittance, remittance_id)
+            if row is None:
+                return None
+            cas_rows = (
+                s.query(CasAdjustment)
+                .filter(CasAdjustment.remittance_id == remittance_id)
+                .all()
+            )
+            parsed_at = (
+                row.batch.parsed_at if row.batch is not None else row.received_at
+            )
+            if parsed_at is not None and parsed_at.tzinfo is None:
+                parsed_at = parsed_at.replace(tzinfo=timezone.utc)
+            return to_ui_remittance_with_adjustments(
+                row,
+                batch_id=row.batch_id,
+                parsed_at=parsed_at,
+                cas_rows=cas_rows,
+            )
+
     def all(self) -> list[BatchRecord]:
         """Return every ``BatchRecord``, oldest first (no pagination)."""
         with db.SessionLocal()() as s: