fix(webapp): resolved-watch adoption wording, stored queue name in page context

A retry that adopts a watch which has already fired or expired now confirms
what the watch found instead of claiming it is still watching.

The queue page hands the agent the stored queue name, so a queue watch it
proposes validates instead of being rejected as a missing target.

Author: kathiekiwi

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

@@ -383,7 +383,7 @@ export function DashboardAgentPanel({
     });
   }, []);
 
-  const dismissWatchCard = useCallback(() => dispatchWatchCard({ type: "dismissed" }), []);
+  const dismissWatchCard = () => dispatchWatchCard({ type: "dismissed" });
 
   const submitWatch = useCallback(async () => {
     const draft = watchCard.draft;

apps/webapp/app/components/dashboard-agent/suggested-prompts/page-mappers.test.ts

@@ -212,6 +212,12 @@ describe("queueAgentPageContext", () => {
     expect(agentPageContextSchema.safeParse(context).success).toBe(true);
   });
 
+  // A watch the agent proposes off this context is validated against the stored name.
+  it("names a task queue by its stored name, prefix and all", () => {
+    const context = queueAgentPageContext(queueLoaderData({ type: "task", name: "send-receipt" }));
+    expect(context?.page).toMatchObject({ kind: "queue", name: "task/send-receipt" });
+  });
+
   it("emits no saturation signal when the queue is idle under its limit", () => {
     const context = queueAgentPageContext(queueLoaderData({ running: 10, queued: 0 }));
     expect(context?.signals).toEqual([]);

apps/webapp/app/components/dashboard-agent/suggested-prompts/page-mappers.ts

@@ -4,6 +4,7 @@
  */
 import type { AgentPageContext, AgentPageSignal } from "@internal/dashboard-agent-contracts";
 import { z } from "zod";
+import { storedQueueName } from "~/components/queues/queue-name";
 import { isQueueAtCapacity, OLDEST_WAIT_WARNING_MS } from "~/components/queues/queue-thresholds";
 
 export const FRESH_FAILURE_WINDOW_MS = 30 * 60_000;
@@ -163,6 +164,7 @@ export const QUEUE_OLDEST_WAIT_WARNING_MS = OLDEST_WAIT_WARNING_MS;
 const queueLoaderDataSchema = z.object({
   queue: z.object({
     name: z.string(),
+    type: z.string(),
     paused: z.boolean().nullish(),
     running: z.number(),
     queued: z.number(),
@@ -200,7 +202,7 @@ export function queueAgentPageContext(data: unknown): AgentPageContext | undefin
   const parsed = queueLoaderDataSchema.safeParse(data);
   if (!parsed.success) return undefined;
 
-  const { name, paused, running, queued, concurrencyLimit } = parsed.data.queue;
+  const { name, type, paused, running, queued, concurrencyLimit } = parsed.data.queue;
   const { environmentConcurrencyLimit, oldestQueuedAt, loadedAt, ckBreakdown } = parsed.data;
   const limit = concurrencyLimit ?? environmentConcurrencyLimit ?? null;
   const atCapacity = isQueueAtCapacity({ running, queued, limit });
@@ -217,7 +219,11 @@ export function queueAgentPageContext(data: unknown): AgentPageContext | undefin
     signals.push({ kind: "concurrency_saturation", severity: queued >= limit! ? "crit" : "warn" });
   }
 
-  return { page: { kind: "queue", name, health, paused: Boolean(paused) }, signals };
+  // The stored name, not the display one: a watch the agent proposes has to validate against it.
+  return {
+    page: { kind: "queue", name: storedQueueName({ type, name }), health, paused: Boolean(paused) },
+    signals,
+  };
 }
 
 export function deploymentsAgentPageContext(): AgentPageContext {

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

@@ -37,6 +37,7 @@ import {
   watchIdentity,
   watchOneShotBlockBody,
   watchRequestSentence,
+  watchResolvedBlockBody,
   watchSubjectLabel,
   type WatchDraft,
   type WatchExternalNotification,
@@ -609,8 +610,27 @@ export async function submitDashboardAgentWatch(params: {
     unavailable: boolean;
     external: WatchExternalNotification;
     confirmed?: WatchDraft;
+    /** The row this settles against, when the caller already read it. */
+    watch?: Watch | null;
   }) => {
     const confirmed = args.confirmed ?? draft;
+    // A retry can settle against a watch that already ran: say what it found, not "watching".
+    const resolution = args.watch?.status !== "active" ? args.watch?.resolution : null;
+    if (args.watch && resolution) {
+      return confirmationMessage({
+        id: `${WATCH_CONFIRMATION_MESSAGE_ID_PREFIX}${args.watchId}`,
+        blockId: args.watchId,
+        body: watchResolvedBlockBody({
+          watchId: args.watchId,
+          resolved: {
+            kind: confirmed.spec.kind,
+            identity: args.watch.identity,
+            resolution,
+            observed: args.watch.observedOutcome,
+          },
+        }),
+      });
+    }
     return confirmationMessage({
       id: `${WATCH_CONFIRMATION_MESSAGE_ID_PREFIX}${args.watchId}`,
       blockId: args.watchId,
@@ -649,6 +669,7 @@ export async function submitDashboardAgentWatch(params: {
       return settle({
         confirmation: watchingConfirmation({
           watchId: recorded.watchId,
+          watch: await getWatch(dashboardAgentDb, { id: recorded.watchId }),
           unavailable: recorded.unavailable,
           // Recorded, never re-decided: the confirmation already in the transcript is
           // append-once, so a second decision here would contradict it forever.
@@ -796,6 +817,8 @@ export async function submitDashboardAgentWatch(params: {
     unavailable: boolean;
     /** The watch was already there: this call adopted it rather than creating it. */
     adopted: boolean;
+    /** The adopted row. Absent when this call created the watch, so it is active. */
+    watch?: Watch | null;
   }): Promise<SubmitWatchCardResult> => {
     // Attached after the watch exists, and a failure here never fails the creation — it is
     // said out loud in the confirmation instead, and recorded so a replay repeats it.
@@ -830,6 +853,7 @@ export async function submitDashboardAgentWatch(params: {
     return settle({
       confirmation: watchingConfirmation({
         watchId: args.watchId,
+        watch: args.watch,
         unavailable: args.unavailable,
         external,
       }),
@@ -851,7 +875,12 @@ export async function submitDashboardAgentWatch(params: {
       });
     }
     // `unavailable` isn't recoverable here: it belonged to the attempt that died.
-    return settleCreated({ watchId: reserved.id, unavailable: false, adopted: true });
+    return settleCreated({
+      watchId: reserved.id,
+      unavailable: false,
+      adopted: true,
+      watch: reserved,
+    });
   }
 
   const result = await create({

apps/webapp/test/dashboardAgentWatches.test.ts

@@ -2300,6 +2300,49 @@ describe("the watch card submit", () => {
     }
   );
 
+  postgresTest(
+    "converging on a watch that already fired confirms the outcome, not 'watching'",
+    async ({ prisma, postgresContainer }) => {
+      await boot(prisma, postgresContainer.getConnectionUri());
+      const seeded = await seed(prisma, "submit-converge-fired");
+      await seedChat(seeded);
+
+      let reservedWatchId = "";
+      await expect(
+        submit({
+          seeded,
+          chatId: "chat_1",
+          create: async (createParams) => {
+            reservedWatchId = createParams.watchId!;
+            await createDashboardAgentWatch(createParams);
+            throw new Error("died after the watch was created");
+          },
+        })
+      ).rejects.toThrow("died after the watch was created");
+
+      // The watch ran and woke the chat before anyone retried the submit.
+      await transitionWatchCondition(ctx.agentDb, {
+        id: reservedWatchId,
+        resolution: "condition_met",
+        observedOutcome: { kind: "run_start", verified: true, status: "EXECUTING", started: true },
+      });
+
+      const retry = await submit({ seeded, chatId: "chat_1" });
+
+      expect(retry.ok).toBe(true);
+      if (!retry.ok) return;
+      // Still one row, still the same watch: adoption is not refused.
+      expect(retry.watchId).toBe(reservedWatchId);
+      expect(await countWatchRows(prisma, "chat_1")).toBe(1);
+
+      const parts = retry.messages.at(-1)?.parts ?? [];
+      const block = (parts[0] as any).data.blocks[0];
+      expect(block.outcome).toBe("already_true");
+      expect(block.headline).not.toContain("Watching");
+      expect(block.lifetime).toBeNull();
+    }
+  );
+
   postgresTest(
     "a refusal that wins the race leaves no live watch behind",
     async ({ prisma, postgresContainer }) => {

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

@@ -614,6 +614,31 @@ export function watchConfirmationBlockBody(args: {
   };
 }
 
+/**
+ * The confirmation for a watch that had already resolved before this submission settled
+ * (a retry adopting a fired or expired row). It states the outcome the watch reached
+ * rather than claiming something is still being watched.
+ */
+export function watchResolvedBlockBody(args: { watchId: string; resolved: WatchResolvedInput }): {
+  type: "watch_result";
+  outcome: "already_true" | "impossible";
+  headline: string;
+  lifetime: null;
+  detail: null;
+  followUp: never[];
+  watchId: string;
+} {
+  return {
+    type: "watch_result",
+    outcome: args.resolved.resolution === "condition_met" ? "already_true" : "impossible",
+    headline: presentResolvedWatch(args.resolved).headline,
+    lifetime: null,
+    detail: null,
+    followUp: [],
+    watchId: args.watchId,
+  };
+}
+
 /**
  * The one-shot result block: the immediate check answered outright, so no watch was
  * created. Nothing is running, so there is no lifetime and no follow-ups.

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

@@ -37,6 +37,12 @@ export const WATCH_STALL_TICKS_MAX = 12;
 /** Ceiling on the `queue_oldest_age` SLA. */
 export const WATCH_MAX_QUEUE_AGE_MINUTES = 24 * 60;
 
+const watchQueueNameSchema = z
+  .string()
+  .describe(
+    "The stored queue name, keeping the `task/` prefix for task queues (e.g. `task/send-receipt`) — not the display name."
+  );
+
 /**
  * Kinds taking the same fields share one member with a `kind` enum. They still ask
  * different questions — `run_failed` inverts `run_finished`, `queue_depth_below` is
@@ -50,12 +56,12 @@ export const watchSpecSchema = z.discriminatedUnion("kind", [
     })
     .merge(runStateCadenceSchema),
   watchCommonSchema
-    .extend({ kind: z.literal("backlog_drain"), queue: z.string() })
+    .extend({ kind: z.literal("backlog_drain"), queue: watchQueueNameSchema })
     .merge(standardCadenceSchema),
   watchCommonSchema
     .extend({
       kind: z.enum(["queue_depth_above", "queue_depth_below"]),
-      queue: z.string(),
+      queue: watchQueueNameSchema,
       threshold: z.number().int().nonnegative().max(WATCH_MAX_QUEUE_THRESHOLD),
     })
     .merge(standardCadenceSchema),
@@ -64,7 +70,7 @@ export const watchSpecSchema = z.discriminatedUnion("kind", [
   watchCommonSchema
     .extend({
       kind: z.literal("queue_stalled"),
-      queue: z.string(),
+      queue: watchQueueNameSchema,
       ticks: z
         .number()
         .int()
@@ -76,7 +82,7 @@ export const watchSpecSchema = z.discriminatedUnion("kind", [
   watchCommonSchema
     .extend({
       kind: z.literal("queue_oldest_age"),
-      queue: z.string(),
+      queue: watchQueueNameSchema,
       thresholdMinutes: z.number().int().positive().max(WATCH_MAX_QUEUE_AGE_MINUTES),
     })
     .merge(standardCadenceSchema),