@@ -0,0 +1,6 @@
+---
+area: webapp
+type: feature
+---
+
+There's now a **Watch…** button on runs, queues, errors and the health report. It opens a short form with the right thing to wait for already filled in — a run finishing, a queue clearing, an error coming back, an environment recovering — so one click is enough. Open **Customize** first if you'd rather change how long it waits, how often it checks, or what it waits for, and you can ask for an email as well as the chat message.
@@ -3,4 +3,4 @@ area: webapp
 type: feature
 ---
 
-Ask the dashboard agent to tell you when something happens — a run starting or finishing, a queue clearing or growing past a number you pick, an error coming back, an environment recovering — and it messages you in the chat once with the answer. It tells you either way: that the run finished, that it failed, or that the queue still hadn't cleared by the time it stopped looking. If the thing you asked about has already happened, it just says so instead of waiting. Each chat can wait on up to three things at a time, for up to 24 hours.
+Ask the dashboard agent to tell you when something happens — a run starting or finishing, a queue clearing or growing past a number you pick, an error coming back, an environment recovering — and it messages you in the chat once with the answer. It tells you either way: that the run finished, that it failed, or that the queue still hadn't cleared by the time it stopped looking. If the thing you asked about has already happened, it just says so instead of waiting. Each chat can wait on up to three things at a time, for up to 24 hours. You can also ask it to start looking into the cause if the news turns out to be bad, and it will — otherwise it just tells you and stops.
@@ -1,4 +1,4 @@
-import type { SuggestedPrompt } from "@internal/dashboard-agent-contracts";
+import type { SuggestedPrompt, WatchSpec } from "@internal/dashboard-agent-contracts";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import {
   ResizableHandle,
@@ -67,6 +67,12 @@ export function DashboardAgent({
   const [openChatRequest, setOpenChatRequest] = useState<
     { chatId: string; seq: number } | undefined
   >(undefined);
+  // A watch card asked for by a `Watch…` entry (§2.1). A card is not a message,
+  // so it travels on its own channel: the panel opens it pre-filled, and nothing
+  // reaches the transcript unless the user submits it.
+  const [watchRequest, setWatchRequest] = useState<{ spec: WatchSpec; seq: number } | undefined>(
+    undefined
+  );
 
   // Closing drops any pending request, so reopening the panel later doesn't
   // replay text the user has moved on from.
@@ -77,6 +83,9 @@ export function DashboardAgent({
     if (!next) {
       setRequestedMessage(undefined);
       setOpenChatRequest(undefined);
+      // An abandoned card leaves no trace (§2.2) — including no pending request
+      // that would re-open it the next time the panel is.
+      setWatchRequest(undefined);
     }
   }, []);
 
@@ -95,6 +104,11 @@ export function DashboardAgent({
     setRequestedMessage((current) => ({ text: trimmed, seq: (current?.seq ?? 0) + 1 }));
   }, []);
 
+  const openWithWatch = useCallback((spec: WatchSpec) => {
+    setOpen(true);
+    setWatchRequest((current) => ({ spec, seq: (current?.seq ?? 0) + 1 }));
+  }, []);
+
   // The dot's poll, and the toast's. Runs only while the panel is CLOSED — an
   // open panel shows the wake in the transcript, so polling then would only race
   // the read marker. Both the interval and the on-close refresh come from this
@@ -172,8 +186,8 @@ export function DashboardAgent({
   useDashboardAgentOpenRequests({ enabled: hasAccess, openWith, setOpen: setPanelOpen });
 
   const context = useMemo(
-    () => ({ open, setOpen: setPanelOpen, openWith, unreadWakes }),
-    [open, setPanelOpen, openWith, unreadWakes]
+    () => ({ open, setOpen: setPanelOpen, openWith, openWithWatch, unreadWakes }),
+    [open, setPanelOpen, openWith, openWithWatch, unreadWakes]
   );
 
   if (!hasAccess) {
@@ -197,6 +211,7 @@ export function DashboardAgent({
               onClose={() => setPanelOpen(false)}
               requestedMessage={requestedMessage}
               openChatRequest={openChatRequest}
+              watchRequest={watchRequest}
               promotedPrompt={promotedPrompt}
               onChatRead={markChatRead}
             />
 
@@ -18,30 +18,6 @@ import { useAgentMessageQuota } from "./useAgentMessageQuota";
 import { useTriggerUriResolver } from "./useTriggerUriResolver";
 import { WatchChips, type WatchChip } from "./WatchChips";
 
-/**
- * The message a card's watch button sends on the user's behalf. Written the way
- * the user would ask, so the transcript reads as a request the agent then
- * confirms (via schedule_watch), not as UI state that changed silently.
- */
-function watchRequestText(spec: WatchSpec): string {
-  const note = "note" in spec && spec.note ? spec.note.trim() : "";
-  if (note) return `Watch this for me — tell me when ${note}.`;
-  switch (spec.kind) {
-    case "backlog_drain":
-      return `Watch this for me — tell me when the ${spec.queue} backlog drains.`;
-    case "queue_depth_above":
-      return `Watch this for me — tell me if the ${spec.queue} queue grows past ${spec.threshold}.`;
-    case "run_start":
-      return `Watch this for me — tell me when run ${spec.runId} starts.`;
-    case "run_finished":
-      return `Watch this for me — tell me when run ${spec.runId} finishes.`;
-    case "error_recurrence":
-      return `Watch this for me — ping me if error ${spec.fingerprint} comes back.`;
-    case "health_recovery":
-      return "Watch this for me — tell me when health is back to normal.";
-  }
-}
-
 // The persisted session for a chat: the session-scoped token plus the stream
 // cursor. Resuming with `lastEventId` is what stops the agent's `.out` stream
 // from replaying the previous turn.
@@ -86,6 +62,9 @@ export function DashboardAgentChat({
   promotedPrompt,
   watches,
   pagePaths,
+  watchCard,
+  appendedMessage,
+  onWatchIntent,
   onCancelWatch,
   onTurnSettled,
   onActivityChange,
@@ -118,6 +97,21 @@ export function DashboardAgentChat({
   watches: WatchChip[];
   /** Host-resolved dashboard paths for settings-page footer actions. */
   pagePaths?: Record<string, string>;
+  /** The ephemeral watch card, when one is open. Sits above the composer. */
+  watchCard?: React.ReactNode;
+  /**
+   * A message the SERVER appended outside a turn — the watch card's confirmation
+   * or one-shot result. It is already durable in the store; this puts it in the
+   * live transcript now instead of on the next open. `seq` makes each append
+   * distinct, so the effect applies it exactly once.
+   */
+  appendedMessage?: { message: UIMessage; seq: number };
+  /**
+   * A card offered a watch. Every `watch` intent means the same thing — open the
+   * configuration card pre-filled with this spec — so the user reviews and
+   * submits it, and nothing is posted or persisted if they don't (§2.2).
+   */
+  onWatchIntent?: (spec: WatchSpec) => void;
   onCancelWatch: (watchId: string) => void;
   /** A watch was created — tell the panel to re-read the chips. */
   onTurnSettled: () => void;
@@ -195,6 +189,7 @@ export function DashboardAgentChat({
 
   const {
     messages: rawMessages,
+    setMessages,
     sendMessage,
     status,
     stop: aiStop,
@@ -229,6 +224,20 @@ export function DashboardAgentChat({
   const activity: TurnActivity | null =
     status === "submitted" ? "thinking" : status === "streaming" ? "working" : null;
 
+  // A server-appended block (the watch card's outcome) joins the live transcript
+  // in place. Applied once per `seq`: the append is already persisted, so
+  // replaying it would show the same confirmation twice.
+  const appendedSeq = useRef<number | undefined>(undefined);
+  useEffect(() => {
+    if (!appendedMessage || appendedSeq.current === appendedMessage.seq) return;
+    appendedSeq.current = appendedMessage.seq;
+    setMessages((current) =>
+      current.some((message) => message.id === appendedMessage.message.id)
+        ? current
+        : [...current, appendedMessage.message]
+    );
+  }, [appendedMessage, setMessages]);
+
   // Cold start: trigger the first turn by sending the pending message once.
   const sentFirst = useRef(false);
   useEffect(() => {
@@ -293,11 +302,14 @@ export function DashboardAgentChat({
   );
 
   // What a card's action does. An `ask` goes back into the conversation as the
-  // user's own question — and so does a `watch`: the click becomes a visible
-  // request ("Watch this for me…") and the agent answers it with schedule_watch,
-  // confirming in its own words and offering an email alert when none is set up.
-  // A silent POST would be cheaper, but a watch the transcript never mentions
-  // reads as nothing having happened.
+  // user's own question.
+  //
+  // A `watch` does NOT: it opens the configuration card pre-filled with the spec
+  // the card offered. Every watch intent is treated this way, whatever offered it
+  // — so the user always sees what they are about to start, can change the window
+  // or the condition first, and an offer they walk away from leaves no trace. It
+  // used to post a visible "Watch this for me…" request and let the agent answer
+  // with schedule_watch; the card replaces that turn with 0 LLM.
   //
   // `propose_fix` is reserved and must never be executed.
   const handleIntent = useCallback(
@@ -307,7 +319,7 @@ export function DashboardAgentChat({
           submit(intent.prompt);
           return;
         case "watch":
-          submit(watchRequestText(intent.spec));
+          onWatchIntent?.(intent.spec);
           return;
         case "navigate":
           void goTo(intent);
@@ -316,7 +328,7 @@ export function DashboardAgentChat({
           console.warn(`Dashboard agent: unhandled intent "${intent.kind}"`);
       }
     },
-    [submit, goTo]
+    [submit, goTo, onWatchIntent]
   );
 
   // The `navigate_to` tool answers with an intent and the agent then narrates it
@@ -391,6 +403,7 @@ export function DashboardAgentChat({
           resolveUri={resolveUri}
         />
       )}
+      {watchCard}
       {/* The Free plan's message cap occupies the composer slot: at the cap the
           composer is replaced by the upgrade block (a composer you can't send
           from is worse than none), and under it the composer is followed by the
 
@@ -19,6 +19,7 @@ export function DashboardAgentDraft({
   currentPage,
   pageContext,
   promotedPrompt,
+  watchCard,
 }: {
   onSubmit: (text: string) => void;
   projectSlug: string;
@@ -28,6 +29,8 @@ export function DashboardAgentDraft({
   pageContext?: AgentPageContext;
   // The product-controlled promoted chip, from the feature flag.
   promotedPrompt?: SuggestedPrompt;
+  /** The ephemeral watch card, when one is open. Sits above the composer. */
+  watchCard?: React.ReactNode;
 }) {
   const [input, setInput] = useState("");
 
@@ -48,6 +51,7 @@ export function DashboardAgentDraft({
         pageContext={pageContext}
         promoted={promotedPrompt}
       />
+      {watchCard}
       <DashboardAgentComposer
         value={input}
         onChange={setInput}
 
@@ -94,10 +94,27 @@ function viewSpecFor(part: UIMessage["parts"][number]): { blocks: unknown[] } |
 function blocksFor(part: UIMessage["parts"][number]): unknown[] | null {
   const spec = viewSpecFor(part);
   if (spec) return spec.blocks;
+  const hostBlocks = hostViewBlocks(part);
+  if (hostBlocks) return hostBlocks;
   const report = reportBlockFromToolPart(part);
   return report ? [report] : null;
 }
 
+/**
+ * Blocks the HOST wrote, with no tool behind them.
+ *
+ * The watch card's confirmation and its one-shot result are deterministic facts
+ * the webapp decided (§2.2) — there is no model turn and no tool call to hang
+ * them off, so they travel as a plain `data-view` part and render through exactly
+ * the same `ViewBlocks` catalog as everything else. Same envelope, same
+ * latest-wins, one renderer.
+ */
+function hostViewBlocks(part: UIMessage["parts"][number]): unknown[] | null {
+  const p = part as { type: string; data?: { blocks?: unknown[] } };
+  if (p.type !== "data-view") return null;
+  return Array.isArray(p.data?.blocks) ? p.data!.blocks! : null;
+}
+
 type InvestigationRef = { id: string; revision: number };
 
 function investigationRef(block: unknown): InvestigationRef | null {