@@ -22,7 +22,7 @@ import {
   writeAgentFullscreen,
 } from "./panel-layout";
 import { nextPendingTurnChatId } from "./pending-turn";
-import { nextVisibleChat, unreadWorkForDot } from "./unread-counts";
+import { nextVisibleChat, unreadWorkForDot, unreadWorkOnPanelClose } from "./unread-counts";
 import { startWakePolling, wakesToToast } from "./wake-poll";
 import { shouldPollWakeFeed, subscribeWatchActivity } from "./watch-activity";
 import {
@@ -146,10 +146,22 @@ 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);
@@ -345,7 +357,7 @@ export function DashboardAgent({
                   newChatSeq={newChatSeq}
                   promotedPrompt={promotedPrompt}
                   onChatRead={markChatRead}
-                  onUnreadWorkChange={setUnreadWork}
+                  onUnreadWorkChange={handleUnreadWorkChange}
                   onTurnActivityChange={handleTurnActivityChange}
                   isFullscreen={fullscreen}
                   onToggleFullscreen={toggleFullscreen}
 
@@ -28,6 +28,7 @@ import {
   pollSettledTranscript,
 } from "./settled-transcript";
 import { takeNavigateIntent } from "./turn-navigation";
+import { sendRequestOutcome } from "./send-request";
 import { teardownCancelsTurn, unmountTeardown } from "./turn-teardown";
 import { useAgentMessageQuota } from "./useAgentMessageQuota";
 import { useTriggerUriResolver } from "./useTriggerUriResolver";
@@ -226,13 +227,21 @@ export function DashboardAgentChat({
     [isStreaming, atMessageCap, sendMessage]
   );
 
-  // The panel only sends when the chat can take it, so this never lands mid-turn.
+  // The panel only sends when the chat can take it, so this never lands mid-turn. The cap it
+  // cannot see is why the request is held rather than consumed on sight.
   const sentRequestSeq = useRef<number | undefined>(undefined);
+  const canSend = !isStreaming && !atMessageCap;
   useEffect(() => {
-    if (!sendRequest || sentRequestSeq.current === sendRequest.seq) return;
+    if (!sendRequest) return;
+    const outcome = sendRequestOutcome({
+      requestSeq: sendRequest.seq,
+      consumedSeq: sentRequestSeq.current,
+      canSend,
+    });
+    if (outcome !== "send") return;
     sentRequestSeq.current = sendRequest.seq;
     submit(sendRequest.text);
-  }, [sendRequest, submit]);
+  }, [sendRequest, submit, canSend]);
 
   const retry = useCallback(() => {
     // A watch's consent record is a user message nobody typed, so retry never treats it as one.
 
@@ -0,0 +1,26 @@
+import { describe, expect, it } from "vitest";
+import { sendRequestOutcome } from "./send-request";
+
+describe("sendRequestOutcome", () => {
+  it("sends a request the chat can take", () => {
+    expect(sendRequestOutcome({ requestSeq: 1, consumedSeq: undefined, canSend: true })).toBe(
+      "send"
+    );
+  });
+
+  it("skips a request it has already sent", () => {
+    expect(sendRequestOutcome({ requestSeq: 1, consumedSeq: 1, canSend: true })).toBe("skip");
+  });
+
+  it("skips when nothing was asked for", () => {
+    expect(sendRequestOutcome({ requestSeq: undefined, consumedSeq: 3, canSend: true })).toBe(
+      "skip"
+    );
+  });
+
+  it("holds a request the chat can't take yet, and sends it once it can", () => {
+    expect(sendRequestOutcome({ requestSeq: 2, consumedSeq: 1, canSend: false })).toBe("hold");
+    // The held click is still the same request: nothing consumed it while it waited.
+    expect(sendRequestOutcome({ requestSeq: 2, consumedSeq: 1, canSend: true })).toBe("send");
+  });
+});
@@ -0,0 +1,17 @@
+/** What to do with a prompt the panel asked the chat to send. */
+export type SendRequestOutcome = "send" | "hold" | "skip";
+
+/**
+ * A click on a suggested prompt is consumed only once it has actually been sent. Marking it
+ * consumed first loses the click whenever the chat can't take it yet — the message cap being
+ * the case that has no other way back in — so an unsendable request is held for the next render.
+ */
+export function sendRequestOutcome(params: {
+  requestSeq: number | undefined;
+  consumedSeq: number | undefined;
+  canSend: boolean;
+}): SendRequestOutcome {
+  if (params.requestSeq === undefined) return "skip";
+  if (params.requestSeq === params.consumedSeq) return "skip";
+  return params.canSend ? "send" : "hold";
+}
@@ -5,6 +5,7 @@ import {
   nextVisibleChat,
   unreadWorkCount,
   unreadWorkForDot,
+  unreadWorkOnPanelClose,
 } from "./unread-counts";
 
 const list = () => [
@@ -79,6 +80,27 @@ describe("unreadWorkForDot", () => {
   });
 });
 
+/**
+ * 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);
+  });
+});
+
 describe("what the panel and the layout actually do with it", () => {
   const panel = readFileSync(new URL("./DashboardAgentPanel.tsx", import.meta.url), "utf8");
   const layout = readFileSync(new URL("./DashboardAgent.tsx", import.meta.url), "utf8");
@@ -105,6 +127,15 @@ describe("what the panel and the layout actually do with it", () => {
     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("re-seeds both counts when the environment changes under the layout", () => {
     expect(layout).toContain("seededEnvironment.current = environment.id;");
     expect(layout).toContain("setUnreadWakes(initialUnreadWakes);");
 
@@ -33,6 +33,20 @@ export function unreadWorkForDot(params: {
   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) =>
 
@@ -1,5 +1,10 @@
 import { json, type ActionFunctionArgs } from "@remix-run/server-runtime";
-import { cancelWatch, getWatch, recordWatchCheck } from "@internal/dashboard-agent-db";
+import {
+  cancelWatch,
+  getWatch,
+  recordWatchAttempt,
+  recordWatchCheck,
+} from "@internal/dashboard-agent-db";
 import { z } from "zod";
 import { dashboardAgentDb } from "~/services/dashboardAgentDb.server";
 import { logger } from "~/services/logger.server";
@@ -22,6 +27,8 @@ import {
 
 const ParamsSchema = z.object({ watchId: z.string().min(1) });
 
+// obs-map-disable error-classification -- arming the chain is best-effort: every error means the same thing, retry next check
+
 /** Best-effort: a chain that couldn't be armed returns `false` and is retried next check. */
 async function ensureBatchChain(watch: {
   id: string;
@@ -156,17 +163,23 @@ export async function action({ request, params }: ActionFunctionArgs) {
         })
     );
 
-    // Recorded even on the final evaluation. Guarded on `active`, so a concurrent
-    // fire/expire wins and this no-ops.
-    await recordWatchCheck(dashboardAgentDb, {
-      id: watchId,
-      lastResult: {
-        result: outcome.result,
-        facts: outcome.facts,
-        observed: outcome.observed,
-        final: body.final === true,
-      },
-    });
+    // Only a real evaluation is recorded, final or not: `unavailable` means nothing was read,
+    // so writing it would move `lastCheckedAt` and overwrite the facts a streak lives in.
+    // Guarded on `active`, so a concurrent fire/expire wins and this no-ops.
+    if (outcome.result !== "unavailable") {
+      await recordWatchCheck(dashboardAgentDb, {
+        id: watchId,
+        lastResult: {
+          result: outcome.result,
+          facts: outcome.facts,
+          observed: outcome.observed,
+          final: body.final === true,
+        },
+      });
+    } else {
+      // Looked at, not checked: the fairness key moves and nothing else does.
+      await recordWatchAttempt(dashboardAgentDb, { id: watchId });
+    }
 
     const batched = await ensureBatchChain(watch);
 
 
@@ -169,7 +169,11 @@ export async function readWatchQueueOldestAge(
   return { ageMs, source: "live_queue", current: true, asOf: now };
 }
 
-/** Same cap the queue detail page reads keys with. */
+/**
+ * Same cap the queue detail page reads keys with. It cannot under-report the wait: the ckIndex
+ * is scored by each key's oldest enqueue time and read ascending, so the oldest key is the first
+ * of the page whatever the cardinality.
+ */
 const OLDEST_AGE_CK_LIMIT = 50;
 
 const MINUTE_MS = 60_000;
 
@@ -12,8 +12,11 @@ import { afterEach, describe, expect } from "vitest";
 
 /**
  * `chats.last_read_at` is nullable and every reader treats NULL as unread, so without a
- * backfill the first load after rollout reports every pre-existing chat unread. Migration
- * 0002 backfills it; this replays the migrations against a real Postgres to prove it does.
+ * backfill the first load after rollout reports every pre-existing chat unread. Migrations
+ * 0002 and 0003 backfill it; this replays them against a real Postgres to prove they do.
+ *
+ * 0003 is the one that reaches a database where 0002 already ran, which is every database
+ * the column landed on before the backfill statement was appended to 0002.
  */
 
 const DRIZZLE = path.resolve(__dirname, "../../../internal-packages/dashboard-agent-db/drizzle");
@@ -22,6 +25,7 @@ const MIGRATIONS = [
   "0000_magenta_lilandra.sql",
   "0001_slimy_living_tribunal.sql",
   "0002_watches_and_chat_messages.sql",
+  "0003_backfill_chat_last_read_at.sql",
 ];
 
 /** The statement under test, located by shape so removing it fails rather than silently passing. */
@@ -135,3 +139,46 @@ describe("the last_read_at backfill in migration 0002", () => {
     }
   );
 });
+
+describe("the last_read_at catch-up in migration 0003", () => {
+  postgresTest(
+    "starts pre-existing chats read on a database that already ran 0002",
+    async ({ prisma, postgresContainer }) => {
+      await run(prisma, statementsOf(MIGRATIONS[0]!));
+      await run(prisma, statementsOf(MIGRATIONS[1]!));
+
+      // 0002 as it was already applied everywhere: the column, without the backfill that
+      // was appended to it later. Re-running 0002 there is impossible — its hash is spent.
+      const applied = statementsOf(MIGRATIONS[2]!).filter((statement) => !BACKFILL.test(statement));
+      await run(prisma, applied);
+      await seedPreExistingChats(prisma);
+      await prisma.$executeRawUnsafe(
+        `update "trigger_dashboard_agent"."chats" set "last_read_at" = $1 where "id" = 'chat_already_read'`,
+        ALREADY_READ_AT
+      );
+
+      agentDbClient = createDashboardAgentDb(postgresContainer.getConnectionUri(), { max: 2 });
+      const agentDb: DashboardAgentDb = agentDbClient.db;
+
+      // The bug 0003 exists for: every chat that predates the column reads as unread.
+      expect(await countChatsWithUnreadWork(agentDb, SCOPE)).toBe(1);
+
+      const catchUp = statementsOf(MIGRATIONS[3]!);
+      expect(catchUp.some((statement) => BACKFILL.test(statement))).toBe(true);
+      await run(prisma, catchUp);
+
+      expect(await readLastReadAt(prisma)).toEqual({
+        chat_with_messages: LAST_MESSAGE_AT,
+        chat_never_messaged: CREATED_AT,
+        chat_already_read: ALREADY_READ_AT,
+      });
+      expect(await countChatsWithUnreadWork(agentDb, SCOPE)).toBe(0);
+
+      // Still a dot for work that lands after the catch-up.
+      await prisma.$executeRawUnsafe(
+        `update "trigger_dashboard_agent"."chats" set "last_message_at" = now() where "id" = 'chat_with_messages'`
+      );
+      expect(await countChatsWithUnreadWork(agentDb, SCOPE)).toBe(1);
+    }
+  );
+});