Keep the arming clock fixed across same-token re-registrations

The end-on-empty grace window keys off remote_started_at, but register
refreshed it on every token upsert — including the foreground
reconciliation that re-registers the same token. An orphaned card whose
relay state was already empty then always replayed inside a fresh grace
window, so the live_activity_end it was waiting for never sent and the
stale card sat on the lock screen indefinitely.

The token claim now skips the device's own row, and the upsert only
resets remote_started_at when the token actually changed (a new
activity); re-registering the same token preserves the original arming
time so the grace expires as designed.

Author: cursoragent

infra/relay/src/agentActivity/LiveActivities.test.ts

@@ -109,10 +109,12 @@ describe("LiveActivities", () => {
             remoteStartedAt: null,
           }),
         ]);
+        // The claim skips this device's own row: it must stay intact so the
+        // upsert can tell a same-token re-registration apart from a fresh arm.
         expect(updateConditions.map((condition) => dialect.sqlToQuery(condition))).toEqual([
           {
-            sql: '"relay_live_activities"."activity_push_token" = $1',
-            params: ["activity-push-token"],
+            sql: '(("relay_live_activities"."activity_push_token" = $1) and ((("relay_live_activities"."user_id" <> $2) or ("relay_live_activities"."device_id" <> $3))))',
+            params: ["activity-push-token", "user-2", "device-1"],
           },
         ]);
         expect(insertedValues).toEqual([
@@ -131,12 +133,20 @@ describe("LiveActivities", () => {
           expect.objectContaining({
             activityPushToken: "activity-push-token",
             remoteStartQueuedAt: null,
-            remoteStartedAt: expect.any(String),
             endedAt: null,
             lastAggregateJson: null,
             lastLiveActivityDeliveryAt: null,
           }),
         );
+        // Re-registering the SAME token (foreground reconciliation) must not
+        // restart the arming clock, or the end-on-empty grace window would
+        // renew forever and orphaned cards would never receive their end.
+        const remoteStartedAtSet = dialect.sqlToQuery(
+          conflictConfigs[0]?.set?.remoteStartedAt as SQL,
+        );
+        expect(remoteStartedAtSet.sql.replace(/\s+/g, " ")).toBe(
+          'case when "relay_live_activities"."activity_push_token" = excluded.activity_push_token then coalesce("relay_live_activities"."remote_started_at", excluded.remote_started_at) else excluded.remote_started_at end',
+        );
       }).pipe(
         Effect.provide(
           LiveActivities.layer.pipe(Layer.provide(Layer.succeed(RelayDb.RelayDb, fakeDb))),

infra/relay/src/agentActivity/LiveActivities.ts

@@ -13,7 +13,7 @@ import * as Effect from "effect/Effect";
 import * as Function from "effect/Function";
 import * as Layer from "effect/Layer";
 import * as Schema from "effect/Schema";
-import { and, eq, sql } from "drizzle-orm";
+import { and, eq, ne, or, sql } from "drizzle-orm";
 
 import * as RelayDb from "../db.ts";
 import { relayLiveActivities, relayMobileDevices } from "../persistence/schema.ts";
@@ -141,6 +141,10 @@ export const make = Effect.gen(function* () {
         const updatedAt = DateTime.formatIso(yield* DateTime.now);
         const registration = input.registration;
 
+        // Claim the token from any OTHER row that still holds it (a token
+        // addresses exactly one activity). The device's own row is left
+        // untouched so the upsert below can tell a same-token re-registration
+        // apart from a fresh arm.
         yield* db
           .update(relayLiveActivities)
           .set({
@@ -150,7 +154,15 @@ export const make = Effect.gen(function* () {
             endedAt: updatedAt,
             updatedAt,
           })
-          .where(eq(relayLiveActivities.activityPushToken, registration.activityPushToken));
+          .where(
+            and(
+              eq(relayLiveActivities.activityPushToken, registration.activityPushToken),
+              or(
+                ne(relayLiveActivities.userId, input.userId),
+                ne(relayLiveActivities.deviceId, registration.deviceId),
+              ),
+            ),
+          );
 
         yield* db
           .insert(relayLiveActivities)
@@ -171,7 +183,17 @@ export const make = Effect.gen(function* () {
             set: {
               activityPushToken: registration.activityPushToken,
               remoteStartQueuedAt: null,
-              remoteStartedAt: updatedAt,
+              // remote_started_at records when the CARD was armed, and the
+              // end-on-empty grace window keys off it. Foreground
+              // reconciliation re-registers the same token periodically;
+              // refreshing the arming time there would perpetually renew the
+              // grace and suppress the end an orphaned card is waiting for.
+              // Only a new token (a new activity) restarts the clock.
+              remoteStartedAt: sql`case
+                when ${relayLiveActivities.activityPushToken} = excluded.activity_push_token
+                  then coalesce(${relayLiveActivities.remoteStartedAt}, excluded.remote_started_at)
+                else excluded.remote_started_at
+              end`,
               endedAt: null,
               lastAggregateJson: null,
               lastLiveActivityDeliveryAt: null,