fix(webapp): one watch button per answer, not two

An investigation card carries its own watch button, and the prompt asked for a watch offer on top of it. The card wins — it is the one with the pre-filled spec — and the prompt now says so too.

Author: kathiekiwi

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

@@ -4,16 +4,20 @@ import type {
 } from "@internal/dashboard-agent-contracts";
 import { Button } from "~/components/primitives/Buttons";
 import { ChatActionsRow } from "./chat-layout";
-import { renderableActions } from "./view-actions";
+import { renderableActions, withoutWatchActions } from "./view-actions";
 
 export function ActionsBlock({
   block,
   onIntent,
+  dropWatch = false,
 }: {
   block: ActionsBlockPayload;
   onIntent?: (intent: AgentIntent) => void;
+  /** Set when an investigation card in the same answer already offers the watch. */
+  dropWatch?: boolean;
 }) {
-  const renderable = renderableActions(block.actions);
+  const actions = dropWatch ? withoutWatchActions(block.actions) : block.actions;
+  const renderable = renderableActions(actions);
   if (!onIntent || renderable.length === 0) return null;
   return (
     <ChatActionsRow>

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

@@ -1,7 +1,7 @@
 import type { ActionsBlockAction } from "@internal/dashboard-agent-contracts";
 import { readFileSync } from "node:fs";
 import { describe, expect, it } from "vitest";
-import { renderableActions } from "./view-actions";
+import { cardAlreadyOffersWatch, renderableActions, withoutWatchActions } from "./view-actions";
 
 const watchAction: ActionsBlockAction = {
   label: "Set up a watch",
@@ -50,6 +50,34 @@ describe("renderableActions", () => {
   });
 });
 
+describe("one watch button per answer", () => {
+  const watchAction = { label: "Watch for a repeat", intent: { kind: "watch" as const, spec: {} } };
+  const card = (actions: unknown[]) =>
+    ({ type: "investigation", investigation: {}, capabilities: { actions } }) as never;
+
+  it("sees the card's own watch offer", () => {
+    expect(cardAlreadyOffersWatch([card([watchAction])])).toBe(true);
+  });
+
+  it("leaves an answer whose card offers no watch alone", () => {
+    expect(
+      cardAlreadyOffersWatch([
+        card([{ label: "Keep digging", intent: { kind: "ask", prompt: "" } }]),
+      ])
+    ).toBe(false);
+    expect(cardAlreadyOffersWatch([])).toBe(false);
+  });
+
+  it("drops the model's duplicate offer, keeping everything else", () => {
+    expect(
+      withoutWatchActions([
+        { label: "Set up a watch", intent: { kind: "watch", spec: {} } },
+        { label: "View similar", intent: { kind: "navigate", target: "trigger://x" } },
+      ] as never)
+    ).toEqual([{ label: "View similar", intent: { kind: "navigate", target: "trigger://x" } }]);
+  });
+});
+
 describe("ActionsBlock", () => {
   const source = readFileSync(new URL("./ActionsBlock.tsx", import.meta.url), "utf8");
 
@@ -59,7 +87,7 @@ describe("ActionsBlock", () => {
   });
 
   it("filters through the shared filter rather than rendering every action", () => {
-    expect(source).toContain("renderableActions(block.actions)");
+    expect(source).toContain("renderableActions(actions)");
   });
 
   it("is a pure component: no app hooks, no server module, no Remix", () => {

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

@@ -4,6 +4,7 @@ import {
   isTriggerUri,
   type ActionsBlockAction,
   type ChartAction,
+  type ViewBlock,
 } from "@internal/dashboard-agent-contracts";
 
 type CardAction = ChartAction | ActionsBlockAction;
@@ -14,3 +15,20 @@ export function renderableActions<T extends CardAction>(actions: T[]): T[] {
     return intent.kind !== "navigate" || isTriggerUri(intent.target);
   });
 }
+
+/**
+ * An investigation card carries its own "watch for a repeat" button, and the model is
+ * asked to end an unresolved answer with a watch offer — so an answer that does both
+ * shows the same button twice. The card wins: it is the one with the pre-filled spec.
+ */
+export function cardAlreadyOffersWatch(blocks: ViewBlock[]): boolean {
+  return blocks.some(
+    (block) =>
+      block.type === "investigation" &&
+      (block.capabilities?.actions ?? []).some((action) => action.intent.kind === "watch")
+  );
+}
+
+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

@@ -5,6 +5,7 @@ import { InvestigationCard } from "./InvestigationCard";
 import { ReportView, type ResolvedUri } from "./ReportView";
 import { RunDiagnosisCard } from "./RunDiagnosisCard";
 import { blockKey, latestRevisionBlocks } from "./view-blocks";
+import { cardAlreadyOffersWatch } from "./view-actions";
 import { WatchResultBlock } from "./WatchResultBlock";
 
 // Unknown block types are skipped, so an older or newer agent cannot render
@@ -21,9 +22,11 @@ export function ViewBlocks({
   pagePaths?: Record<string, string>;
 }) {
   if (!Array.isArray(blocks)) return null;
+  const rendered = latestRevisionBlocks(blocks);
+  const watchOfferedOnCard = cardAlreadyOffersWatch(rendered);
   return (
     <div className="space-y-2">
-      {latestRevisionBlocks(blocks).map((block) => {
+      {rendered.map((block) => {
         // Index into the original array, so collapsing a revision above an
         // envelope-less block can't shift its key.
         const key = blockKey(block, blocks.indexOf(block));
@@ -33,7 +36,14 @@ export function ViewBlocks({
           case "chart":
             return <AgentChart key={key} block={block} onIntent={onIntent} />;
           case "actions":
-            return <ActionsBlock key={key} block={block} onIntent={onIntent} />;
+            return (
+              <ActionsBlock
+                key={key}
+                block={block}
+                onIntent={onIntent}
+                dropWatch={watchOfferedOnCard}
+              />
+            );
           // Revisions share the investigationId, so latest-wins keeps one card.
           case "investigation":
             return (

internal-packages/dashboard-agent/src/tool-schemas.ts

@@ -517,7 +517,7 @@ Is anything wrong?:
 
 Watches — telling the user later:
 - When the user wants to be told when something happens ("tell me when this run finishes", "let me know when the backlog drains", "tell me when it's back under 100", "tell me if that queue stops moving", "ping me if runs start waiting more than 5 minutes", "ping me if that error comes back", "tell me when prod is healthy again"), call schedule_watch. Never poll: repeating a read tool until the thing happens is not a watch, and you cannot wait inside a turn.
-- Offer a watch whenever your answer points at something worth monitoring that you can't resolve now: a recurring or unresolved error, a queue trending toward trouble, a condition the user would want to hear about the moment it changes. The offer is two things together: one short line ("Want me to set up a watch so you're told if it hits again?") AND a render_view "actions" block with one button — label it like "Set up a watch", intent {"kind":"watch","spec":{…}} carrying the same spec schedule_watch would compose. Clicking it opens the configuration card pre-filled, so the user answers with a click instead of typing "yeah". One offer per answer at most; skip it when the news is good or the user is clearly just browsing. schedule_watch is still how you answer a user who asks for a watch in their own words.
+- Offer a watch whenever your answer points at something worth monitoring that you can't resolve now: a recurring or unresolved error, a queue trending toward trouble, a condition the user would want to hear about the moment it changes. The offer is two things together: one short line ("Want me to set up a watch so you're told if it hits again?") AND a render_view "actions" block with one button — label it like "Set up a watch", intent {"kind":"watch","spec":{…}} carrying the same spec schedule_watch would compose. Clicking it opens the configuration card pre-filled, so the user answers with a click instead of typing "yeah". One offer per answer at most; skip it when the news is good, when the user is clearly just browsing, or when this answer's investigation card already carries a watch button — the card is the offer, and repeating it puts two watch buttons on one answer. schedule_watch is still how you answer a user who asks for a watch in their own words.
 - schedule_watch does not start anything. It opens a configuration card pre-filled with what you composed, and the user confirming that card is what starts the watch. So say what you filled in — what is being watched, how often it checks, and when it gives up (the maxHours you set) — and that confirming starts it. Never say it's running, scheduled, or that you'll tell them later: "I've filled in a watch for you to review — confirm to start it", never "I'll let you know when it finishes". Pick the longest cadence that still answers in time — 1 minute only for a run's state, 5 minutes or more for backlog, error recurrence, and health.
 - The card settles everything after the user confirms: whether this chat can hold another watch, whether the same thing is already watched, and whether the condition is already true (in which case they get the answer instead of a watch). Never promise, predict, or pre-explain any of those.
 - A watch wake is a message you send unprompted, and it is narrated ONCE, briefly: what the outcome was, the numbers from the facts you were given, and one suggested next step. Nothing else — no new investigation, no fresh reads, no recap of the conversation.