test(webapp): assert the cached idempotency loser resolves to the recreated run

Strengthen the reacquire cases (expired + failed winner) to assert the cached
loser's run.friendlyId is the RECREATED run (the other loser's fresh child), not
the cleared winner — so a stale isCached pointing at the cleared winner can't slip
past the count check. (CodeRabbit review.)

Author: d-cs

apps/webapp/test/idempotencyGlobalScopeCrossDbConcurrent.test.ts

@@ -792,32 +792,33 @@ describe("run-ops split — CONCURRENT global-scope idempotency dedup across two
       const taskIdentifier = "child-task";
       const concern = new IdempotencyKeyConcern(prisma14 as never, {} as never, {} as never);
 
-      const { bRes, cRes } = await driveWinnerPlusTwoLosers({
-        concern,
-        router,
-        buffer: bufferHarness,
-        env,
-        idempotencyKey,
-        taskIdentifier,
-        // Winner child is a genuinely-expired run: an EXPIRED status AND an already-expired key, so
-        // handleExistingRun's expiry branch clears it. Both attributes matter for determinism: the
-        // expiry drives the clear; the EXPIRED status keeps the SECOND loser on the clear path even
-        // after the first loser's clear has NULLed the key + expiry (a plain PENDING winner would
-        // then look "live" to the second reader and dedup by accident, masking the duplicate).
-        winnerSeed: { status: "EXPIRED", idempotencyKeyExpiresAt: new Date(Date.now() - 60_000) },
-        a: {
-          spec: { parentResidency: "NEW", idempotencyKey, scope: "global", taskIdentifier },
-          childResidency: "NEW",
-        },
-        b: {
-          spec: { parentResidency: "LEGACY", idempotencyKey, scope: "global", taskIdentifier },
-          childResidency: "LEGACY",
-        },
-        c: {
-          spec: { parentResidency: "NEW", idempotencyKey, scope: "global", taskIdentifier },
-          childResidency: "NEW",
-        },
-      });
+      const { bRes, cRes, childWFriendly, childBFriendly, childCFriendly } =
+        await driveWinnerPlusTwoLosers({
+          concern,
+          router,
+          buffer: bufferHarness,
+          env,
+          idempotencyKey,
+          taskIdentifier,
+          // Winner child is a genuinely-expired run: an EXPIRED status AND an already-expired key, so
+          // handleExistingRun's expiry branch clears it. Both attributes matter for determinism: the
+          // expiry drives the clear; the EXPIRED status keeps the SECOND loser on the clear path even
+          // after the first loser's clear has NULLed the key + expiry (a plain PENDING winner would
+          // then look "live" to the second reader and dedup by accident, masking the duplicate).
+          winnerSeed: { status: "EXPIRED", idempotencyKeyExpiresAt: new Date(Date.now() - 60_000) },
+          a: {
+            spec: { parentResidency: "NEW", idempotencyKey, scope: "global", taskIdentifier },
+            childResidency: "NEW",
+          },
+          b: {
+            spec: { parentResidency: "LEGACY", idempotencyKey, scope: "global", taskIdentifier },
+            childResidency: "LEGACY",
+          },
+          c: {
+            spec: { parentResidency: "NEW", idempotencyKey, scope: "global", taskIdentifier },
+            childResidency: "NEW",
+          },
+        });
 
       // The winner's key was cleared, so only the recreated child(ren) still carry the key. Exactly
       // ONE new child ⇒ the reacquire serialised the two losers' recreate across the split.
@@ -826,6 +827,14 @@ describe("run-ops split — CONCURRENT global-scope idempotency dedup across two
       // Exactly one loser recreated (claim reacquired); the other resolved to it as a cached hit.
       const cachedCount = [bRes, cRes].filter((r) => r.isCached).length;
       expect(cachedCount).toBe(1);
+      // The cached loser must resolve to the RECREATED run (the other loser's fresh child), NOT the
+      // cleared winner — a stale isCached still pointing at childWFriendly would otherwise slip past.
+      const recreaterFriendly = bRes.isCached ? childCFriendly : childBFriendly;
+      const cachedLoser = bRes.isCached ? bRes : cRes;
+      if (cachedLoser.isCached === true) {
+        expect(cachedLoser.run.friendlyId).toBe(recreaterFriendly);
+        expect(cachedLoser.run.friendlyId).not.toBe(childWFriendly);
+      }
       // Both losers genuinely contended on the claim (winner + two losers ⇒ ≥3 attempts).
       expect(bufferHarness.claimCalls).toBeGreaterThanOrEqual(3);
     }
@@ -847,33 +856,42 @@ describe("run-ops split — CONCURRENT global-scope idempotency dedup across two
       const taskIdentifier = "child-task";
       const concern = new IdempotencyKeyConcern(prisma14 as never, {} as never, {} as never);
 
-      const { bRes, cRes } = await driveWinnerPlusTwoLosers({
-        concern,
-        router,
-        buffer: bufferHarness,
-        env,
-        idempotencyKey,
-        taskIdentifier,
-        // Winner child carries a LIVE (future) key but a failed status → status-clear branch fires.
-        winnerSeed: { status: "COMPLETED_WITH_ERRORS" },
-        a: {
-          spec: { parentResidency: "NEW", idempotencyKey, scope: "global", taskIdentifier },
-          childResidency: "NEW",
-        },
-        b: {
-          spec: { parentResidency: "LEGACY", idempotencyKey, scope: "global", taskIdentifier },
-          childResidency: "LEGACY",
-        },
-        c: {
-          spec: { parentResidency: "NEW", idempotencyKey, scope: "global", taskIdentifier },
-          childResidency: "NEW",
-        },
-      });
+      const { bRes, cRes, childWFriendly, childBFriendly, childCFriendly } =
+        await driveWinnerPlusTwoLosers({
+          concern,
+          router,
+          buffer: bufferHarness,
+          env,
+          idempotencyKey,
+          taskIdentifier,
+          // Winner child carries a LIVE (future) key but a failed status → status-clear branch fires.
+          winnerSeed: { status: "COMPLETED_WITH_ERRORS" },
+          a: {
+            spec: { parentResidency: "NEW", idempotencyKey, scope: "global", taskIdentifier },
+            childResidency: "NEW",
+          },
+          b: {
+            spec: { parentResidency: "LEGACY", idempotencyKey, scope: "global", taskIdentifier },
+            childResidency: "LEGACY",
+          },
+          c: {
+            spec: { parentResidency: "NEW", idempotencyKey, scope: "global", taskIdentifier },
+            childResidency: "NEW",
+          },
+        });
 
       const counts = await countChildren(prisma14, prisma17, env, idempotencyKey, taskIdentifier);
       expect(counts.total).toBe(1);
       const cachedCount = [bRes, cRes].filter((r) => r.isCached).length;
       expect(cachedCount).toBe(1);
+      // The cached loser must resolve to the RECREATED run (the other loser's fresh child), NOT the
+      // cleared winner — a stale isCached still pointing at childWFriendly would otherwise slip past.
+      const recreaterFriendly = bRes.isCached ? childCFriendly : childBFriendly;
+      const cachedLoser = bRes.isCached ? bRes : cRes;
+      if (cachedLoser.isCached === true) {
+        expect(cachedLoser.run.friendlyId).toBe(recreaterFriendly);
+        expect(cachedLoser.run.friendlyId).not.toBe(childWFriendly);
+      }
       expect(bufferHarness.claimCalls).toBeGreaterThanOrEqual(3);
     }
   );