fix(webapp): decide the one-watch-button rule per turn, not per render_view

The flag was computed inside `ViewBlocks`, which sees the blocks of a single
`render_view` part. A turn that renders the investigation card in one call and
the actions block in another gave each call its own answer, and the duplicate
Watch button came back. It is now computed where every part of the message is
in scope; a card can still add its own offer, never drop the turn's.

Author: kathiekiwi

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

@@ -23,7 +23,8 @@ import { stripModelImages } from "./model-markdown";
 import { reportBlockFromToolPart } from "./report-block-adapter";
 import { shouldShowLiveTurnError } from "./turn-error";
 import type { ResolvedUri } from "./ReportView";
-import { answerContinuesAfter } from "./view-actions";
+import { answerContinuesAfter, turnAlreadyOffersWatch } from "./view-actions";
+import { latestRevisionBlocks } from "./view-blocks";
 import { ViewBlocks } from "./view-catalog";
 import { findWakeWatch, WakeBanner, wakeRefFromMessageId, type WakeWatch } from "./WakeBanner";
 
@@ -237,17 +238,28 @@ const DashboardAgentTurn = memo(function DashboardAgentTurn({
   const parts = message.parts ?? [];
   if (parts.length === 0) return null;
 
+  // Null for a part that renders no view at all; an empty array for one whose blocks were
+  // all superseded. Both skip the part, only the first falls through to the other renderers.
+  const blocksByPart = parts.map((part, i) => {
+    const raw = blocksFor(part);
+    return raw
+      ? withoutSupersededInvestigations(raw, `${message.id}:${i}`, investigationWinners)
+      : null;
+  });
+  // One answer for the whole turn: two `render_view` parts each deciding for themselves
+  // would show the watch button twice. `ViewBlocks` collapses revisions the same way.
+  const watchOfferedInTurn = turnAlreadyOffersWatch(
+    blocksByPart
+      .filter((blocks): blocks is unknown[] => blocks !== null)
+      .map((blocks) => latestRevisionBlocks(blocks as never))
+  );
+
   const body: React.ReactNode[] = [];
   for (let i = 0; i < parts.length; i++) {
     const part = parts[i]!;
 
-    const rawBlocks = blocksFor(part);
-    if (rawBlocks) {
-      const blocks = withoutSupersededInvestigations(
-        rawBlocks,
-        `${message.id}:${i}`,
-        investigationWinners
-      );
+    const blocks = blocksByPart[i];
+    if (blocks) {
       if (blocks.length > 0) {
         body.push(
           <ChatCardSlot key={i}>
@@ -257,6 +269,7 @@ const DashboardAgentTurn = memo(function DashboardAgentTurn({
               resolveUri={resolveUri}
               pagePaths={pagePaths}
               answered={answerContinuesAfter(parts as never, i)}
+              watchOfferedInTurn={watchOfferedInTurn}
             />
           </ChatCardSlot>
         );

apps/webapp/app/components/dashboard-agent/view-actions.test.ts

@@ -5,6 +5,7 @@ import {
   answerContinuesAfter,
   cardAlreadyOffersWatch,
   renderableActions,
+  turnAlreadyOffersWatch,
   withoutWatchActions,
 } from "./view-actions";
 
@@ -88,6 +89,24 @@ describe("one watch button per answer", () => {
     expect(cardAlreadyOffersWatch([])).toBe(false);
   });
 
+  // The bug this closes: one `render_view` call carries the investigation card and a second
+  // carries the actions block, so each call asked only about its own blocks and said no.
+  it("sees a watch offered by another of the same turn's render_view calls", () => {
+    const investigationCall = [card([watchAction])];
+    const actionsCall = [{ type: "actions", actions: [watchAction] }] as never[];
+
+    expect(cardAlreadyOffersWatch(actionsCall)).toBe(false);
+    // Either order: the card can be rendered before or after the block that repeats it.
+    expect(turnAlreadyOffersWatch([investigationCall, actionsCall])).toBe(true);
+    expect(turnAlreadyOffersWatch([actionsCall, investigationCall])).toBe(true);
+  });
+
+  it("says no when no call in the turn has a card offering one", () => {
+    const plain = [card([{ label: "Keep digging", intent: { kind: "ask", prompt: "" } }])];
+    expect(turnAlreadyOffersWatch([plain, []])).toBe(false);
+    expect(turnAlreadyOffersWatch([])).toBe(false);
+  });
+
   it("drops the model's duplicate offer, keeping everything else", () => {
     expect(
       withoutWatchActions([
@@ -116,3 +135,26 @@ describe("ActionsBlock", () => {
     expect(source).not.toMatch(/\.server"/);
   });
 });
+
+/**
+ * There is no rendering harness here, so this pins the wiring rather than the pixels: the
+ * turn-wide answer is computed where every part is in scope and reaches every card, and
+ * `ViewBlocks` can only add to it. What it does not prove is that the button disappears.
+ */
+describe("the one-watch-button flag is decided per turn, not per render_view call", () => {
+  const turn = readFileSync(new URL("./DashboardAgentMessages.tsx", import.meta.url), "utf8");
+  const catalog = readFileSync(new URL("./view-catalog.tsx", import.meta.url), "utf8");
+
+  it("computes it over every part's blocks, above the per-part loop", () => {
+    expect(turn).toContain("turnAlreadyOffersWatch(");
+    // Above the loop: computed from the whole `parts` map, not from one part.
+    expect(turn.indexOf("const watchOfferedInTurn")).toBeLessThan(
+      turn.indexOf("for (let i = 0; i < parts.length; i++)")
+    );
+    expect(turn).toContain("watchOfferedInTurn={watchOfferedInTurn}");
+  });
+
+  it("lets a card add its own offer but never drop the turn's", () => {
+    expect(catalog).toContain("watchOfferedInTurn || cardAlreadyOffersWatch(rendered)");
+  });
+});

apps/webapp/app/components/dashboard-agent/view-actions.ts

@@ -29,6 +29,14 @@ export function cardAlreadyOffersWatch(blocks: ViewBlock[]): boolean {
   );
 }
 
+/**
+ * The same question across every card a turn renders. One `render_view` call can carry the
+ * investigation card and another the actions block, so a per-call answer misses the pair.
+ */
+export function turnAlreadyOffersWatch(blockGroups: ViewBlock[][]): boolean {
+  return blockGroups.some(cardAlreadyOffersWatch);
+}
+
 export function withoutWatchActions<T extends CardAction>(actions: T[]): T[] {
   return actions.filter((action) => action.intent.kind !== "watch");
 }

apps/webapp/app/components/dashboard-agent/view-catalog.tsx

@@ -16,17 +16,21 @@ export function ViewBlocks({
   resolveUri,
   pagePaths,
   answered = false,
+  watchOfferedInTurn = false,
 }: {
   blocks: ViewBlock[];
   onIntent?: (intent: AgentIntent) => void;
   resolveUri?: (uri: string) => ResolvedUri | null;
   pagePaths?: Record<string, string>;
   /** The turn kept answering after this card, so "keep digging" has nothing to ask for. */
   answered?: boolean;
+  /** A card in another of this turn's parts already offers the watch; see `view-actions`. */
+  watchOfferedInTurn?: boolean;
 }) {
   if (!Array.isArray(blocks)) return null;
   const entries = latestRevisionEntries(blocks);
-  const watchOfferedOnCard = cardAlreadyOffersWatch(entries.map((entry) => entry.block));
+  const watchOfferedOnCard =
+    watchOfferedInTurn || cardAlreadyOffersWatch(entries.map((entry) => entry.block));
   return (
     <div className="space-y-2">
       {entries.map(({ block, index }) => {