feat: add United Ucard claim worker and fix batch-column site-key routing

Adds a "United Ucard Claim" button (claims/preauth insurance form) that
submits through a full Selenium pipeline mirroring the Tufts SCO claim
worker: frontend handler -> backend route/queue processor -> Python
agent, reusing the persistent login/OTP session from the existing
United Ucard eligibility check. Implements the UHC Dental claim wizard
end-to-end (Provider Information, Patient Information search/select,
Claim Information procedures + questions, Upload Documents, Review and
Sign, Submit); the final confirmation-page PDF/claim-number capture is
still a TODO stub pending that page's DOM.

Also wires United Ucard into the AI chatbot's eligibility flow
(insuranceAliases.json, siteKeyToAutoCheck, clarification options), and
fixes a bug where the AI-column batch claim feature silently defaulted
United Ucard patients to MassHealth because batchColumnDeriveSiteKey
had no matching branch and no job-dispatch case for UNITED_UCARD.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

apps/Backend/src/ai/internal-chat-workflow.ts

@@ -86,6 +86,7 @@ export function siteKeyToAutoCheck(siteKey: string, dob?: string | Date | null):
     case "DELTA_INS":  return "delta-ins";
     case "TUFTS_SCO":  return "tufts-sco";
     case "UNITED_SCO": return "united-sco";
+    case "UNITED_UCARD": return "united-ucard";
     default: {
       // MassHealth: patients under 21 use the CMSP button
       if (dob) {
@@ -428,7 +429,7 @@ async function handleEligibilityById(
         memberId,
         dob: resolvedDob,
         patient,
-        options: ["United SCO / Dental Hub", "Other United (not in app)"],
+        options: ["United SCO / Dental Hub", "United Ucard", "Other United (not in app)"],
       },
     };
   }
@@ -969,7 +970,7 @@ async function handleCheckAndClaim(
         dob: resolvedDob,
         patient,
         procedureNames: c.procedureNames ?? [],
-        options: ["United SCO / Dental Hub", "Other United (not in app)"],
+        options: ["United SCO / Dental Hub", "United Ucard", "Other United (not in app)"],
       },
     };
   }

apps/Backend/src/data/insuranceAliases.json

@@ -29,6 +29,12 @@
   { "keyword": "dental hub",                  "siteKey": "UNITED_SCO" },
   { "keyword": "united_sco",                  "siteKey": "UNITED_SCO" },
 
+  { "keyword": "united ucard",                "siteKey": "UNITED_UCARD" },
+  { "keyword": "uniteducard",                 "siteKey": "UNITED_UCARD" },
+  { "keyword": "ucard",                       "siteKey": "UNITED_UCARD" },
+  { "keyword": "onehealthcareid",             "siteKey": "UNITED_UCARD" },
+  { "keyword": "one healthcare id",           "siteKey": "UNITED_UCARD" },
+
   { "keyword": "blue cross blue shield",      "siteKey": "BCBS_MA" },
   { "keyword": "bcbs ma",                     "siteKey": "BCBS_MA" },
   { "keyword": "blue cross",                  "siteKey": "BCBS_MA" },

apps/Backend/src/queue/jobRunner.ts

@@ -24,6 +24,7 @@ import { runUnitedDHClaimProcessor } from "./processors/unitedDHClaimProcessor";
 import { runUnitedDHPreAuthProcessor } from "./processors/unitedDHPreAuthProcessor";
 import { runTuftsSCOPreAuthProcessor } from "./processors/tuftsSCOPreAuthProcessor";
 import { runTuftsSCOClaimProcessor } from "./processors/tuftsSCOClaimProcessor";
+import { runUnitedUcardClaimProcessor } from "./processors/unitedUcardClaimProcessor";
 import { runEligibilityHistoryProcessor } from "./processors/eligibilityHistoryProcessor";
 import { runCmspEligibilityHistoryRemainingProcessor } from "./processors/cmspEligibilityHistoryRemainingProcessor";
 import { runBcbsMaEligibilityProcessor } from "./processors/bcbsMaEligibilityProcessor";
@@ -234,6 +235,17 @@ export function enqueueSeleniumJob(data: SeleniumJobData): string {
         job.id
       );
     }
+    if (jobType === "uniteducard-claim-submit") {
+      return runUnitedUcardClaimProcessor(
+        {
+          enrichedPayload: data.enrichedPayload,
+          userId: data.userId,
+          claimId: data.claimId,
+          socketId: data.socketId,
+        },
+        job.id
+      );
+    }
     if (jobType === "cca-eligibility-check") {
       return runCCAEligibilityProcessor(
         {

apps/Backend/src/queue/processors/unitedUcardClaimProcessor.ts

@@ -0,0 +1,176 @@
+/**
+ * Processor for "uniteducard-claim-submit" jobs.
+ * Opens a claim on the United Ucard (UHC Dental) provider portal via Selenium.
+ *
+ * Flow:
+ *   1. POST /uniteducard-claim to Python agent → get session_id
+ *   2. Emit selenium:uniteducard_claim_started to frontend
+ *   3. Poll until completed/error
+ *   4. Emit result
+ */
+import {
+  forwardToSeleniumUnitedUcardClaimAgent,
+  getSeleniumUnitedUcardClaimSessionStatus,
+} from "../../services/seleniumUnitedUcardClaimClient";
+import { io } from "../../socket";
+import { storage } from "../../storage";
+import axios from "axios";
+import path from "path";
+
+function log(tag: string, msg: string, ctx?: any) {
+  console.log(`${new Date().toISOString()} [${tag}] ${msg}`, ctx ?? "");
+}
+
+function emitToSocket(socketId: string | undefined, event: string, payload: any) {
+  if (!socketId || !io) return;
+  try {
+    const socket = io.sockets.sockets.get(socketId);
+    if (socket) socket.emit(event, payload);
+  } catch (_) {}
+}
+
+async function pollUntilDone(
+  sessionId: string,
+  socketId: string | undefined,
+  jobId: string,
+  pollTimeoutMs = 10 * 60 * 1000
+): Promise<any> {
+  const maxAttempts = 1200;
+  const pollIntervalMs = 500;
+  const maxTransientErrors = 12;
+  let transientErrors = 0;
+  let lastOtpEmit = 0;
+  const deadline = Date.now() + pollTimeoutMs;
+
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    if (Date.now() > deadline) {
+      throw new Error(`United Ucard claim polling timeout for session ${sessionId}`);
+    }
+    try {
+      const st = await getSeleniumUnitedUcardClaimSessionStatus(sessionId);
+      const status: string = st?.status ?? "unknown";
+      log("uniteducard-claim-processor", `poll attempt=${attempt}`, { sessionId, status });
+      transientErrors = 0;
+
+      if (status === "waiting_for_otp") {
+        if (Date.now() - lastOtpEmit > 5000) {
+          emitToSocket(socketId, "selenium:otp_required", {
+            session_id: sessionId,
+            jobId,
+            message: "OTP required. Please enter the OTP shown by the United Ucard portal.",
+          });
+          lastOtpEmit = Date.now();
+        }
+        await new Promise((r) => setTimeout(r, pollIntervalMs));
+        continue;
+      }
+
+      if (status === "completed") return st.result;
+      if (status === "error" || status === "not_found") {
+        throw new Error(st?.message || `United Ucard claim session ended with status: ${status}`);
+      }
+      await new Promise((r) => setTimeout(r, pollIntervalMs));
+    } catch (err: any) {
+      const isTerminal =
+        err?.response?.status === 404 ||
+        (typeof err?.message === "string" &&
+          (err.message.includes("not_found") || err.message.includes("polling timeout")));
+      if (isTerminal) throw err;
+      transientErrors++;
+      if (transientErrors > maxTransientErrors) {
+        throw new Error(`Too many transient errors polling United Ucard claim session ${sessionId}`);
+      }
+      const backoff = Math.min(30_000, 500 * Math.pow(2, transientErrors - 1));
+      await new Promise((r) => setTimeout(r, backoff));
+    }
+  }
+  throw new Error(`United Ucard claim polling exhausted all attempts for session ${sessionId}`);
+}
+
+async function savePdfFromSelenium(pdf_url: string, patientId: number, userId: number) {
+  try {
+    const filename = path.basename(new URL(pdf_url).pathname);
+    const seleniumPort = process.env.SELENIUM_PORT || "5002";
+    const localUrl = `http://localhost:${seleniumPort}/downloads/${filename}`;
+    const resp = await axios.get(localUrl, { responseType: "arraybuffer", timeout: 30000 });
+    const patient = await storage.getPatient(patientId);
+    const patientName = patient ? `${patient.firstName ?? ""} ${patient.lastName ?? ""}`.trim() : "";
+    await storage.savePdfToCloudStorage(
+      userId,
+      patientId,
+      patientName || `Patient ${patientId}`,
+      "Claims",
+      filename,
+      Buffer.from(resp.data)
+    );
+    log("uniteducard-claim-processor", "PDF saved", { patientId, filename });
+  } catch (err: any) {
+    log("uniteducard-claim-processor", "failed to save PDF (non-fatal)", { error: err?.message ?? err });
+  }
+}
+
+export interface UnitedUcardClaimProcessorInput {
+  enrichedPayload: any;
+  userId: number;
+  claimId?: number;
+  socketId?: string;
+}
+
+export async function runUnitedUcardClaimProcessor(
+  input: UnitedUcardClaimProcessorInput,
+  jobId: string
+): Promise<{ status: string; pdf_url?: string; claimNumber?: string }> {
+  const { enrichedPayload, userId, claimId, socketId } = input;
+
+  log("uniteducard-claim-processor", "starting Python agent session", { claimId });
+  const agentResp = await forwardToSeleniumUnitedUcardClaimAgent(enrichedPayload);
+
+  if (!agentResp?.session_id) {
+    throw new Error("Python agent did not return a session_id for United Ucard claim");
+  }
+
+  const sessionId = agentResp.session_id as string;
+  log("uniteducard-claim-processor", "got session_id", { sessionId });
+
+  emitToSocket(socketId, "selenium:uniteducard_claim_started", { session_id: sessionId, jobId });
+
+  const seleniumResult = await pollUntilDone(sessionId, socketId, jobId);
+
+  if (!seleniumResult || seleniumResult.status === "error") {
+    throw new Error(seleniumResult?.message ?? "United Ucard claim session returned an error");
+  }
+
+  const claimNumber: string | undefined = seleniumResult.claimNumber ?? undefined;
+  const pdf_url: string | undefined = seleniumResult.pdf_url ?? undefined;
+
+  if (claimId) {
+    try {
+      const updates: Record<string, any> = { status: "REVIEW" };
+      if (claimNumber) updates.claimNumber = claimNumber;
+      await storage.updateClaim(claimId, updates);
+      log("uniteducard-claim-processor", "claim record updated", { claimId, claimNumber });
+    } catch (e) {
+      log("uniteducard-claim-processor", "failed to update claim record (non-fatal)", { error: e });
+    }
+  }
+
+  // Auto-save PDF for batch-column calls (no socketId = no frontend listener)
+  if (pdf_url && !socketId) {
+    const claim = claimId ? await storage.getClaim(claimId).catch(() => null) : null;
+    const patientId = claim?.patientId ?? enrichedPayload?.claim?.patientId ?? enrichedPayload?.patientId;
+    if (patientId) await savePdfFromSelenium(pdf_url, Number(patientId), userId);
+  }
+
+  emitToSocket(socketId, "selenium:uniteducard_claim_completed", {
+    jobId,
+    claimId,
+    claimNumber,
+    pdf_url,
+    message: claimNumber
+      ? `United Ucard claim submitted — Claim #: ${claimNumber}`
+      : (seleniumResult?.message ?? "United Ucard claim submitted successfully"),
+  });
+
+  log("uniteducard-claim-processor", "done", { claimId, claimNumber });
+  return { status: "success", pdf_url, claimNumber };
+}

apps/Backend/src/queue/queues.ts

@@ -16,6 +16,7 @@ export type SeleniumJobType =
   | "cca-preauth-submit"
   | "ddma-claim-submit"
   | "tuftssco-claim-submit"
+  | "uniteducard-claim-submit"
   | "uniteddh-claim-submit"
   | "uniteddh-preauth-submit"
   | "tuftssco-preauth-submit"

apps/Backend/src/routes/claims.ts

@@ -590,6 +590,7 @@ function batchColumnDeriveSiteKey(provider: string): string {
   if (p.includes("ddma") || p.includes("delta dental ma")) return "DDMA";
   if (p.includes("tufts") || p.includes("dentaquest") || p === "tuftssco") return "TUFTS_SCO";
   if ((p.includes("united") && p.includes("sco")) || p.includes("dentalhub") || p === "united_sco") return "UNITED_SCO";
+  if (p.includes("ucard") || p.includes("onehealthcareid") || p.includes("one healthcare id")) return "UNITED_UCARD";
   return "MH"; // default fallback
 }
 
@@ -600,6 +601,7 @@ function batchColumnCanonicalName(siteKey: string): string {
     case "DDMA": return "Delta Dental MA";
     case "TUFTS_SCO": return "Tufts SCO";
     case "UNITED_SCO": return "United/DentalHub";
+    case "UNITED_UCARD": return "United Ucard";
     default: return "MassHealth";
   }
 }
@@ -979,6 +981,24 @@ router.post(
               enrichedPayload,
               claimId,
             });
+          } else if (siteKey === "UNITED_UCARD") {
+            const enrichedPayload = {
+              claim: {
+                ...baseClaimPayload,
+                insuranceProvider: "United Ucard",
+                insuranceSiteKey: "UNITED_UCARD",
+                uniteducardUsername: credentials.username,
+                uniteducardPassword: credentials.password,
+                providerName: resolvedNpiProvider?.providerName ?? "",
+                claimFiles: diskClaimFiles,
+              },
+            };
+            jobId = enqueueSeleniumJob({
+              jobType: "uniteducard-claim-submit",
+              userId: req.user.id,
+              enrichedPayload,
+              claimId,
+            });
           } else {
             resultItem.error = `Unsupported insurance type: ${siteKey}`;
             results.push(resultItem);

apps/Backend/src/routes/index.ts

@@ -24,6 +24,7 @@ import insuranceStatusUnitedDHClaimRoutes from "./insuranceStatusUnitedDHClaim";
 import insuranceStatusUnitedDHPreAuthRoutes from "./insuranceStatusUnitedDHPreAuth";
 import insuranceStatusTuftsSCOClaimRoutes from "./insuranceStatusTuftsSCOClaim";
 import insuranceStatusTuftsSCOPreAuthRoutes from "./insuranceStatusTuftsSCOPreAuth";
+import insuranceStatusUnitedUcardClaimRoutes from "./insuranceStatusUnitedUcardClaim";
 import paymentsRoutes from "./payments";
 import databaseManagementRoutes from "./database-management";
 import notificationsRoutes from "./notifications";
@@ -78,6 +79,7 @@ router.use("/claims", insuranceStatusUnitedDHClaimRoutes);
 router.use("/claims", insuranceStatusUnitedDHPreAuthRoutes);
 router.use("/claims", insuranceStatusTuftsSCOClaimRoutes);
 router.use("/claims", insuranceStatusTuftsSCOPreAuthRoutes);
+router.use("/claims", insuranceStatusUnitedUcardClaimRoutes);
 router.use("/payments", paymentsRoutes);
 router.use("/database-management", databaseManagementRoutes);
 router.use("/notifications", notificationsRoutes);

apps/Backend/src/routes/insuranceStatusUnitedUcardClaim.ts

@@ -0,0 +1,104 @@
+import { Router, Request, Response } from "express";
+import { storage } from "../storage";
+import { enqueueSeleniumJob } from "../queue/jobRunner";
+import { forwardOtpToSeleniumUnitedUcardClaimAgent } from "../services/seleniumUnitedUcardClaimClient";
+import { io } from "../socket";
+import { prisma as db } from "@repo/db/client";
+
+const router = Router();
+
+/**
+ * POST /uniteducard-claim
+ *
+ * Enqueues a United Ucard (UHC Dental) claim submission job.
+ *
+ * Body fields (JSON):
+ *   data     — claim payload (memberId, dateOfBirth, serviceDate, serviceLines, patientName, etc.)
+ *   socketId — socket.io client id
+ *   claimId  — existing claim DB id (optional)
+ *
+ * Response: { status: "queued", jobId: "…" }
+ */
+router.post("/uniteducard-claim", async (req: Request, res: Response): Promise<any> => {
+  if (!req.user?.id) {
+    return res.status(401).json({ error: "Unauthorized: user info missing" });
+  }
+
+  try {
+    const claimData =
+      typeof req.body.data === "string"
+        ? JSON.parse(req.body.data)
+        : req.body.data ?? req.body ?? {};
+
+    // Fetch United Ucard (UHC Dental / OneHealthcareID) credentials
+    const credentials = await storage.getInsuranceCredentialByUserAndSiteKey(
+      req.user.id,
+      "UNITED_UCARD"
+    );
+    if (!credentials) {
+      return res.status(404).json({
+        error: "No United Ucard credentials found. Please add them on the Settings page.",
+      });
+    }
+
+    const seleniumSettings = await db.seleniumSettings.findUnique({ where: { userId: req.user.id } });
+
+    // Default provider (sorted by sortOrder asc, then id asc) — used for the
+    // provider signature field on the Review and Sign step.
+    const npiProviders = await storage.getNpiProvidersByUser(req.user.id);
+    const primaryProvider = npiProviders[0];
+
+    const enrichedPayload = {
+      claim: {
+        ...claimData,
+        uniteducardUsername: credentials.username,
+        uniteducardPassword: credentials.password,
+        paymentGroupId: seleniumSettings?.paymentGroupId ?? "",
+        providerName: primaryProvider?.providerName ?? "",
+      },
+    };
+
+    const socketId: string | undefined = req.body.socketId;
+    const claimId: number | undefined = claimData.claimId
+      ? Number(claimData.claimId)
+      : undefined;
+
+    const jobId = enqueueSeleniumJob({
+      jobType: "uniteducard-claim-submit",
+      userId: req.user.id,
+      socketId,
+      enrichedPayload,
+      claimId,
+    });
+
+    return res.json({ status: "queued", jobId });
+  } catch (err: any) {
+    console.error("[uniteducard-claim route] error:", err);
+    return res.status(500).json({
+      error: err.message || "Failed to enqueue United Ucard claim job",
+    });
+  }
+});
+
+/**
+ * POST /claims/uniteducard-claim/selenium/submit-otp
+ * Body: { session_id, otp, socketId? }
+ */
+router.post("/uniteducard-claim/selenium/submit-otp", async (req: Request, res: Response): Promise<any> => {
+  const { session_id: sessionId, otp, socketId } = req.body;
+  if (!sessionId || !otp) {
+    return res.status(400).json({ error: "session_id and otp are required" });
+  }
+  try {
+    const r = await forwardOtpToSeleniumUnitedUcardClaimAgent(sessionId, otp);
+    if (socketId && io) {
+      io.to(socketId).emit("selenium:otp_submitted", { session_id: sessionId });
+    }
+    return res.json(r);
+  } catch (err: any) {
+    console.error("[uniteducard-claim] submit-otp failed:", err?.message);
+    return res.status(500).json({ error: err?.message || "Failed to forward OTP" });
+  }
+});
+
+export default router;

apps/Backend/src/services/seleniumUnitedUcardClaimClient.ts

@@ -0,0 +1,35 @@
+import axios from "axios";
+
+const SELENIUM_BASE = process.env.SELENIUM_SERVICE_URL ?? "http://localhost:5002";
+
+/**
+ * POST /uniteducard-claim
+ * Returns { status: "started", session_id: "<uuid>" }
+ */
+export async function forwardToSeleniumUnitedUcardClaimAgent(
+  data: Record<string, any>
+): Promise<{ status: string; session_id: string }> {
+  const resp = await axios.post(`${SELENIUM_BASE}/uniteducard-claim`, data);
+  return resp.data;
+}
+
+/**
+ * GET /session/{sid}/status
+ */
+export async function getSeleniumUnitedUcardClaimSessionStatus(
+  sessionId: string
+): Promise<Record<string, any>> {
+  const resp = await axios.get(`${SELENIUM_BASE}/session/${sessionId}/status`);
+  return resp.data;
+}
+
+/**
+ * POST /submit-otp
+ */
+export async function forwardOtpToSeleniumUnitedUcardClaimAgent(
+  sessionId: string,
+  otp: string
+): Promise<Record<string, any>> {
+  const resp = await axios.post(`${SELENIUM_BASE}/submit-otp`, { session_id: sessionId, otp });
+  return resp.data;
+}