feat: United/DentalHub claim submission automation and patient list sync

- Add full Selenium automation for United/DentalHub claim submission
  (steps 1-8: login, OTP, patient search, practitioner page, code entry,
  other coverage No, attachments, submit, Status & History PDF)
- Consolidate UnitedDH siteKey to UNITED_SCO throughout app
- Fix procedure date overwrite with Ctrl+A+Delete before typing service date
- Fix OTP popup reliability: emit every poll (no throttle)
- Fix Chrome session persistence: only clear cookies on startup
- Add touchPatient() to storage: claim submission now pushes patient to
  top of list across eligibility, claims, and documents pages

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

apps/Backend/src/queue/jobRunner.ts

@@ -19,6 +19,8 @@ import { runCCAEligibilityProcessor } from "./processors/ccaEligibilityProcessor
 import { runCCAClaimProcessor } from "./processors/ccaClaimProcessor";
 import { runCCAPreAuthProcessor } from "./processors/ccaPreAuthProcessor";
 import { runDDMAClaimProcessor } from "./processors/ddmaClaimProcessor";
+import { runUnitedDHClaimProcessor } from "./processors/unitedDHClaimProcessor";
+import { runTuftsSCOClaimProcessor } from "./processors/tuftsSCOClaimProcessor";
 import { runEligibilityHistoryProcessor } from "./processors/eligibilityHistoryProcessor";
 import { runCmspEligibilityHistoryRemainingProcessor } from "./processors/cmspEligibilityHistoryRemainingProcessor";
 import type { SeleniumJobData, OcrJobData } from "./queues";
@@ -168,6 +170,28 @@ export function enqueueSeleniumJob(data: SeleniumJobData): string {
         job.id
       );
     }
+    if (jobType === "uniteddh-claim-submit") {
+      return runUnitedDHClaimProcessor(
+        {
+          enrichedPayload: data.enrichedPayload,
+          userId: data.userId,
+          claimId: data.claimId,
+          socketId: data.socketId,
+        },
+        job.id
+      );
+    }
+    if (jobType === "tuftssco-claim-submit") {
+      return runTuftsSCOClaimProcessor(
+        {
+          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/ddmaClaimProcessor.ts

@@ -127,6 +127,13 @@ export async function runDDMAClaimProcessor(
       if (claimNumber) updates.claimNumber = claimNumber;
       await storage.updateClaim(claimId, updates);
       log("ddma-claim-processor", "claim record updated", { claimId, claimNumber });
+
+      // Touch patient so they rise to top of the list across all pages
+      const claim = await storage.getClaim(claimId);
+      if (claim?.patientId) {
+        await storage.touchPatient(claim.patientId);
+        log("ddma-claim-processor", "patient touched", { patientId: claim.patientId });
+      }
     } catch (e) {
       log("ddma-claim-processor", "failed to update claim record (non-fatal)", { error: e });
     }

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

@@ -0,0 +1,164 @@
+/**
+ * Processor for "uniteddh-claim-submit" jobs.
+ * Opens a claim on the United/DentalHub provider portal via Selenium.
+ *
+ * Flow:
+ *   1. POST /uniteddh-claim to Python agent → get session_id
+ *   2. Emit selenium:uniteddh_claim_started to frontend
+ *   3. Poll until completed/error
+ *   4. Emit result
+ */
+import {
+  forwardToSeleniumUnitedDHClaimAgent,
+  getSeleniumUnitedDHClaimSessionStatus,
+} from "../../services/seleniumUnitedDHClaimClient";
+import { io } from "../../socket";
+import { storage } from "../../storage";
+
+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 = 5 * 60 * 1000
+): Promise<any> {
+  const maxAttempts = 600;
+  const pollIntervalMs = 500;
+  const maxTransientErrors = 12;
+  const noProgressLimit = 240; // 120s of waiting_for_otp before giving up
+  let transientErrors = 0;
+  let consecutiveNoProgress = 0;
+  let lastStatus: string | null = null;
+  const deadline = Date.now() + pollTimeoutMs;
+
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    if (Date.now() > deadline) {
+      throw new Error(`UnitedDH claim polling timeout for session ${sessionId}`);
+    }
+    try {
+      const st = await getSeleniumUnitedDHClaimSessionStatus(sessionId);
+      const status: string = st?.status ?? "unknown";
+      log("uniteddh-claim-processor", `poll attempt=${attempt}`, { sessionId, status });
+      transientErrors = 0;
+
+      const isTerminal = status === "completed" || status === "error" || status === "not_found";
+      if (status === lastStatus && !isTerminal) {
+        consecutiveNoProgress++;
+      } else {
+        consecutiveNoProgress = 0;
+      }
+      lastStatus = status;
+
+      if (consecutiveNoProgress >= noProgressLimit) {
+        throw new Error(`No progress from Python agent (status="${status}") after ${consecutiveNoProgress} polls`);
+      }
+
+      if (status === "waiting_for_otp") {
+        // Emit every poll (same as eligibility) so the popup appears immediately
+        emitToSocket(socketId, "selenium:otp_required", {
+          session_id: sessionId,
+          jobId,
+          message: "OTP required. Please enter the OTP shown by the DentalHub portal.",
+        });
+        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 || `UnitedDH 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 UnitedDH 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(`UnitedDH claim polling exhausted all attempts for session ${sessionId}`);
+}
+
+export interface UnitedDHClaimProcessorInput {
+  enrichedPayload: any;
+  userId: number;
+  claimId?: number;
+  socketId?: string;
+}
+
+export async function runUnitedDHClaimProcessor(
+  input: UnitedDHClaimProcessorInput,
+  jobId: string
+): Promise<{ status: string; pdf_url?: string; claimNumber?: string }> {
+  const { enrichedPayload, userId, claimId, socketId } = input;
+
+  log("uniteddh-claim-processor", "starting Python agent session", { claimId });
+  const agentResp = await forwardToSeleniumUnitedDHClaimAgent(enrichedPayload);
+
+  if (!agentResp?.session_id) {
+    throw new Error("Python agent did not return a session_id for UnitedDH claim");
+  }
+
+  const sessionId = agentResp.session_id as string;
+  log("uniteddh-claim-processor", "got session_id", { sessionId });
+
+  emitToSocket(socketId, "selenium:uniteddh_claim_started", { session_id: sessionId, jobId });
+
+  const seleniumResult = await pollUntilDone(sessionId, socketId, jobId);
+
+  if (!seleniumResult || seleniumResult.status === "error") {
+    throw new Error(seleniumResult?.message ?? "UnitedDH 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("uniteddh-claim-processor", "claim record updated", { claimId, claimNumber });
+
+      // Touch patient so they rise to top of the list across all pages
+      const claim = await storage.getClaim(claimId);
+      if (claim?.patientId) {
+        await storage.touchPatient(claim.patientId);
+        log("uniteddh-claim-processor", "patient touched", { patientId: claim.patientId });
+      }
+    } catch (e) {
+      log("uniteddh-claim-processor", "failed to update claim record (non-fatal)", { error: e });
+    }
+  }
+
+  emitToSocket(socketId, "selenium:uniteddh_claim_completed", {
+    jobId,
+    claimId,
+    claimNumber,
+    pdf_url,
+    message: claimNumber
+      ? `United/DentalHub claim submitted — Claim #: ${claimNumber}`
+      : (seleniumResult?.message ?? "United/DentalHub claim submitted successfully"),
+  });
+
+  log("uniteddh-claim-processor", "done", { claimId, claimNumber });
+  return { status: "success", pdf_url, claimNumber };
+}

apps/Backend/src/routes/index.ts

@@ -19,6 +19,8 @@ import insuranceStatusCCARoutes from "./insuranceStatusCCA";
 import insuranceStatusCCAClaimRoutes from "./insuranceStatusCCAClaim";
 import insuranceStatusCCAPreAuthRoutes from "./insuranceStatusCCAPreAuth";
 import insuranceStatusDDMAClaimRoutes from "./insuranceStatusDDMAClaim";
+import insuranceStatusUnitedDHClaimRoutes from "./insuranceStatusUnitedDHClaim";
+import insuranceStatusTuftsSCOClaimRoutes from "./insuranceStatusTuftsSCOClaim";
 import paymentsRoutes from "./payments";
 import databaseManagementRoutes from "./database-management";
 import notificationsRoutes from "./notifications";
@@ -60,6 +62,8 @@ router.use("/insurance-status-cca", insuranceStatusCCARoutes);
 router.use("/claims", insuranceStatusCCAClaimRoutes);
 router.use("/claims", insuranceStatusCCAPreAuthRoutes);
 router.use("/claims", insuranceStatusDDMAClaimRoutes);
+router.use("/claims", insuranceStatusUnitedDHClaimRoutes);
+router.use("/claims", insuranceStatusTuftsSCOClaimRoutes);
 router.use("/payments", paymentsRoutes);
 router.use("/database-management", databaseManagementRoutes);
 router.use("/notifications", notificationsRoutes);

apps/Backend/src/storage/patients-storage.ts

@@ -15,6 +15,7 @@ export interface IStorage {
   getPatientsByIds(ids: number[]): Promise<Patient[]>;
   createPatient(patient: InsertPatient): Promise<Patient>;
   updatePatient(id: number, patient: UpdatePatient): Promise<Patient>;
+  touchPatient(id: number): Promise<void>;
   deletePatient(id: number): Promise<void>;
   searchPatients(args: {
     filters: any;
@@ -105,6 +106,15 @@ export const patientsStorage: IStorage = {
     }
   },
 
+  async touchPatient(id: number): Promise<void> {
+    try {
+      await db.patient.update({
+        where: { id },
+        data: { updatedAt: new Date() },
+      });
+    } catch (_) {}
+  },
+
   async deletePatient(id: number): Promise<void> {
     try {
       await db.patient.delete({ where: { id } });