feat(webapp): a user-cancelled watch says so in the chat

Author: kathiekiwi

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

@@ -513,6 +513,16 @@ export function DashboardAgentPanel({
       try {
         const res = await fetch(actionPath, { method: "POST", body });
         if (!res.ok) throw new Error(`Watch cancel failed (${res.status})`);
+        // Empty when the watch had already resolved: then nothing was written.
+        const data = (await res.json()) as { messages?: UIMessage[] };
+        if (data.messages?.length) {
+          const messages = data.messages;
+          setAppendedMessages((current) => ({
+            chatId,
+            messages,
+            seq: (current?.seq ?? 0) + 1,
+          }));
+        }
       } catch (error) {
         console.error("Dashboard agent: failed to cancel watch", error);
         toast.error("We couldn't stop that watch. Try again in a moment.");

apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.dashboard-agent.ts

@@ -1,6 +1,5 @@
 import { json, type ActionFunctionArgs, type LoaderFunctionArgs } from "@remix-run/server-runtime";
 import {
-  cancelWatch,
   chatExists,
   countUnreadWatchWakes,
   countChatsWithUnreadWork,
@@ -36,6 +35,7 @@ import { findProjectBySlug } from "~/models/project.server";
 import { findEnvironmentBySlug } from "~/models/runtimeEnvironment.server";
 import {
   authorizeWatchEnvironmentById,
+  cancelDashboardAgentWatch,
   deleteChatWithWatches,
   listActiveWatchesForChats,
   submitDashboardAgentWatch,
@@ -670,10 +670,14 @@ export const action = async ({ request, params }: ActionFunctionArgs) => {
         return json({ error: "Chat not found" }, { status: 404 });
       }
 
-      // `cancelWatch` only touches an active row, so an already-resolved watch keeps
-      // its outcome and this is a no-op.
-      await cancelWatch(dashboardAgentDb, { id: watchId, reason: "user" });
-      return json({ ok: true });
+      // Only an active row is cancelled, so an already-resolved watch keeps its outcome,
+      // this is a no-op and no note is written.
+      const { messages } = await cancelDashboardAgentWatch({
+        watchId,
+        userId,
+        organizationId: project.organizationId,
+      });
+      return json({ ok: true, messages });
     }
   }
 };

apps/webapp/app/services/dashboardAgentWatches.server.ts

@@ -30,8 +30,10 @@ import {
 } from "@internal/dashboard-agent-db";
 import {
   VIEW_BLOCK_VERSION,
+  WATCH_CANCELLED_MESSAGE_ID_PREFIX,
   WATCH_CONFIRMATION_MESSAGE_ID_PREFIX,
   WATCH_REQUEST_MESSAGE_ID_PREFIX,
+  watchCancelledSentence,
   watchConfirmationBlockBody,
   watchDraftSchema,
   watchIdentity,
@@ -1123,6 +1125,37 @@ export async function scheduleWatchDelivery(watch: { id: string; expiresAt: Date
   );
 }
 
+/**
+ * Stop a watch the user asked to stop, and say so in the chat that owns it.
+ *
+ * Only this reason leaves a line: the other cancellations either take the chat with them or
+ * already state themselves. `cancelWatch` is guarded on `active`, so a second cancel — or a
+ * watch that resolved first — writes nothing, and the id keyed off the watch keeps a retry
+ * from adding a second line. Deterministic: no wake, no delivery, no model.
+ */
+export async function cancelDashboardAgentWatch(params: {
+  watchId: string;
+  userId: string;
+  organizationId: string;
+}): Promise<{ cancelled: boolean; messages: WatchTranscriptMessage[] }> {
+  const cancelled = await cancelWatch(dashboardAgentDb, { id: params.watchId, reason: "user" });
+  if (!cancelled) return { cancelled: false, messages: [] };
+
+  const message: WatchTranscriptMessage = {
+    id: `${WATCH_CANCELLED_MESSAGE_ID_PREFIX}${cancelled.id}`,
+    role: "assistant",
+    parts: [{ type: "text", text: watchCancelledSentence(cancelled.spec) }],
+  };
+  await appendChatMessageOnce(dashboardAgentDb, {
+    chatId: cancelled.chatId,
+    userId: params.userId,
+    organizationId: params.organizationId,
+    message,
+  });
+
+  return { cancelled: true, messages: [message] };
+}
+
 /**
  * Delete a chat and end its watches in one transaction, so no live watch is left on an
  * invisible chat. Owner-scoped, so a chatId the caller doesn't own deletes nothing.

apps/webapp/test/dashboardAgentWatches.test.ts

@@ -93,6 +93,7 @@ process.env.ALERT_EMAIL_TRANSPORT = "smtp";
 const {
   armDashboardAgentWatchBatch,
   authorizeWatchEnvironment,
+  cancelDashboardAgentWatch,
   createDashboardAgentWatch,
   deleteChatWithWatches,
   listActiveWatchesForChats,
@@ -784,6 +785,68 @@ describe("the chat cascade and the list view", () => {
     }
   );
 
+  postgresTest(
+    "a user's own cancel leaves one neutral line in the chat, and only one",
+    async ({ prisma, postgresContainer }) => {
+      await boot(prisma, postgresContainer.getConnectionUri());
+      const seeded = await seed(prisma, "usercancel");
+      await seedChat(seeded, "chat_1");
+
+      const created = await create({ seeded, chatId: "chat_1" });
+      expect(created.ok).toBe(true);
+      if (!created.ok) return;
+
+      const cancel = () =>
+        cancelDashboardAgentWatch({
+          watchId: created.watchId,
+          userId: seeded.user.id,
+          organizationId: seeded.organization.id,
+        });
+
+      expect(await cancel()).toMatchObject({
+        cancelled: true,
+        messages: [
+          {
+            id: `watch-cancelled:${created.watchId}`,
+            role: "assistant",
+            parts: [{ type: "text", text: "Stopped watching run run_1." }],
+          },
+        ],
+      });
+      expect(await getWatch(ctx.agentDb, { id: created.watchId })).toMatchObject({
+        status: "cancelled",
+        cancelReason: "user",
+        deliveryStatus: "not_required",
+      });
+      expect(await storedMessages(seeded, "chat_1")).toMatchObject([
+        { id: `watch-cancelled:${created.watchId}`, role: "assistant" },
+      ]);
+
+      // The row is no longer active, so the second cancel writes nothing at all.
+      expect(await cancel()).toEqual({ cancelled: false, messages: [] });
+      expect(await storedMessages(seeded, "chat_1")).toHaveLength(1);
+    }
+  );
+
+  postgresTest(
+    "a chat delete cancels its watches without a line in the chat",
+    async ({ prisma, postgresContainer }) => {
+      await boot(prisma, postgresContainer.getConnectionUri());
+      const seeded = await seed(prisma, "silentcancel");
+      await seedChat(seeded, "chat_1");
+
+      const created = await create({ seeded, chatId: "chat_1" });
+      expect(created.ok).toBe(true);
+
+      await deleteChatWithWatches({ chatId: "chat_1", userId: seeded.user.id });
+
+      const rows = await ctx.prisma.$queryRawUnsafe<{ message_id: string }[]>(
+        `select message_id from trigger_dashboard_agent.chat_messages where chat_id = 'chat_1'`
+      );
+      expect(rows).toEqual([]);
+    }
+  );
+
   postgresTest(
     "aggregates active watches per chat in one query",
     async ({ prisma, postgresContainer }) => {

internal-packages/dashboard-agent-contracts/src/watch-wording.ts

@@ -506,6 +506,14 @@ export function watchConditionLabel(spec: WatchSpec): string {
   return watchConditionWording(spec).label;
 }
 
+/**
+ * The line a user's own cancel leaves in the transcript. States that the watch
+ * stopped and nothing about what it saw — it is not a wake.
+ */
+export function watchCancelledSentence(spec: WatchSpec): string {
+  return `Stopped watching ${watchSubjectLabel(spec)}.`;
+}
+
 /** The Watch button's tooltip. */
 export function watchTooltipLabel(spec: WatchSpec): string {
   return watchConditionWording(spec).tooltip;

internal-packages/dashboard-agent-contracts/src/watch.ts

@@ -136,6 +136,9 @@ export const WATCH_REQUEST_MESSAGE_ID_PREFIX = "watch-request:";
 /** The transcript id of the confirmation that a watch is running, keyed by the watch. */
 export const WATCH_CONFIRMATION_MESSAGE_ID_PREFIX = "watch-confirmation:";
 
+/** The transcript id of the note that the user stopped a watch, keyed by the watch. */
+export const WATCH_CANCELLED_MESSAGE_ID_PREFIX = "watch-cancelled:";
+
 /**
  * A deterministic consent record, not a turn the user spent, so it never counts
  * against the message cap and the retry button never resends it.

internal-packages/dashboard-agent/GUIDEBOOK.md

@@ -389,12 +389,13 @@ deliver — otherwise they would stay active forever — and leaves the wake owe
 ## What ends a watch without an answer
 
 A watch reaches `fired` or `expired` by resolving, and both deliver a wake.
-**Cancellation is the silent ending: no resolution, no wake, nothing to read.**
+**Cancellation is the ending without an answer: no resolution and never a wake.**
 The five reasons (`watch-schema.ts`):
 
 | Reason | When |
 | --- | --- |
 | `user` | the chip's cancel, scoped through the chat: the watch must belong to that chat and the chat to this user in this org. A no-op if it already resolved |
+| | Alone among the reasons, it leaves one neutral line in the transcript ("Stopped watching …"), keyed off the watch id so a retry can't repeat it. Still no wake, no delivery |
 | `chat_deleted` | deleting a chat cancels its watches in the same transaction, so live watches can't outlive a chat the user can no longer see |
 | `access_revoked` | the creator's access no longer holds — checked before any read |
 | `scheduling_failed` | the first tick couldn't be scheduled |