fix(webapp): replay keeps the recorded watch confirmation; resolved wording follows the presented category

Author: kathiekiwi

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

@@ -669,7 +669,6 @@ 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.

apps/webapp/test/dashboardAgentWatches.test.ts

@@ -2450,6 +2450,37 @@ describe("the watch card submit", () => {
       expect(await storedMessages(seeded, "chat_1")).toEqual(transcript);
     }
   );
+
+  postgresTest(
+    "a replay repeats the recorded 'Watching' confirmation after the watch has fired",
+    async ({ prisma, postgresContainer }) => {
+      await boot(prisma, postgresContainer.getConnectionUri());
+      const seeded = await seed(prisma, "submit-replay-fired");
+      await seedChat(seeded);
+
+      const first = await submit({ seeded, chatId: "chat_1" });
+      expect(first.ok).toBe(true);
+      if (!first.ok || !first.watchId) return;
+
+      await transitionWatchCondition(ctx.agentDb, {
+        id: first.watchId,
+        resolution: "condition_met",
+      });
+
+      const retry = await submit({ seeded, chatId: "chat_1" });
+
+      expect(retry.ok).toBe(true);
+      if (!retry.ok) return;
+      expect(retry.repaired).toBe(true);
+
+      // The recorded outcome is replayed, never decided again: the append-once
+      // confirmation in the transcript says "Watching", so the answer has to as well.
+      const parts = retry.messages.at(-1)?.parts ?? [];
+      const block = (parts[0] as any).data.blocks[0];
+      expect(block.outcome).toBe("watching");
+      expect(block.headline).toContain("Watching");
+    }
+  );
 });
 
 describe("appendChatMessageOnce", () => {

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

@@ -628,10 +628,11 @@ export function watchResolvedBlockBody(args: { watchId: string; resolved: WatchR
   followUp: never[];
   watchId: string;
 } {
+  const presented = presentResolvedWatch(args.resolved);
   return {
     type: "watch_result",
-    outcome: args.resolved.resolution === "condition_met" ? "already_true" : "impossible",
-    headline: presentResolvedWatch(args.resolved).headline,
+    outcome: presented.category === "positive" ? "already_true" : "impossible",
+    headline: presented.headline,
     lifetime: null,
     detail: null,
     followUp: [],

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

@@ -23,6 +23,7 @@ import {
   type WatchKind,
   type WatchSpec,
 } from "./watch.js";
+import { watchResolvedBlockBody } from "./watch-wording.js";
 
 const common = { maxHours: 6, note: "because I asked" };
 
@@ -583,3 +584,30 @@ describe("resolveWatchResult", () => {
     ).toBe("queue_drained");
   });
 });
+
+describe("watchResolvedBlockBody", () => {
+  const identity = watchIdentity(specs.run_failed as WatchSpec);
+
+  it("marks good news as already true even when the window merely ran out", () => {
+    expect(
+      watchResolvedBlockBody({
+        watchId: "watch_1",
+        resolved: { kind: "run_failed", identity, resolution: "window_completed" },
+      }).outcome
+    ).toBe("already_true");
+  });
+
+  it("does not put a success check on bad news the watch caught", () => {
+    expect(
+      watchResolvedBlockBody({
+        watchId: "watch_1",
+        resolved: {
+          kind: "run_failed",
+          identity,
+          resolution: "condition_met",
+          observed: watchObservedOutcomeSchema.parse({ kind: "run_failed" }),
+        },
+      }).outcome
+    ).toBe("impossible");
+  });
+});