@@ -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}
 
@@ -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<
 
@@ -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", () => {
 
@@ -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;
 }
@@ -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",
 
@@ -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,
       }),
     ]);
 
 
@@ -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,
 
@@ -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;
 
@@ -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",
+    });
+  });
+});