fix(webapp): show the cumulative watch-result count in the grouped toast

Author: kathiekiwi

.server-changes/watch-summary-cumulative-count.md

@@ -0,0 +1,6 @@
+---
+area: webapp
+type: fix
+---
+
+The grouped "watch updates" notification now shows the total number of results waiting, instead of only the most recent batch's count.

apps/webapp/app/components/dashboard-agent/DashboardAgent.tsx

@@ -23,7 +23,7 @@ import {
 } from "./panel-layout";
 import { nextPendingTurnChatId } from "./pending-turn";
 import { nextVisibleChat } from "./unread-counts";
-import { startWakePolling, wakesToToast } from "./wake-poll";
+import { planWakeToasts, startWakePolling, wakesToToast } from "./wake-poll";
 import { shouldPollWakeFeed, subscribeWatchActivity } from "./watch-activity";
 import {
   showWatchWakesSummaryToast,
@@ -99,6 +99,11 @@ export function DashboardAgent({
   // which outlives the render that started it, so it has to be a ref.
   const visibleChat = useRef<string | null>(null);
 
+  // The count the still-visible grouped toast claims. Consecutive polls add to it so a
+  // later batch grows the summary instead of overwriting it with only its own count;
+  // reset when the user opens the panel from that toast.
+  const summaryPending = useRef(0);
+
   // Switching environment re-runs the layout loader but does not remount it, so the seeds
   // above would keep the old environment's counts.
   const seededEnvironment = useRef(environment.id);
@@ -224,11 +229,22 @@ export function DashboardAgent({
         const fresh = wakesToToast(data.wakes, toastedWakes.current);
         for (const wake of fresh) rememberToasted(wake.watchId);
 
-        if (fresh.length > WAKE_TOAST_MAX_INDIVIDUAL) {
-          showWatchWakesSummaryToast(fresh.length, () => setPanelOpen(true));
-        } else {
-          for (const wake of [...fresh].reverse()) {
-            showWatchWakeToast(wake, openChat);
+        if (fresh.length > 0) {
+          const { plan, pending } = planWakeToasts(
+            fresh,
+            summaryPending.current,
+            WAKE_TOAST_MAX_INDIVIDUAL
+          );
+          summaryPending.current = pending;
+          if (plan.mode === "summary") {
+            showWatchWakesSummaryToast(plan.count, () => {
+              summaryPending.current = 0;
+              setPanelOpen(true);
+            });
+          } else {
+            for (const wake of [...plan.wakes].reverse()) {
+              showWatchWakeToast(wake, openChat);
+            }
           }
         }
       } catch {

apps/webapp/app/components/dashboard-agent/wake-poll.test.ts

@@ -1,5 +1,10 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { startWakePolling, UNREAD_POLL_INTERVAL_MS, wakesToToast } from "./wake-poll";
+import {
+  planWakeToasts,
+  startWakePolling,
+  UNREAD_POLL_INTERVAL_MS,
+  wakesToToast,
+} from "./wake-poll";
 
 function harness() {
   let hidden = false;
@@ -124,3 +129,42 @@ describe("wakesToToast", () => {
     expect(wakesToToast(undefined, new Set())).toEqual([]);
   });
 });
+
+describe("planWakeToasts", () => {
+  const MAX = 3;
+  const batch = (n: number) => Array.from({ length: n }, (_, i) => i);
+
+  it("toasts a small batch individually but still counts it toward the running total", () => {
+    const { plan, pending } = planWakeToasts(batch(2), 0, MAX);
+
+    expect(plan).toEqual({ mode: "individual", wakes: [0, 1] });
+    expect(pending).toBe(2);
+  });
+
+  it("summarizes when a single batch is over the max", () => {
+    const { plan, pending } = planWakeToasts(batch(4), 0, MAX);
+
+    expect(plan).toEqual({ mode: "summary", count: 4 });
+    expect(pending).toBe(4);
+  });
+
+  it("accumulates across consecutive polls instead of showing only the latest", () => {
+    // First batch of 2 is below the max: individual toasts, nothing pending yet.
+    const first = planWakeToasts(batch(2), 0, MAX);
+    expect(first.plan.mode).toBe("individual");
+
+    // A second batch of 3 pushes the running total to 5, so the grouped toast claims
+    // the cumulative count, not just this batch's 3.
+    const second = planWakeToasts(batch(3), first.pending, MAX);
+    expect(second.plan).toEqual({ mode: "summary", count: 5 });
+    expect(second.pending).toBe(5);
+  });
+
+  it("grows the visible summary as later batches arrive", () => {
+    const first = planWakeToasts(batch(4), 0, MAX);
+    const second = planWakeToasts(batch(3), first.pending, MAX);
+
+    expect(second.plan).toEqual({ mode: "summary", count: 7 });
+    expect(second.pending).toBe(7);
+  });
+});

apps/webapp/app/components/dashboard-agent/wake-poll.ts

@@ -21,6 +21,30 @@ export function wakesToToast<T extends { watchId: string; unread?: boolean }>(
   return (wakes ?? []).filter((wake) => wake.unread === true && !toasted.has(wake.watchId));
 }
 
+export type WakeToastPlan<T> =
+  | { mode: "summary"; count: number }
+  | { mode: "individual"; wakes: T[] };
+
+/**
+ * Whether this poll's fresh wakes join a grouped summary or each get their own toast.
+ * `pending` is the running count of unacknowledged wakes carried from earlier polls; a
+ * batch that pushes the total past `max` shows the summary with that cumulative count, so
+ * a later batch adds to it rather than replacing it with only its own, smaller number.
+ * The returned `pending` is what the caller carries into the next poll; it resets to zero
+ * once the user acknowledges (opens the panel).
+ */
+export function planWakeToasts<T>(
+  fresh: T[],
+  pending: number,
+  max: number
+): { plan: WakeToastPlan<T>; pending: number } {
+  const total = pending + fresh.length;
+  if (total > max) {
+    return { plan: { mode: "summary", count: total }, pending: total };
+  }
+  return { plan: { mode: "individual", wakes: fresh }, pending: total };
+}
+
 export type WakePollOptions = {
   load: () => Promise<void>;
   isHidden: () => boolean;