fix(webapp): drop the watch action button when the turn already proposed a watch

Author: kathiekiwi

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

@@ -23,7 +23,7 @@ import { stripModelImages } from "./model-markdown";
 import { reportBlockFromToolPart } from "./report-block-adapter";
 import { shouldShowLiveTurnError } from "./turn-error";
 import type { ResolvedUri } from "./ReportView";
-import { answerContinuesAfter, turnAlreadyOffersWatch } from "./view-actions";
+import { answerContinuesAfter, turnAlreadyOffersWatch, turnProposesWatch } from "./view-actions";
 import { latestRevisionBlocks } from "./view-blocks";
 import { ViewBlocks } from "./view-catalog";
 import { findWakeWatch, WakeBanner, wakeRefFromMessageId, type WakeWatch } from "./WakeBanner";
@@ -258,11 +258,13 @@ const DashboardAgentTurn = memo(function DashboardAgentTurn({
   });
   // 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 watchOfferedInTurn =
+    turnProposesWatch(parts as never) ||
+    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++) {

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

@@ -6,6 +6,7 @@ import {
   cardAlreadyOffersWatch,
   renderableActions,
   turnAlreadyOffersWatch,
+  turnProposesWatch,
   withoutWatchActions,
 } from "./view-actions";
 
@@ -117,6 +118,32 @@ describe("one watch button per answer", () => {
   });
 });
 
+describe("a turn that proposed a watch through the tool", () => {
+  const text = { type: "text", text: "here is what I found" };
+  const scheduled = (output: unknown, state = "output-available") => ({
+    type: "tool-schedule_watch",
+    state,
+    output,
+  });
+  const intent = { intent: watchAction.intent };
+
+  it("sees the proposal that opened the card", () => {
+    expect(turnProposesWatch([text, scheduled(intent)])).toBe(true);
+  });
+
+  it("leaves the button alone when the spec was rejected — no card opened", () => {
+    expect(turnProposesWatch([text, scheduled({ error: "Couldn't build that watch: bad" })])).toBe(
+      false
+    );
+  });
+
+  it("waits for the output: a call still running proposes nothing", () => {
+    expect(turnProposesWatch([scheduled(intent, "input-available")])).toBe(false);
+    expect(turnProposesWatch([{ type: "tool-schedule_watch", output: intent }])).toBe(false);
+    expect(turnProposesWatch([text])).toBe(false);
+  });
+});
+
 describe("ActionsBlock", () => {
   const source = readFileSync(new URL("./ActionsBlock.tsx", import.meta.url), "utf8");
 
@@ -154,6 +181,10 @@ describe("the one-watch-button flag is decided per turn, not per render_view cal
     expect(turn).toContain("watchOfferedInTurn={watchOfferedInTurn}");
   });
 
+  it("counts the turn's own schedule_watch proposal as an offer", () => {
+    expect(turn).toMatch(/turnProposesWatch\(parts as never\) \|\|/);
+  });
+
   it("lets a card add its own offer but never drop the turn's", () => {
     expect(catalog).toMatch(/watchOfferedInTurn \|\|\s*cardAlreadyOffersWatch\(/);
   });

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

@@ -1,6 +1,7 @@
 // A navigate target is a plain string at the contract boundary, so only targets
 // that parse become buttons: a hallucinated URI costs a button, never a dead click.
 import {
+  agentIntentSchema,
   isTriggerUri,
   type ActionsBlockAction,
   type ChartAction,
@@ -37,6 +38,21 @@ export function turnAlreadyOffersWatch(blockGroups: ViewBlock[][]): boolean {
   return blockGroups.some(cardAlreadyOffersWatch);
 }
 
+/**
+ * `schedule_watch` opens the pre-filled card itself, so a button repeating it is dead.
+ * A rejected spec returns an error instead of an intent: no card opens, so the button stays.
+ */
+export function turnProposesWatch(
+  parts: ReadonlyArray<{ type?: string; state?: string; output?: unknown }>
+): boolean {
+  return parts.some(
+    (part) =>
+      part.type === "tool-schedule_watch" &&
+      part.state === "output-available" &&
+      agentIntentSchema.safeParse((part.output as { intent?: unknown } | undefined)?.intent).success
+  );
+}
+
 export function withoutWatchActions<T extends CardAction>(actions: T[]): T[] {
   return actions.filter((action) => action.intent.kind !== "watch");
 }