fix(webapp): keep the wake poll running for a turn started behind a closed panel

DashboardAgent declared turnStarted but nothing set it, so a question asked
and then left with the panel closed raised no dot until the next reload.

The panel now reports turn activity up to DashboardAgent, which latches onto
the chat whose turn is running. Closing the panel reports nothing, so the
latch holds; re-opening the chat with the turn over clears it.

Author: kathiekiwi

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

@@ -23,6 +23,7 @@ import {
   readAgentFullscreen,
   writeAgentFullscreen,
 } from "./panel-layout";
+import { nextPendingTurnChatId } from "./pending-turn";
 import { startWakePolling } from "./wake-poll";
 import { shouldPollWakeFeed, subscribeWatchActivity } from "./watch-activity";
 import {
@@ -69,7 +70,10 @@ export function DashboardAgent({
   const [unreadWork, setUnreadWork] = useState(initialUnreadWork);
   // A turn this tab started may finish after the panel closes; that is exactly the case the
   // dot exists for, so the poll has to be running when it lands.
-  const [turnStarted, setTurnStarted] = useState(false);
+  const [pendingTurnChatId, setPendingTurnChatId] = useState<string | null>(null);
+  const handleTurnActivityChange = useCallback((chatId: string, active: boolean) => {
+    setPendingTurnChatId((current) => nextPendingTurnChatId(current, { chatId, active }));
+  }, []);
   const toastedWakes = useRef(new Set<string>());
   // The toast source is recent deliveries, not unread, so the dedupe must survive a reload.
   useEffect(() => {
@@ -169,15 +173,15 @@ export function DashboardAgent({
           serverUnreadWakes: initialUnreadWakes,
           serverHasActiveWatches: hasActiveWatches,
           serverUnreadWork: initialUnreadWork,
-          turnInFlight: turnStarted,
+          turnInFlight: pendingTurnChatId !== null,
           organizationId: organization.id,
         })
       )
         setWatching(true);
     };
     sync();
     return subscribeWatchActivity(sync);
-  }, [organization.id, initialUnreadWakes, hasActiveWatches, initialUnreadWork, turnStarted]);
+  }, [organization.id, initialUnreadWakes, hasActiveWatches, initialUnreadWork, pendingTurnChatId]);
 
   useEffect(() => {
     if (!hasAccess || !watching) return;
@@ -313,6 +317,7 @@ export function DashboardAgent({
                   promotedPrompt={promotedPrompt}
                   onChatRead={markChatRead}
                   onUnreadWorkChange={setUnreadWork}
+                  onTurnActivityChange={handleTurnActivityChange}
                   isFullscreen={fullscreen}
                   onToggleFullscreen={toggleFullscreen}
                 />

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

@@ -72,6 +72,7 @@ export function DashboardAgentPanel({
   watchRequest,
   onChatRead,
   onUnreadWorkChange,
+  onTurnActivityChange,
   isFullscreen = false,
   onToggleFullscreen,
 }: {
@@ -87,6 +88,8 @@ export function DashboardAgentPanel({
   onChatRead?: (chatId: string) => void;
   /** How many chats still hold work their owner hasn't seen. */
   onUnreadWorkChange?: (count: number) => void;
+  /** Whether a turn is running in a chat, so a closed panel still knows to expect an answer. */
+  onTurnActivityChange?: (chatId: string, active: boolean) => void;
 }) {
   const organization = useOrganization();
   const project = useProject();
@@ -130,11 +133,15 @@ export function DashboardAgentPanel({
   );
 
   const [thinkingChatId, setThinkingChatId] = useState<string | null>(null);
-  const handleActivityChange = useCallback((chatId: string, activity: TurnActivity | null) => {
-    setThinkingChatId((previous) =>
-      activity !== null ? chatId : previous === chatId ? null : previous
-    );
-  }, []);
+  const handleActivityChange = useCallback(
+    (chatId: string, activity: TurnActivity | null) => {
+      setThinkingChatId((previous) =>
+        activity !== null ? chatId : previous === chatId ? null : previous
+      );
+      onTurnActivityChange?.(chatId, activity !== null);
+    },
+    [onTurnActivityChange]
+  );
 
   const historyInFlight = useRef<Promise<void> | null>(null);
 

apps/webapp/app/components/dashboard-agent/pending-turn.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it } from "vitest";
+import { nextPendingTurnChatId } from "./pending-turn";
+import { shouldPollWakeFeed } from "./watch-activity";
+
+/**
+ * The launcher dot only appears if the wake poll is running when the answer lands. A turn
+ * started in the panel has to keep the poll alive across a close, and let go of it once the
+ * answer has been seen.
+ */
+describe("nextPendingTurnChatId", () => {
+  it("latches onto the chat whose turn started", () => {
+    expect(nextPendingTurnChatId(null, { chatId: "chat_a", active: true })).toBe("chat_a");
+  });
+
+  it("holds while a newer turn takes over", () => {
+    const afterA = nextPendingTurnChatId(null, { chatId: "chat_a", active: true });
+    expect(nextPendingTurnChatId(afterA, { chatId: "chat_b", active: true })).toBe("chat_b");
+  });
+
+  it("lets go once that chat's turn is no longer running", () => {
+    const pending = nextPendingTurnChatId(null, { chatId: "chat_a", active: true });
+    expect(nextPendingTurnChatId(pending, { chatId: "chat_a", active: false })).toBe(null);
+  });
+
+  it("keeps waiting when a different chat goes quiet", () => {
+    const pending = nextPendingTurnChatId(null, { chatId: "chat_a", active: true });
+    expect(nextPendingTurnChatId(pending, { chatId: "chat_b", active: false })).toBe("chat_a");
+  });
+
+  it("stays clear when nothing is pending", () => {
+    expect(nextPendingTurnChatId(null, { chatId: "chat_a", active: false })).toBe(null);
+  });
+});
+
+describe("a turn started behind a closed panel", () => {
+  // The page load knew of nothing: no wake, no watch, no unread work. Only the turn can
+  // start the poll.
+  const quietPageLoad = {
+    serverUnreadWakes: 0,
+    serverHasActiveWatches: false,
+    serverUnreadWork: 0,
+    organizationId: "org_quiet",
+  };
+
+  it("keeps the poll running until the answer is seen", () => {
+    expect(shouldPollWakeFeed({ ...quietPageLoad, turnInFlight: false })).toBe(false);
+
+    // Asked a question, then closed the panel: the panel reports no end, so the latch holds.
+    const pending = nextPendingTurnChatId(null, { chatId: "chat_a", active: true });
+    expect(shouldPollWakeFeed({ ...quietPageLoad, turnInFlight: pending !== null })).toBe(true);
+
+    // Re-opened the chat with the turn already over.
+    const seen = nextPendingTurnChatId(pending, { chatId: "chat_a", active: false });
+    expect(shouldPollWakeFeed({ ...quietPageLoad, turnInFlight: seen !== null })).toBe(false);
+  });
+});

apps/webapp/app/components/dashboard-agent/pending-turn.ts

@@ -0,0 +1,17 @@
+/**
+ * Which chat this tab is still waiting on. A turn started here can finish after the panel
+ * closes — the case the launcher dot exists for — so the wake poll has to keep running until
+ * the answer has been seen. The panel reports turn activity while it is mounted; closing it
+ * reports nothing, which is what leaves the latch set.
+ */
+
+/** `active` is true while a turn is running in `chatId`, false once it is not. */
+export function nextPendingTurnChatId(
+  current: string | null,
+  event: { chatId: string; active: boolean }
+): string | null {
+  if (event.active) return event.chatId;
+  // Only the chat we are waiting on clears the latch; another chat going quiet says nothing
+  // about this one.
+  return current === event.chatId ? null : current;
+}