fix(money): consolidated review-triage follow-ups across session PRs

__tests__/enterprise/sweep-stuck-webhook-events.test.ts

@@ -50,6 +50,8 @@ const mockWe = (
       findMany: jest.Mock;
       findUnique: jest.Mock;
       update: jest.Mock;
+      // #1205-triage — the sweeper's claim CAS before each re-drive.
+      updateMany: jest.Mock;
     };
   }
 ).webhookEvent;
@@ -60,6 +62,7 @@ const stuckRow = (over: Record<string, unknown> = {}) => ({
   eventType: "payment.captured",
   payload: { payment: { entity: { id: "pay_1" } } },
   receivedAt: new Date("2026-06-01T00:00:00Z"),
+  claimedAt: null as Date | null | undefined,
   ...over,
 });
 
@@ -69,6 +72,36 @@ beforeEach(() => {
 });
 
 describe("sweepStuckWebhookEvents (#785)", () => {
+  it("a LOST claim (claimedAt raced) skips the re-drive entirely (#1205-triage)", async () => {
+    const ev = stuckRow();
+    (mockWe.findMany as jest.Mock).mockResolvedValue([ev]);
+    // Another driver claimed between selection and claim: CAS misses.
+    (mockWe.updateMany as jest.Mock).mockResolvedValue({ count: 0 });
+
+    const result = await sweepStuckWebhookEvents({ staleMinutes: 6 });
+
+    expect(processRazorpayWebhookEvent).not.toHaveBeenCalled();
+    expect(result.recovered).toBe(0);
+  });
+
+  it("the claim CAS keys on claimedAt, not receivedAt (age must survive re-drives)", async () => {
+    const ev = stuckRow();
+    (mockWe.findMany as jest.Mock).mockResolvedValue([ev]);
+    (mockWe.updateMany as jest.Mock).mockResolvedValue({ count: 1 });
+
+    await sweepStuckWebhookEvents({ staleMinutes: 6 });
+
+    const [claim] = (mockWe.updateMany as jest.Mock).mock.calls;
+    expect(claim[0].where).toMatchObject({
+      eventId: ev.eventId,
+      OR: [{ claimedAt: null }, { claimedAt: ev.claimedAt }],
+    });
+    expect(claim[0].data.claimedAt).toBeInstanceOf(Date);
+    // receivedAt untouched — the give-up cap ages on it.
+    expect(claim[0].where.receivedAt).toBeUndefined();
+    expect(claim[0].data.receivedAt).toBeUndefined();
+  });
+
   it("re-drives a stuck event and reconstructs the full envelope", async () => {
     mockWe.findMany.mockResolvedValue([stuckRow()]);
     mockProcess.mockResolvedValue(undefined);

__tests__/enterprise/with-cron-lock.test.ts

@@ -118,6 +118,45 @@ describe("withCronLock", () => {
     expect(fn).not.toHaveBeenCalled();
   });
 
+  it("#1205-triage: breaker OPEN at acquire → CronLockUnavailableError (pages), not a held skip", async () => {
+    mockAcquire.mockResolvedValue(null);
+    mockHealth.mockResolvedValue(true); // pre-acquire health passes
+    const { isRedisCircuitOpen } = jest.requireMock("../../lib/redis") as {
+      isRedisCircuitOpen: jest.Mock;
+    };
+    isRedisCircuitOpen.mockReturnValue(true);
+
+    const fn = jest.fn().mockResolvedValue("done");
+    const err = await withCronLock("dunning", { failMode: "closed" }, fn).catch(
+      (e: unknown) => e,
+    );
+    expect(err).toBeInstanceOf(CronLockUnavailableError);
+    expect(fn).not.toHaveBeenCalled();
+  });
+
+  it("#1205-triage: null acquire + Redis downed AFTER a healthy gate pages too", async () => {
+    // The first-four-failures window: breaker CLOSED, but every op fails —
+    // acquire returns null via the error fallback while isRedisCircuitOpen()
+    // is false. Only the fresh health probe distinguishes this from "held".
+    // Healthy at the pre-acquire gate (Redis reachable then), down by the
+    // post-null re-probe — exactly the mid-window failure the old code
+    // misclassified as CronLockHeldError.
+    mockHealth.mockResolvedValueOnce(true).mockResolvedValueOnce(false);
+    mockAcquire.mockResolvedValue(null);
+    const { isRedisCircuitOpen } = jest.requireMock("../../lib/redis") as {
+      isRedisCircuitOpen: jest.Mock;
+    };
+    isRedisCircuitOpen.mockReturnValue(false);
+    const fn = jest.fn().mockResolvedValue("done");
+
+    const err = await withCronLock("dunning", { failMode: "closed" }, fn).catch(
+      (e: unknown) => e,
+    );
+    expect(err).toBeInstanceOf(CronLockUnavailableError);
+    // Two probes total: the pre-acquire gate + the post-null re-probe.
+    expect(mockHealth).toHaveBeenCalledTimes(2);
+  });
+
   it("fail-closed: refuses to run when Redis is unhealthy (circuit open)", async () => {
     mockHealth.mockResolvedValue(false);
     await expect(

__tests__/payments/checkout-lock-ttl.test.ts

@@ -7,31 +7,27 @@
  * serverless-freeze worst case for CLASS: the platform can suspend the lock
  * holder AFTER the single checked renewal while Redis keeps counting the TTL
  * down, so the old 300s CLASS budget could expire mid-checkout and admit a
- * second instance. Source-contract pins (same idiom as
- * idempotency-minting.test.ts) freeze the values until someone deliberately
- * re-litigates them.
+ * second instance.
+ *
+ * Asserts the IMPORTED constant (CodeRabbit #1220 triage): source-text regexes
+ * break on formatter changes (600_000 ↔ 600000) and pass through duplicate-key
+ * overrides — neither can lie here.
  */
 
-import fs from "fs";
-import path from "path";
-
-const read = (rel: string) =>
-  fs.readFileSync(path.join(process.cwd(), rel), "utf8");
+import { CHECKOUT_LOCK_TTL_MS } from "../../utils/appointmentlock";
 
 describe("CHECKOUT_LOCK_TTL_MS (#832 serverless-freeze worst case)", () => {
-  const src = read("utils/appointmentlock.ts");
-
   it("raises CLASS to the documented freeze worst case: 600s", () => {
-    expect(src).toMatch(/CLASS:\s*600_000,/);
+    expect(CHECKOUT_LOCK_TTL_MS.CLASS).toBe(600_000);
   });
 
   it("no longer carries the insufficient 300s CLASS budget", () => {
-    expect(src).not.toMatch(/CLASS:\s*300_000/);
+    expect(CHECKOUT_LOCK_TTL_MS.CLASS).not.toBe(300_000);
   });
 
   it("keeps the smaller shapes on their sized #832 budgets", () => {
-    expect(src).toMatch(/CONSULTATION:\s*60_000,/);
-    expect(src).toMatch(/SUBSCRIPTION:\s*120_000,/);
-    expect(src).toMatch(/WEBINAR:\s*120_000,/);
+    expect(CHECKOUT_LOCK_TTL_MS.CONSULTATION).toBe(60_000);
+    expect(CHECKOUT_LOCK_TTL_MS.SUBSCRIPTION).toBe(120_000);
+    expect(CHECKOUT_LOCK_TTL_MS.WEBINAR).toBe(120_000);
   });
 });

__tests__/payments/checkout-open-order-reuse.test.ts

@@ -23,9 +23,13 @@ jest.mock("../../lib/prisma", () => ({
   default: {
     $transaction: jest.fn(async (fn: any, _opts?: unknown) => fn(txClient)),
     payment: {
-      findFirst: jest.fn(async ({ where }: any) =>
-        reuseState.rows.find((row) => matchesReuseWhere(row, where)) ?? null,
+      // #1220-triage — the reuse lookup fetches the newest scope-matching
+      // candidates; window/amount gates run in-code and rejects get
+      // superseded via updateMany.
+      findMany: jest.fn(async ({ where }: any) =>
+        reuseState.rows.filter((row) => matchesReuseWhere(row, where)),
       ),
+      updateMany: jest.fn(async () => ({ count: 1 })),
     },
     webinar: {
       findUnique: jest.fn(async () => webinarRow()),
@@ -239,7 +243,14 @@ function openSibling(overrides: Record<string, any> = {}) {
     amount: 100000,
     currency: "INR",
     appointmentId: "appt-w",
-    appointment: { webinarId: "evt-1" },
+    appointment: {
+      webinarId: "evt-1",
+      // Window gate reads the first slot (WEBINAR flow skips it, but keep the
+      // shape faithful for the direct unit cases below).
+      slotsOfAppointment: [
+        { startsAt: new Date("2026-09-01T10:00:00Z"), endsAt: new Date("2026-09-01T11:00:00Z") },
+      ],
+    },
     ...overrides,
   };
 }
@@ -327,7 +338,7 @@ describe("rec C — checkout adopts an open PENDING order across remounts", () =
 
     // The lookup must be scoped tightly — user + PENDING + fresh window +
     // org equality + gateway + this event's appointment join.
-    const where = (prisma.payment.findFirst as jest.Mock).mock.calls[0][0]
+    const where = (prisma.payment.findMany as jest.Mock).mock.calls[0][0]
       .where;
     expect(where).toMatchObject({
       userId: "user-1",
@@ -378,3 +389,125 @@ describe("rec C — checkout adopts an open PENDING order across remounts", () =
     expect(res.paymentIntent?.id).toBe("order_NEW");
   });
 });
+
+// ---------------------------------------------------------------------------
+// #1220-triage — the gates themselves, exercised directly (the webinar flow
+// above cannot discriminate them: eventId already pins scope and its fixtures
+// share one price).
+// ---------------------------------------------------------------------------
+import {
+  findReusablePendingOrderPayment,
+} from "../../lib/payments/operations/checkout";
+
+const SLOT = { startsAt: new Date("2026-09-01T10:00:00Z"), endsAt: new Date("2026-09-01T11:00:00Z") };
+const OTHER_SLOT = { startsAt: new Date("2026-09-02T10:00:00Z"), endsAt: new Date("2026-09-02T11:00:00Z") };
+
+function gateDb(rows: Array<Record<string, unknown>>) {
+  return { payment: { findMany: async () => rows } };
+}
+
+describe("#1220-triage — reuse gates", () => {
+  test("CONSULTATION: a different slot time is superseded, never resumed", async () => {
+    const row = openSibling({
+      appointment: { consultationId: "cons_1", slotsOfAppointment: [OTHER_SLOT] },
+    });
+    const { reusable, supersede } = await findReusablePendingOrderPayment(
+      gateDb([row]) as never,
+      {
+        userId: "user-1",
+        appointmentType: "CONSULTATION",
+        planId: "plan-1",
+        organizationId: null,
+        paymentGateway: "RAZORPAY" as never,
+        expectedAmountPaise: 100_000,
+        slotWindow: SLOT,
+      },
+    );
+    expect(reusable).toBeNull();
+    expect(supersede).toEqual([{ id: "pay-open", reason: "slot-window-mismatch" }]);
+  });
+
+  test("CONSULTATION: identical slot window resumes", async () => {
+    const row = openSibling({
+      appointment: { consultationId: "cons_1", slotsOfAppointment: [SLOT] },
+    });
+    const { reusable, supersede } = await findReusablePendingOrderPayment(
+      gateDb([row]) as never,
+      {
+        userId: "user-1",
+        appointmentType: "CONSULTATION",
+        planId: "plan-1",
+        organizationId: null,
+        paymentGateway: "RAZORPAY" as never,
+        expectedAmountPaise: 100_000,
+        slotWindow: SLOT,
+      },
+    );
+    expect(reusable?.id).toBe("pay-open");
+    expect(supersede).toEqual([]);
+  });
+
+  test("amount parity gate: a stale frozen total is superseded, not resumed", async () => {
+    const row = openSibling({ amount: 80_000 }); // coupon changed since mint
+    const { reusable, supersede } = await findReusablePendingOrderPayment(
+      gateDb([row]) as never,
+      {
+        userId: "user-1",
+        appointmentType: "WEBINAR",
+        planId: "plan-1",
+        eventId: "evt-1",
+        organizationId: null,
+        paymentGateway: "RAZORPAY" as never,
+        expectedAmountPaise: 100_000,
+      },
+    );
+    expect(reusable).toBeNull();
+    expect(supersede).toEqual([{ id: "pay-open", reason: "amount-mismatch" }]);
+  });
+
+  test("SUBSCRIPTION: period mismatch supersedes; both-null request matches both-null rows only", async () => {
+    const withPeriod = openSibling({
+      id: "pay-period",
+      appointment: {
+        subscriptionId: "sub_1",
+        slotsOfAppointment: [SLOT],
+      },
+    });
+    const withoutPeriod = openSibling({
+      id: "pay-noperiod",
+      appointment: { subscriptionId: "sub_2", slotsOfAppointment: [] },
+    });
+
+    // Request WITH a period must not resume a period-less hold.
+    const gated = await findReusablePendingOrderPayment(
+      gateDb([withoutPeriod, withPeriod]) as never,
+      {
+        userId: "user-1",
+        appointmentType: "SUBSCRIPTION",
+        planId: "plan-1",
+        organizationId: null,
+        paymentGateway: "RAZORPAY" as never,
+        expectedAmountPaise: 100_000,
+        schedulingPeriod: SLOT,
+      },
+    );
+    expect(gated.reusable?.id).toBe("pay-period");
+    expect(gated.supersede.map((s) => s.id)).toEqual(["pay-noperiod"]);
+
+    // Keyless request must not resume a hold that carries a period.
+    const keyless = await findReusablePendingOrderPayment(
+      gateDb([withPeriod]) as never,
+      {
+        userId: "user-1",
+        appointmentType: "SUBSCRIPTION",
+        planId: "plan-1",
+        organizationId: null,
+        paymentGateway: "RAZORPAY" as never,
+        expectedAmountPaise: 100_000,
+        schedulingPeriod: null,
+      },
+    );
+    expect(keyless.reusable).toBeNull();
+    expect(keyless.supersede.map((s) => s.id)).toEqual(["pay-period"]);
+  });
+});