fix(webapp,dashboard-agent): settle the work count on the chat on screen, and let an admin preview's watches alert

The launcher's work count is now taken with the chat the panel has on screen
left out — in the panel's own list and in the poll's server-side count alike —
instead of subtracting one afterwards, which under-counted whenever that chat
held nothing unseen and left a stale count on the closing edge.

The alert gate stopped deciding the admin preview differently from the agent's
own gate: `canAccessDashboardAgent` reads `admin` off the user row when the
caller has no session, so a watch an admin could create can still alert.

A `run_start` watch now offers the same Customize variants as the rest of its
family.

Author: kathiekiwi

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

@@ -22,7 +22,7 @@ import {
   writeAgentFullscreen,
 } from "./panel-layout";
 import { nextPendingTurnChatId } from "./pending-turn";
-import { nextVisibleChat, unreadWorkForDot, unreadWorkOnPanelClose } from "./unread-counts";
+import { nextVisibleChat } from "./unread-counts";
 import { startWakePolling, wakesToToast } from "./wake-poll";
 import { shouldPollWakeFeed, subscribeWatchActivity } from "./watch-activity";
 import {
@@ -95,14 +95,9 @@ export function DashboardAgent({
       // Same as the read.
     }
   }, []);
-  // A wake in the on-screen chat toasts but must not light the dot.
+  // A wake in the on-screen chat toasts but must not light the dot. Read by the poll callback,
+  // which outlives the render that started it, so it has to be a ref.
   const visibleChat = useRef<string | null>(null);
-  // Read by the poll callback, which outlives the render that started it: `open` in its closure
-  // is whatever it was when polling began, and opening the panel does not restart the poll.
-  const panelOpen = useRef(open);
-  useEffect(() => {
-    panelOpen.current = open;
-  }, [open]);
 
   // Switching environment re-runs the layout loader but does not remount it, so the seeds
   // above would keep the old environment's counts.
@@ -146,22 +141,10 @@ export function DashboardAgent({
     undefined
   );
 
-  // The panel's own count, off the chat list it has already marked read. Kept so the closing
-  // edge can settle the dot instead of waiting a poll for the open-chat subtraction to lift.
-  const panelWorkCount = useRef<number | null>(null);
-  const handleUnreadWorkChange = useCallback((count: number) => {
-    panelWorkCount.current = count;
-    setUnreadWork(count);
-  }, []);
-
   const setPanelOpen = useCallback((next: boolean) => {
     setOpen(next);
     // Pending requests must be dropped or a stale one re-applies on the next open.
     if (!next) {
-      setUnreadWork((shown) =>
-        unreadWorkOnPanelClose({ shown, panelCount: panelWorkCount.current })
-      );
-      panelWorkCount.current = null;
       visibleChat.current = null;
       setFullscreen(false);
       writeAgentFullscreen(false);
@@ -216,10 +199,14 @@ export function DashboardAgent({
     let cancelled = false;
     const load = async () => {
       try {
+        // The chat on screen is being read, so the server leaves it out of the work count
+        // rather than the client subtracting it back off afterwards.
+        const onScreen = visibleChat.current;
         // Bounded, so one stuck request can't hold the poll's in-flight guard.
-        const res = await fetch(`${actionPath}?unread=1`, {
-          signal: AbortSignal.timeout(UNREAD_REQUEST_TIMEOUT_MS),
-        });
+        const res = await fetch(
+          `${actionPath}?unread=1${onScreen ? `&chatId=${encodeURIComponent(onScreen)}` : ""}`,
+          { signal: AbortSignal.timeout(UNREAD_REQUEST_TIMEOUT_MS) }
+        );
         if (!res.ok) return;
         const data = (await res.json()) as {
           unreadWakes?: number;
@@ -232,13 +219,7 @@ export function DashboardAgent({
           (wake) => wake.unread && wake.chatId === visibleChat.current
         ).length;
         setUnreadWakes(Math.max(0, (data.unreadWakes ?? 0) - unreadInView));
-        setUnreadWork(
-          unreadWorkForDot({
-            reported: data.unreadWork,
-            panelOpen: panelOpen.current,
-            visibleChatId: visibleChat.current,
-          })
-        );
+        setUnreadWork(Math.max(0, data.unreadWork ?? 0));
 
         const fresh = wakesToToast(data.wakes, toastedWakes.current);
         for (const wake of fresh) rememberToasted(wake.watchId);
@@ -357,7 +338,8 @@ export function DashboardAgent({
                   newChatSeq={newChatSeq}
                   promotedPrompt={promotedPrompt}
                   onChatRead={markChatRead}
-                  onUnreadWorkChange={handleUnreadWorkChange}
+                  // The panel's own count, off the chat list it has already marked read.
+                  onUnreadWorkChange={setUnreadWork}
                   onTurnActivityChange={handleTurnActivityChange}
                   isFullscreen={fullscreen}
                   onToggleFullscreen={toggleFullscreen}

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

@@ -334,8 +334,8 @@ export function DashboardAgentPanel({
   // The one source for the dot's work count: nudging it per open double-subtracts.
   useEffect(() => {
     if (!chatsLoaded) return;
-    onUnreadWorkChange?.(unreadWorkCount(chats));
-  }, [chats, chatsLoaded, onUnreadWorkChange]);
+    onUnreadWorkChange?.(unreadWorkCount(chats, active?.chatId));
+  }, [chats, chatsLoaded, active?.chatId, onUnreadWorkChange]);
 
   // Bound to its chat, which remounts with a fresh guard ref on every switch.
   const [sendRequest, setSendRequest] = useState<

apps/webapp/app/components/dashboard-agent/unread-counts.test.ts

@@ -1,12 +1,6 @@
 import { readFileSync } from "node:fs";
 import { describe, expect, it } from "vitest";
-import {
-  markChatListRead,
-  nextVisibleChat,
-  unreadWorkCount,
-  unreadWorkForDot,
-  unreadWorkOnPanelClose,
-} from "./unread-counts";
+import { markChatListRead, nextVisibleChat, unreadWorkCount } from "./unread-counts";
 
 const list = () => [
   { id: "chat_a", hasUnreadWake: true, hasUnreadWork: true },
@@ -59,45 +53,21 @@ describe("nextVisibleChat", () => {
 });
 
 /**
- * The chat on screen is being read, so it isn't work waiting for anyone — but only while the
- * panel is actually open.
+ * A turn landing in the chat on screen must not light the dot — and the chat is left out of the
+ * count rather than subtracted off it afterwards, so a chat holding nothing is never subtracted.
  */
-describe("unreadWorkForDot", () => {
-  it("subtracts the chat the panel is showing", () => {
-    expect(unreadWorkForDot({ reported: 3, panelOpen: true, visibleChatId: "chat_a" })).toBe(2);
+describe("the chat on screen", () => {
+  it("is left out, however much work lands in it", () => {
+    expect(unreadWorkCount(list(), "chat_a")).toBe(1);
   });
 
-  it("counts every chat when the panel is closed", () => {
-    expect(unreadWorkForDot({ reported: 3, panelOpen: false, visibleChatId: "chat_a" })).toBe(3);
-    expect(unreadWorkForDot({ reported: 3, panelOpen: true, visibleChatId: null })).toBe(3);
+  it("takes nothing off the count when it holds no unseen work", () => {
+    expect(unreadWorkCount(list(), "chat_c")).toBe(2);
   });
 
-  it("never reports a negative count, or one the poll didn't give", () => {
-    expect(unreadWorkForDot({ reported: 0, panelOpen: true, visibleChatId: "chat_a" })).toBe(0);
-    expect(unreadWorkForDot({ reported: undefined, panelOpen: false, visibleChatId: null })).toBe(
-      0
-    );
-  });
-});
-
-/**
- * Closing the panel stops the chat on screen being read, so the one the open panel took off the
- * count comes straight back rather than a poll later.
- */
-describe("unreadWorkOnPanelClose", () => {
-  it("settles the dot on the panel's own count", () => {
-    const open = unreadWorkForDot({ reported: 1, panelOpen: true, visibleChatId: "chat_a" });
-    expect(open).toBe(0);
-    // Work landed in another chat while chat_a was on screen: the panel's list still counts it.
-    expect(unreadWorkOnPanelClose({ shown: open, panelCount: 1 })).toBe(1);
-  });
-
-  it("leaves the shown count alone when the panel closed before its list loaded", () => {
-    expect(unreadWorkOnPanelClose({ shown: 2, panelCount: null })).toBe(2);
-  });
-
-  it("takes the panel's zero too, so reading the last chat darkens the dot at once", () => {
-    expect(unreadWorkOnPanelClose({ shown: 1, panelCount: 0 })).toBe(0);
+  it("counts every chat when there is none on screen", () => {
+    expect(unreadWorkCount(list(), null)).toBe(2);
+    expect(unreadWorkCount(list(), undefined)).toBe(2);
   });
 });
 
@@ -106,7 +76,7 @@ describe("what the panel and the layout actually do with it", () => {
   const layout = readFileSync(new URL("./DashboardAgent.tsx", import.meta.url), "utf8");
 
   it("reports the count from the list, and only from the list", () => {
-    expect(panel).toContain("onUnreadWorkChange?.(unreadWorkCount(chats));");
+    expect(panel).toContain("onUnreadWorkChange?.(unreadWorkCount(chats, active?.chatId));");
     expect(panel).not.toContain("settled.filter((chat) => chat.hasUnreadWork).length");
     expect(layout).not.toContain("setUnreadWork((count) => Math.max(0, count - 1))");
   });
@@ -118,22 +88,14 @@ describe("what the panel and the layout actually do with it", () => {
   });
 
   /**
-   * The poll runs for as long as this tab is watching, so anything it reads about the panel has
-   * to come from a ref. `open` is state: the callback would keep the value it had when polling
-   * started, which is `false`, and the dot would go on counting the chat on screen.
+   * Structural: there is no DOM here to open a panel in. The poll runs for as long as this tab
+   * is watching, so the chat on screen has to be read from a ref at request time — `open` in the
+   * callback's closure is whatever it was when polling started.
    */
-  it("reads the panel's state at poll time, not from the closure", () => {
-    expect(layout).toContain("panelOpen: panelOpen.current,");
-    expect(layout).not.toContain("open && visibleChat.current");
-  });
-
-  /** Structural: there is no DOM here to close a real panel in. */
-  it("settles the count on the closing edge instead of waiting for the poll", () => {
-    expect(panel).toContain("onUnreadWorkChange?.(unreadWorkCount(chats));");
-    expect(layout).toContain("panelWorkCount.current = count;");
-    expect(layout).toContain(
-      "unreadWorkOnPanelClose({ shown, panelCount: panelWorkCount.current })"
-    );
+  it("names the chat on screen to the poll instead of correcting the count it gets back", () => {
+    expect(layout).toContain("const onScreen = visibleChat.current;");
+    expect(layout).toContain("setUnreadWork(Math.max(0, data.unreadWork ?? 0));");
+    expect(layout).not.toContain("panelOpen.current");
   });
 
   it("re-seeds both counts when the environment changes under the layout", () => {

apps/webapp/app/components/dashboard-agent/unread-counts.ts

@@ -17,44 +17,18 @@ export function nextVisibleChat(chatId: string, options: { leaving: boolean }):
   return options.leaving ? null : chatId;
 }
 
-/**
- * The work count the launcher's dot shows, given what the poll just reported. A chat open in
- * the panel is being read right now, so it is not work anyone is waiting on.
- *
- * Both inputs have to be read at poll time rather than captured when the poll started: the
- * panel opens and closes without restarting it.
- */
-export function unreadWorkForDot(params: {
-  reported: number | undefined;
-  panelOpen: boolean;
-  visibleChatId: string | null;
-}): number {
-  const onScreen = params.panelOpen && params.visibleChatId !== null ? 1 : 0;
-  return Math.max(0, (params.reported ?? 0) - onScreen);
-}
-
-/**
- * The count the dot settles on the moment the panel closes. While the panel is open the poll
- * subtracts the chat on screen, and it only corrects itself a tick later — up to a minute of a
- * dark dot over work nobody has seen. The panel's own count is taken off the chat list it has
- * already marked read, so it settles the closing edge without waiting. `null` is a panel that
- * closed before its list loaded, which leaves the shown count alone.
- */
-export function unreadWorkOnPanelClose(params: {
-  shown: number;
-  panelCount: number | null;
-}): number {
-  return params.panelCount ?? params.shown;
-}
-
 /** Opening a chat settles everything unseen in it, not just the wake. */
 export function markChatListRead<T extends UnreadChat>(chats: T[], chatId: string): T[] {
   return chats.map((chat) =>
     chat.id === chatId ? { ...chat, hasUnreadWake: false, hasUnreadWork: false } : chat
   );
 }
 
-/** How many chats still hold work their owner hasn't seen. */
-export function unreadWorkCount(chats: UnreadChat[]): number {
-  return chats.filter((chat) => chat.hasUnreadWork).length;
+/**
+ * How many chats still hold work their owner hasn't seen. The chat on screen is being read
+ * right now, so a turn landing in it is not work anyone is waiting on — every count of this,
+ * here and on the server, leaves it out, so none of them has to be corrected afterwards.
+ */
+export function unreadWorkCount(chats: UnreadChat[], visibleChatId?: string | null): number {
+  return chats.filter((chat) => chat.hasUnreadWork && chat.id !== visibleChatId).length;
 }

apps/webapp/app/components/dashboard-agent/watch-card.test.ts

@@ -111,8 +111,8 @@ describe("cadence limits", () => {
 });
 
 describe("condition variants (§3)", () => {
-  it("offers the run pair and the whole queue family", () => {
-    expect(variantsOf(runDraft())).toEqual(["run_finished", "run_failed"]);
+  it("offers the whole run family and the whole queue family", () => {
+    expect(variantsOf(runDraft())).toEqual(["run_start", "run_finished", "run_failed"]);
     expect(variantsOf(queueDraft())).toEqual([
       "backlog_drain",
       "queue_depth_above",

apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.dashboard-agent.ts

@@ -139,6 +139,8 @@ export const loader = async ({ request, params }: LoaderFunctionArgs) => {
       countChatsWithUnreadWork(dashboardAgentDb, {
         organizationId: scoped.organizationId,
         userId,
+        // The chat the panel has on screen, if any: it is being read as this is counted.
+        excludeChatId: searchParams.get("chatId") ?? undefined,
       }),
     ]);
 

apps/webapp/app/services/dashboardAgentWatchAlerts.server.ts

@@ -86,12 +86,12 @@ export async function canUseDashboardAgentAlerts(params: {
   userId: string;
   organizationSlug: string;
   organizationId: string;
-  isAdmin?: boolean;
   orgFeatureFlags?: Record<string, unknown> | null;
 }): Promise<DashboardAgentAlertGate> {
   const hasAgent = await canAccessDashboardAgent({
+    // `isAdmin` is left out on purpose: there is no session here, so the gate reads it off
+    // the user row and a watch an admin could create can still alert.
     userId: params.userId,
-    isAdmin: params.isAdmin ?? false,
     // Never an impersonated session: this runs in the background.
     isImpersonating: false,
     organizationSlug: params.organizationSlug,

apps/webapp/app/v3/canAccessDashboardAgent.server.ts

@@ -10,16 +10,21 @@ import { makeFlag } from "~/v3/featureFlags.server";
  */
 export async function canAccessDashboardAgent(options: {
   userId: string;
-  isAdmin: boolean;
+  // Omitted by a caller with no session (a background job, a token-authenticated route),
+  // which is read off the user row instead so both answer the preview the same way.
+  isAdmin?: boolean;
   isImpersonating: boolean;
   organizationSlug: string;
   // The org's already-loaded `featureFlags`. Omitted means we query the org ourselves.
   orgFeatureFlags?: Record<string, unknown> | null;
 }): Promise<boolean> {
   const { userId, isAdmin, isImpersonating, organizationSlug, orgFeatureFlags } = options;
 
-  if ((isAdmin || isImpersonating) && env.DASHBOARD_AGENT_ADMIN_PREVIEW === "1") {
-    return true;
+  if (env.DASHBOARD_AGENT_ADMIN_PREVIEW === "1") {
+    const admin =
+      isAdmin ??
+      (await prisma.user.findFirst({ where: { id: userId }, select: { admin: true } }))?.admin;
+    if (admin || isImpersonating) return true;
   }
 
   let overrides = orgFeatureFlags;

apps/webapp/test/dashboardAgentAlertAdminPreview.test.ts

@@ -0,0 +1,46 @@
+/**
+ * A watch can only exist because its owner could use the agent, so the alert gate has to
+ * decide access the same way the agent's own gate does. There is no session behind these
+ * calls — the delivery job, and the agent's own token-authenticated routes — so the admin
+ * preview the agent honours has to be read off the user row.
+ */
+
+import { beforeEach, describe, expect, test, vi } from "vitest";
+
+const ctx = vi.hoisted(() => ({ admin: false }));
+
+vi.mock("~/db.server", () => {
+  const db = {
+    user: { findFirst: async () => ({ admin: ctx.admin }) },
+    organization: { findFirst: async () => ({ featureFlags: {} }) },
+    featureFlag: { findFirst: async () => null },
+  };
+  return { prisma: db, $replica: db, sqlDatabaseSchema: undefined };
+});
+
+process.env.SESSION_SECRET = "test-session-secret-for-alert-admin-preview";
+// The install this is previewed on: the flag is off for everyone else.
+process.env.DASHBOARD_AGENT_ADMIN_PREVIEW = "1";
+delete process.env.DASHBOARD_AGENT_ENABLED;
+
+const { canUseDashboardAgentAlerts } = await import("~/services/dashboardAgentWatchAlerts.server");
+
+const params = { userId: "user_1", organizationId: "org_1", organizationSlug: "acme" };
+
+beforeEach(() => {
+  ctx.admin = false;
+});
+
+describe("watch alerts during the admin preview", () => {
+  test("let an admin's watch alert, exactly as the agent lets them create it", async () => {
+    ctx.admin = true;
+    expect(await canUseDashboardAgentAlerts(params)).toEqual({ allowed: true });
+  });
+
+  test("stay shut for everyone the flag is still off for", async () => {
+    expect(await canUseDashboardAgentAlerts(params)).toEqual({
+      allowed: false,
+      reason: "dashboard_agent_disabled",
+    });
+  });
+});