Apply the terminal freshness window to Live Activity alerts too

The freshness gate added for terminal push notifications left Live
Activity alerts unguarded: alertForNewlyTerminal could buzz on a
restart replay whenever the device's last delivered aggregate still
showed the thread as live, and the end-event fallback rang via
alertForTerminalAggregate precisely when the companion push had been
silenced for staleness. Both alert helpers now take nowMs and share
the same isFreshTerminalRow window as notificationForAggregate, so a
stale completion stays silent on every channel.

Author: cursoragent

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

@@ -1525,15 +1525,30 @@ describe("live activity alert decisions", () => {
       activities: [{ ...aggregate.activities[0]!, phase: "completed" as const, status: "Done" }],
     };
     expect(
-      ApnsDeliveries.alertForTerminalAggregate({ aggregate: terminalAggregate, preferences }),
+      ApnsDeliveries.alertForTerminalAggregate({
+        aggregate: terminalAggregate,
+        preferences,
+        nowMs: 0,
+      }),
     ).toEqual({ title: "Thread", body: "Done: Project" });
     expect(
       ApnsDeliveries.alertForTerminalAggregate({
         aggregate: terminalAggregate,
         preferences: { ...preferences, notifyOnCompletion: false },
+        nowMs: 0,
+      }),
+    ).toBeNull();
+    expect(
+      ApnsDeliveries.alertForTerminalAggregate({ aggregate: null, preferences, nowMs: 0 }),
+    ).toBeNull();
+    // A completion replayed long after the fact must not ring again.
+    expect(
+      ApnsDeliveries.alertForTerminalAggregate({
+        aggregate: terminalAggregate,
+        preferences,
+        nowMs: 10 * 60 * 1_000,
       }),
     ).toBeNull();
-    expect(ApnsDeliveries.alertForTerminalAggregate({ aggregate: null, preferences })).toBeNull();
   });
 
   it("alerts when a previously active thread finishes mid-flight", () => {
@@ -1552,6 +1567,7 @@ describe("live activity alert decisions", () => {
         previousAggregate: aggregate,
         nextAggregate: next,
         preferences,
+        nowMs: 0,
       }),
     ).toEqual({ title: "Thread", body: "Done: Project" });
     // The completion switch mutes it.
@@ -1560,6 +1576,7 @@ describe("live activity alert decisions", () => {
         previousAggregate: aggregate,
         nextAggregate: next,
         preferences: { ...preferences, notifyOnCompletion: false },
+        nowMs: 0,
       }),
     ).toBeNull();
     // No baseline means no transition to ring on.
@@ -1568,6 +1585,7 @@ describe("live activity alert decisions", () => {
         previousAggregate: null,
         nextAggregate: next,
         preferences,
+        nowMs: 0,
       }),
     ).toBeNull();
     // A Done row that was already terminal (or absent) before stays silent.
@@ -1576,13 +1594,25 @@ describe("live activity alert decisions", () => {
         previousAggregate: next,
         nextAggregate: next,
         preferences,
+        nowMs: 0,
       }),
     ).toBeNull();
     expect(
       ApnsDeliveries.alertForNewlyTerminal({
         previousAggregate: { ...aggregate, activities: [attentionRow] },
         nextAggregate: next,
         preferences,
+        nowMs: 0,
+      }),
+    ).toBeNull();
+    // A stale completion replayed after a restart (previous aggregate still
+    // shows the thread as running) must not ring the device again.
+    expect(
+      ApnsDeliveries.alertForNewlyTerminal({
+        previousAggregate: aggregate,
+        nextAggregate: next,
+        preferences,
+        nowMs: 10 * 60 * 1_000,
       }),
     ).toBeNull();
   });

infra/relay/src/agentActivity/ApnsDeliveries.ts

@@ -210,6 +210,20 @@ export function alertForAttentionTransition(input: {
   };
 }
 
+// Completions replayed long after the fact (server restarts republish every
+// recently-finished thread) must not ring the device again — on any channel:
+// push notifications, Live Activity update alerts, and end alerts all honor
+// the same freshness window.
+const TERMINAL_NOTIFICATION_FRESHNESS_MS = 2 * 60 * 1_000;
+
+function isFreshTerminalRow(row: { readonly updatedAt: string }, nowMs: number): boolean {
+  const updatedAtMs = Option.match(DateTime.make(row.updatedAt), {
+    onNone: () => null,
+    onSome: (dt) => dt.epochMilliseconds,
+  });
+  return updatedAtMs !== null && nowMs - updatedAtMs <= TERMINAL_NOTIFICATION_FRESHNESS_MS;
+}
+
 // Alert copy for an update whose aggregate contains threads that finished
 // (Done/Failed) since the previously delivered aggregate — the mid-flight
 // completion buzz while other agents keep the activity alive. Requires the
@@ -219,6 +233,7 @@ export function alertForNewlyTerminal(input: {
   readonly previousAggregate: RelayAgentActivityAggregateState | null;
   readonly nextAggregate: RelayAgentActivityAggregateState;
   readonly preferences: RelayAgentAwarenessPreferences | null;
+  readonly nowMs: number;
 }): ApnsLiveActivityAlert | null {
   if (input.previousAggregate === null) {
     return null;
@@ -230,6 +245,9 @@ export function alertForNewlyTerminal(input: {
     if (row.phase !== "completed" && row.phase !== "failed") {
       return false;
     }
+    if (!isFreshTerminalRow(row, input.nowMs)) {
+      return false;
+    }
     const previousPhase = previousPhases.get(row.threadId);
     return (
       previousPhase !== undefined &&
@@ -255,11 +273,15 @@ export function alertForNewlyTerminal(input: {
 export function alertForTerminalAggregate(input: {
   readonly aggregate: RelayAgentActivityAggregateState | null;
   readonly preferences: RelayAgentAwarenessPreferences | null;
+  readonly nowMs: number;
 }): ApnsLiveActivityAlert | null {
   const row = input.aggregate?.activities[0];
   if (!row || (row.phase !== "completed" && row.phase !== "failed")) {
     return null;
   }
+  if (!isFreshTerminalRow(row, input.nowMs)) {
+    return null;
+  }
   if (!alertAllowedForPhase(input.preferences, row.phase)) {
     return null;
   }
@@ -298,10 +320,6 @@ function shouldUpdateLiveActivity(input: {
   );
 }
 
-// Completions replayed long after the fact (server restarts republish every
-// recently-finished thread) must not ring the device again.
-const TERMINAL_NOTIFICATION_FRESHNESS_MS = 2 * 60 * 1_000;
-
 function notificationForAggregate(input: {
   readonly target: LiveActivities.TargetRow;
   readonly aggregate: RelayAgentActivityAggregateState | null;
@@ -318,14 +336,11 @@ function notificationForAggregate(input: {
   if (!activity) {
     return null;
   }
-  if (activity.phase === "completed" || activity.phase === "failed") {
-    const updatedAtMs = Option.match(DateTime.make(activity.updatedAt), {
-      onNone: () => null,
-      onSome: (dt) => dt.epochMilliseconds,
-    });
-    if (updatedAtMs === null || input.nowMs - updatedAtMs > TERMINAL_NOTIFICATION_FRESHNESS_MS) {
-      return null;
-    }
+  if (
+    (activity.phase === "completed" || activity.phase === "failed") &&
+    !isFreshTerminalRow(activity, input.nowMs)
+  ) {
+    return null;
   }
   const enabled =
     (activity.phase === "waiting_for_approval" && preferences.notifyOnApproval) ||
@@ -419,6 +434,7 @@ function chooseLiveActivityDelivery(input: {
             previousAggregate,
             nextAggregate,
             preferences,
+            nowMs: input.nowMs,
           }),
       }
     : "suppressed";
@@ -1100,6 +1116,7 @@ export const make = Effect.gen(function* () {
             : alertForTerminalAggregate({
                 aggregate: delivery.aggregate,
                 preferences: parsePreferences(input.target.preferences_json),
+                nowMs: input.nowMs,
               })
           : delivery.alert;
       const result = yield* deliveryQueue.enqueueLiveActivity({