fix(webapp): schedule_watch proposes a watch instead of creating one

The free-text path used to POST the watch straight from the tool, so a
"yeah, set one up" created it with no card and no consent. The tool now
validates the spec and returns a `watch` intent; the panel scans
`tool-schedule_watch` results the same way it scans navigate_to and opens
the pre-filled configuration card, replay-safe. The card's submit is the
only creator, so it owns the opt-ins, the cap, dedup, and the one-shot
result — prompt wording updated to match.

Author: kathiekiwi

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

@@ -12,7 +12,8 @@ import { DashboardAgentContextBanner } from "./DashboardAgentContextBanner";
 import { DashboardAgentHero } from "./DashboardAgentHero";
 import { DashboardAgentMessages, type TurnActivity } from "./DashboardAgentMessages";
 import { createTranscriptOrder, orderTranscript } from "./message-order";
-import { appendRunFilters, pendingNavigateIntents } from "./navigate-target";
+import { appendRunFilters } from "./navigate-target";
+import { pendingNavigateIntents, pendingWatchIntents } from "./pending-intents";
 import type { AgentPageContext } from "./page-context-types";
 import { useAgentMessageQuota } from "./useAgentMessageQuota";
 import { useTriggerUriResolver } from "./useTriggerUriResolver";
@@ -345,9 +346,26 @@ export function DashboardAgentChat({
     const pending = pendingNavigateIntents(messages, navigatedRef.current!);
     // Only the last one matters — the earlier destinations are already history.
     const target = pending.at(-1);
-    if (target?.kind === "navigate") void goTo(target);
+    if (target) void goTo(target);
   }, [messages, goTo]);
 
+  // `schedule_watch` proposes rather than creates: it answers with a watch intent
+  // and the panel opens the card pre-filled, so a free-text ask ("set up a watch
+  // then") is reviewed and confirmed like any other watch (§2.1 Path B). Seeded
+  // and deduped exactly like navigate, so reopening a chat whose history holds
+  // the call never reopens the card.
+  const watchProposedRef = useRef<Set<string> | null>(null);
+  if (watchProposedRef.current === null) {
+    watchProposedRef.current = new Set();
+    pendingWatchIntents(initialMessages, watchProposedRef.current);
+  }
+  useEffect(() => {
+    const pending = pendingWatchIntents(messages, watchProposedRef.current!);
+    // One card at a time, so the newest proposal is the one to review.
+    const proposed = pending.at(-1);
+    if (proposed) onWatchIntent?.(proposed.spec);
+  }, [messages, onWatchIntent]);
+
   const stop = useCallback(() => {
     transport.stopGeneration(chatId);
     aiStop();

apps/webapp/app/components/dashboard-agent/navigate-target.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { appendRunFilters, pendingNavigateIntents, sameOriginPath } from "./navigate-target";
+import { appendRunFilters, sameOriginPath } from "./navigate-target";
 
 const RUNS_PATH = "/orgs/acme/projects/api/env/prod/runs";
 
@@ -49,49 +49,3 @@ describe("sameOriginPath", () => {
     expect(sameOriginPath("not a url", "")).toBeNull();
   });
 });
-
-describe("pendingNavigateIntents", () => {
-  const uri = "trigger://proj_abc/env_123/run/run_abc";
-  const toolPart = (toolCallId: string, state = "output-available") => ({
-    type: "tool-navigate_to",
-    state,
-    toolCallId,
-    output: { intent: { kind: "navigate", target: uri } },
-  });
-
-  it("returns the intent from a completed navigate_to call, once", () => {
-    const seen = new Set<string>();
-    const messages = [{ id: "m1", parts: [toolPart("call-1")] }];
-
-    expect(pendingNavigateIntents(messages, seen)).toEqual([{ kind: "navigate", target: uri }]);
-    expect(pendingNavigateIntents(messages, seen)).toEqual([]);
-  });
-
-  it("ignores a call that hasn't produced output yet", () => {
-    expect(
-      pendingNavigateIntents(
-        [{ id: "m1", parts: [toolPart("call-1", "input-available")] }],
-        new Set()
-      )
-    ).toEqual([]);
-  });
-
-  it("ignores output that isn't a navigate intent", () => {
-    const messages = [
-      { id: "m1", parts: [{ ...toolPart("call-1"), output: { error: "nowhere to go" } }] },
-      { id: "m2", parts: [{ type: "text", text: "hello" }] },
-    ];
-
-    expect(pendingNavigateIntents(messages, new Set())).toEqual([]);
-  });
-
-  it("skips calls seeded as already seen (loaded history)", () => {
-    const history = [{ id: "m1", parts: [toolPart("call-1")] }];
-    const seen = new Set<string>();
-    pendingNavigateIntents(history, seen);
-
-    expect(
-      pendingNavigateIntents([...history, { id: "m2", parts: [toolPart("call-2")] }], seen)
-    ).toEqual([{ kind: "navigate", target: uri }]);
-  });
-});

apps/webapp/app/components/dashboard-agent/navigate-target.ts

@@ -6,11 +6,7 @@
  * client-side halves: the runs-list filters a navigate intent carries, and links
  * that arrived as absolute URLs into our own origin.
  */
-import {
-  agentIntentSchema,
-  type AgentIntent,
-  type RunFilters,
-} from "@internal/dashboard-agent-contracts";
+import { type RunFilters } from "@internal/dashboard-agent-contracts";
 
 // The filter keys are already the runs page's own URL params (see
 // `TaskRunListSearchFilters`), with one exception: the page reads absolute
@@ -61,41 +57,3 @@ export function sameOriginPath(href: string, origin: string): string | null {
   if (url.origin !== origin) return null;
   return `${url.pathname}${url.search}${url.hash}`;
 }
-
-type ToolPart = { type?: string; state?: string; toolCallId?: string; output?: unknown };
-type ToolMessage = { id: string; parts?: ReadonlyArray<unknown> };
-
-/**
- * The navigate intents from completed `navigate_to` tool calls the host hasn't
- * honoured yet.
- *
- * The tool returns an intent rather than performing the navigation, so the panel
- * is what actually moves the user — otherwise the agent says "you're now on the
- * page" and nothing happened. `seen` is mutated with the calls handled, and is
- * seeded with the transcript loaded at mount so opening an old chat never
- * navigates on history.
- */
-export function pendingNavigateIntents(
-  messages: ReadonlyArray<ToolMessage>,
-  seen: Set<string>
-): AgentIntent[] {
-  const intents: AgentIntent[] = [];
-
-  for (const message of messages) {
-    const parts = message.parts ?? [];
-    for (let i = 0; i < parts.length; i++) {
-      const part = parts[i] as ToolPart;
-      if (part?.type !== "tool-navigate_to" || part.state !== "output-available") continue;
-
-      const key = part.toolCallId ?? `${message.id}:${i}`;
-      if (seen.has(key)) continue;
-      seen.add(key);
-
-      const output = part.output as { intent?: unknown } | undefined;
-      const parsed = agentIntentSchema.safeParse(output?.intent);
-      if (parsed.success && parsed.data.kind === "navigate") intents.push(parsed.data);
-    }
-  }
-
-  return intents;
-}

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

@@ -0,0 +1,122 @@
+import { describe, expect, it } from "vitest";
+import { pendingNavigateIntents, pendingWatchIntents } from "./pending-intents";
+
+describe("pendingNavigateIntents", () => {
+  const uri = "trigger://proj_abc/env_123/run/run_abc";
+  const toolPart = (toolCallId: string, state = "output-available") => ({
+    type: "tool-navigate_to",
+    state,
+    toolCallId,
+    output: { intent: { kind: "navigate", target: uri } },
+  });
+
+  it("returns the intent from a completed navigate_to call, once", () => {
+    const seen = new Set<string>();
+    const messages = [{ id: "m1", parts: [toolPart("call-1")] }];
+
+    expect(pendingNavigateIntents(messages, seen)).toEqual([{ kind: "navigate", target: uri }]);
+    expect(pendingNavigateIntents(messages, seen)).toEqual([]);
+  });
+
+  it("ignores a call that hasn't produced output yet", () => {
+    expect(
+      pendingNavigateIntents(
+        [{ id: "m1", parts: [toolPart("call-1", "input-available")] }],
+        new Set()
+      )
+    ).toEqual([]);
+  });
+
+  it("ignores output that isn't a navigate intent", () => {
+    const messages = [
+      { id: "m1", parts: [{ ...toolPart("call-1"), output: { error: "nowhere to go" } }] },
+      { id: "m2", parts: [{ type: "text", text: "hello" }] },
+    ];
+
+    expect(pendingNavigateIntents(messages, new Set())).toEqual([]);
+  });
+
+  it("skips calls seeded as already seen (loaded history)", () => {
+    const history = [{ id: "m1", parts: [toolPart("call-1")] }];
+    const seen = new Set<string>();
+    pendingNavigateIntents(history, seen);
+
+    expect(
+      pendingNavigateIntents([...history, { id: "m2", parts: [toolPart("call-2")] }], seen)
+    ).toEqual([{ kind: "navigate", target: uri }]);
+  });
+});
+
+describe("pendingWatchIntents", () => {
+  const spec = {
+    kind: "run_finished",
+    runId: "run_abc",
+    checkEveryMinutes: 1,
+    maxHours: 2,
+    note: "tell me when the receipt run finishes",
+  };
+  const toolPart = (toolCallId: string, state = "output-available") => ({
+    type: "tool-schedule_watch",
+    state,
+    toolCallId,
+    output: { intent: { kind: "watch", spec } },
+  });
+
+  it("returns the proposed spec from a completed schedule_watch call, once", () => {
+    const seen = new Set<string>();
+    const messages = [{ id: "m1", parts: [toolPart("call-1")] }];
+
+    expect(pendingWatchIntents(messages, seen)).toEqual([{ kind: "watch", spec }]);
+    expect(pendingWatchIntents(messages, seen)).toEqual([]);
+  });
+
+  it("ignores a call still running, and a spec the contract rejects", () => {
+    expect(
+      pendingWatchIntents([{ id: "m1", parts: [toolPart("call-1", "input-available")] }], new Set())
+    ).toEqual([]);
+
+    const invalid = [
+      {
+        id: "m1",
+        parts: [
+          {
+            ...toolPart("call-2"),
+            output: { intent: { kind: "watch", spec: { kind: "run_finished" } } },
+          },
+        ],
+      },
+    ];
+    expect(pendingWatchIntents(invalid, new Set())).toEqual([]);
+  });
+
+  // The card must not reopen when an old chat is loaded: replaying a transcript
+  // that already holds the proposal is not a new request.
+  it("never reopens a proposal seeded from loaded history", () => {
+    const history = [{ id: "m1", parts: [toolPart("call-1")] }];
+    const seen = new Set<string>();
+    pendingWatchIntents(history, seen);
+
+    expect(pendingWatchIntents(history, seen)).toEqual([]);
+    expect(
+      pendingWatchIntents([...history, { id: "m2", parts: [toolPart("call-2")] }], seen)
+    ).toEqual([{ kind: "watch", spec }]);
+  });
+
+  it("doesn't confuse a navigate result for a watch", () => {
+    const messages = [
+      {
+        id: "m1",
+        parts: [
+          {
+            type: "tool-navigate_to",
+            state: "output-available",
+            toolCallId: "call-1",
+            output: { intent: { kind: "navigate", target: "trigger://p/e/run/run_abc" } },
+          },
+        ],
+      },
+    ];
+
+    expect(pendingWatchIntents(messages, new Set())).toEqual([]);
+  });
+});

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

@@ -0,0 +1,63 @@
+/**
+ * The intents the agent emitted as tool results that the host hasn't honoured
+ * yet.
+ *
+ * A tool that emits an intent performs nothing — the panel is what acts, so what
+ * the agent then narrates ("you're now on…", "I've filled in a watch") is what
+ * actually happened. `seen` is mutated with the calls handled, and is seeded with
+ * the transcript loaded at mount, so opening an old chat never re-fires on
+ * history: only calls that land while this chat is open are honoured, once each.
+ */
+import { agentIntentSchema, type AgentIntent } from "@internal/dashboard-agent-contracts";
+
+type ToolPart = { type?: string; state?: string; toolCallId?: string; output?: unknown };
+type ToolMessage = { id: string; parts?: ReadonlyArray<unknown> };
+
+function pendingToolIntents<Kind extends AgentIntent["kind"]>(
+  messages: ReadonlyArray<ToolMessage>,
+  seen: Set<string>,
+  toolType: string,
+  kind: Kind
+): Array<Extract<AgentIntent, { kind: Kind }>> {
+  const intents: Array<Extract<AgentIntent, { kind: Kind }>> = [];
+
+  for (const message of messages) {
+    const parts = message.parts ?? [];
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i] as ToolPart;
+      if (part?.type !== toolType || part.state !== "output-available") continue;
+
+      const key = part.toolCallId ?? `${message.id}:${i}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+
+      const output = part.output as { intent?: unknown } | undefined;
+      const parsed = agentIntentSchema.safeParse(output?.intent);
+      if (parsed.success && parsed.data.kind === kind) {
+        intents.push(parsed.data as Extract<AgentIntent, { kind: Kind }>);
+      }
+    }
+  }
+
+  return intents;
+}
+
+/** Where `navigate_to` asked the panel to take the user. */
+export function pendingNavigateIntents(
+  messages: ReadonlyArray<ToolMessage>,
+  seen: Set<string>
+): Array<Extract<AgentIntent, { kind: "navigate" }>> {
+  return pendingToolIntents(messages, seen, "tool-navigate_to", "navigate");
+}
+
+/**
+ * The watches `schedule_watch` proposed. The tool never creates one: the spec
+ * comes back for the panel to open the configuration card pre-filled, so a
+ * free-text ask lands on the same review card as the contextual action.
+ */
+export function pendingWatchIntents(
+  messages: ReadonlyArray<ToolMessage>,
+  seen: Set<string>
+): Array<Extract<AgentIntent, { kind: "watch" }>> {
+  return pendingToolIntents(messages, seen, "tool-schedule_watch", "watch");
+}

apps/webapp/app/components/dashboard-agent/tool-labels.ts

@@ -31,7 +31,7 @@ const TOOL_LABELS: Record<string, string> = {
   search_docs: "Searching the docs",
   get_current_page: "Reading the current page",
   navigate_to: "Opening the page",
-  schedule_watch: "Setting up a watch",
+  schedule_watch: "Filling in a watch",
   list_alerts: "Listing alerts",
   create_alert: "Creating an alert",
   delete_alert: "Deleting an alert",

internal-packages/dashboard-agent/src/dashboard-agent.eval.ts

@@ -268,16 +268,6 @@ const FIXTURES: Record<string, unknown> = {
       pullRequestTitle: "Batch the receipt sends",
     },
   },
-  // A scheduled watch, as the host returns it: the id, the thing it watches, and
-  // when it gives up. No immediate outcome, so the answer must promise a message.
-  schedule_watch: {
-    watchId: "watch_eval1",
-    identity: "run_finished:run_a1",
-    status: "active",
-    expiresAt: "2026-01-02T01:00:00.000Z",
-    checkEveryMinutes: 1,
-    watching: true,
-  },
   search_docs: {
     results:
       "batchTrigger() triggers many runs of the same task in one call. It takes an array of payloads and returns a batch handle; use batchTriggerAndWait() inside a task to wait for all of them.",
@@ -313,6 +303,11 @@ function makeFixtureTools(
           // navigate_to doesn't fetch anything: the real one echoes the intent it
           // built, so the fixture does too.
           if (name === "navigate_to") return input;
+          // schedule_watch creates nothing either: it hands the spec back as the
+          // intent that opens the pre-filled card.
+          if (name === "schedule_watch") {
+            return { intent: { kind: "watch", spec: (input as { watch?: unknown }).watch } };
+          }
           // render_view echoes the spec and — for an investigation — reports the
           // identity the store assigned, which is what the model carries forward.
           if (name === "render_view") {