test(webapp): pin the settlement failure window and the open panel

Covers the two halves the earlier pass left open. Against a real database, a
stale card that cannot be rendered now proves the sweep rolls the settle back
with it: the row stays `in_progress` at revision 0, the chat stays empty, and
the row is still in the next run's selection.

The panel half is covered over `liveProgress`, the code that decides whether
"Working…" is shown: a mounted panel holding the unconcluded card re-reads the
stored transcript, merges by stable id, and the progress line goes away without
a reload. Re-reading repeatedly cannot add a second copy of the card.

Author: kathiekiwi

apps/webapp/app/components/dashboard-agent/settled-transcript.test.ts

@@ -0,0 +1,144 @@
+import { VIEW_BLOCK_VERSION } from "@internal/dashboard-agent-contracts";
+import { describe, expect, it } from "vitest";
+import { liveProgress } from "./progress-line";
+import {
+  hasOpenInvestigation,
+  mergeSettledMessages,
+  pollSettledTranscript,
+} from "./settled-transcript";
+
+/**
+ * The open panel. A settled turn writes its terminal card to the chat row rather than
+ * pushing a stream chunk, so a panel that stays mounted has to re-read the transcript
+ * or it renders the last `in_progress` revision forever.
+ */
+
+const INVESTIGATION_ID = "inv_open_panel";
+
+function cardMessage(args: { id: string; revision: number; outcome: string; progress?: string }) {
+  return {
+    id: args.id,
+    role: "assistant",
+    parts: [
+      {
+        type: "tool-render_view",
+        toolCallId: args.id,
+        state: "output-available",
+        output: {
+          blocks: [
+            {
+              type: "investigation",
+              id: INVESTIGATION_ID,
+              revision: args.revision,
+              version: VIEW_BLOCK_VERSION,
+              investigation: { outcome: args.outcome, progress: args.progress },
+            },
+          ],
+        },
+      },
+    ],
+  };
+}
+
+const OPEN = cardMessage({
+  id: "msg_open",
+  revision: 0,
+  outcome: "in_progress",
+  progress: "Reading the run's spans",
+});
+
+const SETTLED = cardMessage({
+  id: `investigation-settlement:${INVESTIGATION_ID}:1`,
+  revision: 1,
+  outcome: "inconclusive",
+});
+
+describe("merging a re-read transcript", () => {
+  it("adds only what the panel doesn't have, keeping what is already rendered in place", () => {
+    const merged = mergeSettledMessages([OPEN], [OPEN, SETTLED]);
+    expect(merged.map((message) => message.id)).toEqual([OPEN.id, SETTLED.id]);
+    expect(merged[0]).toBe(OPEN);
+  });
+
+  it("cannot produce a second copy of a card, however many times it re-reads", () => {
+    let merged = mergeSettledMessages([OPEN], [OPEN, SETTLED]);
+    merged = mergeSettledMessages(merged, [OPEN, SETTLED]);
+    merged = mergeSettledMessages(merged, [OPEN, SETTLED]);
+    expect(merged.filter((message) => message.id === SETTLED.id)).toHaveLength(1);
+  });
+
+  it("returns the same array when the re-read adds nothing, so no render is forced", () => {
+    const current = [OPEN, SETTLED];
+    expect(mergeSettledMessages(current, [OPEN, SETTLED])).toBe(current);
+  });
+});
+
+describe("an already-open panel when a turn is exhausted", () => {
+  it("stops showing Working… without a reload or a reopen", async () => {
+    // What the mounted panel holds when the stream closes: the card the model opened
+    // and never concluded, and no turn in flight.
+    let rendered: (typeof OPEN)[] = [OPEN];
+    expect(liveProgress(rendered, null)).toEqual({
+      source: "investigation",
+      label: "Reading the run's spans",
+    });
+
+    // The stored transcript, which `onTurnComplete` has closed out by now.
+    const waits: number[] = [];
+    await pollSettledTranscript({
+      fetchTranscript: async () => [OPEN, SETTLED],
+      apply: (merge) => void (rendered = merge(rendered)),
+      wait: async (ms) => void waits.push(ms),
+    });
+
+    expect(rendered.map((message) => message.id)).toEqual([OPEN.id, SETTLED.id]);
+    // The panel's own progress line is gone: the winning revision is terminal.
+    expect(liveProgress(rendered, null)).toBeNull();
+    // One re-read was enough, because the transcript came back closed.
+    expect(waits).toHaveLength(1);
+  });
+
+  it("retries while the stored transcript is still open, because the write lands after the stream closes", async () => {
+    const responses = [[OPEN], [OPEN], [OPEN, SETTLED]];
+    let rendered: (typeof OPEN)[] = [OPEN];
+    let reads = 0;
+
+    await pollSettledTranscript({
+      fetchTranscript: async () => responses[reads++] ?? null,
+      apply: (merge) => void (rendered = merge(rendered)),
+      wait: async () => {},
+    });
+
+    expect(reads).toBe(3);
+    expect(hasOpenInvestigation(rendered)).toBe(false);
+  });
+
+  it("gives up rather than polling forever, leaving the sweep as the backstop", async () => {
+    let reads = 0;
+    await pollSettledTranscript({
+      fetchTranscript: async () => {
+        reads++;
+        return [OPEN];
+      },
+      apply: () => {},
+      wait: async () => {},
+      delays: [0, 0],
+    });
+
+    expect(reads).toBe(2);
+  });
+
+  it("stops on a failed re-read instead of hammering the endpoint", async () => {
+    let reads = 0;
+    await pollSettledTranscript<typeof OPEN>({
+      fetchTranscript: async () => {
+        reads++;
+        return null;
+      },
+      apply: () => {},
+      wait: async () => {},
+    });
+
+    expect(reads).toBe(1);
+  });
+});

apps/webapp/test/dashboardAgentInvestigationSweep.test.ts

@@ -5,7 +5,7 @@ import {
   getInvestigation,
   investigationSettlementMessageId,
   listStaleOpenInvestigations,
-  settleInvestigationAsInconclusive,
+  settleInvestigationAndCloseCard,
   upsertInvestigationRevision,
   type DashboardAgentDb,
   type DashboardAgentDbClient,
@@ -309,6 +309,52 @@ describe("the dashboard agent investigation sweep", () => {
     }
   );
 
+  /**
+   * The failure window. Settling the row and delivering its card used to be two
+   * operations: once the row was terminal, a failed append left a card reading
+   * `in_progress` that nothing would ever repair, because this sweep only selects
+   * `in_progress` rows. They must land together or not at all.
+   */
+  postgresTest(
+    "a card that can't be delivered leaves the row in_progress, so the next run retries it",
+    async ({ prisma, postgresContainer }) => {
+      await boot(prisma, postgresContainer.getConnectionUri());
+      await seedChat("chat_undeliverable");
+      // A state the settle can merge but no card can be rendered from, so the delivery
+      // half genuinely fails against a real database.
+      const id = await seedInvestigation({
+        chatId: "chat_undeliverable",
+        state: { outcome: "in_progress" } as unknown as InvestigationState,
+        ageMs: STALE_AGE_MS,
+      });
+
+      await expect(sweepDashboardAgentInvestigations()).rejects.toThrow(
+        /failed on 1 investigations/
+      );
+
+      // The settle rolled back with the card: no half-applied terminal row.
+      const row = await getInvestigation(ctx.agentDb, { id });
+      expect(row?.revision).toBe(0);
+      expect((row?.state as { outcome?: string }).outcome).toBe("in_progress");
+      expect(
+        await getChatMessages(ctx.agentDb, {
+          chatId: "chat_undeliverable",
+          userId: "user_sweep",
+          organizationId: "org_sweep",
+        })
+      ).toEqual([]);
+
+      // And it is still in the selection, so the sweep keeps trying rather than
+      // leaving a permanent spinner behind.
+      const stale = await listStaleOpenInvestigations(ctx.agentDb, {
+        olderThan: new Date(),
+        limit: 10,
+      });
+      expect(stale.map((candidate) => candidate.id)).toEqual([id]);
+    },
+    30_000
+  );
+
   postgresTest(
     "one failing row doesn't cost the batch, and the run throws so the job retries",
     async ({ prisma, postgresContainer }) => {
@@ -328,10 +374,10 @@ describe("the dashboard agent investigation sweep", () => {
       const attempted: string[] = [];
       await expect(
         sweepDashboardAgentInvestigations({
-          settle: async (params) => {
+          settleAndClose: async (params) => {
             attempted.push(params.id);
             if (params.id === first) throw new Error("the settle failed");
-            return settleInvestigationAsInconclusive(ctx.agentDb, params);
+            return settleInvestigationAndCloseCard(ctx.agentDb, params);
           },
         })
       ).rejects.toThrow(/failed on 1 investigations/);

apps/webapp/test/dashboardAgentInvestigationSweepCard.test.ts

@@ -1,4 +1,5 @@
 import {
+  investigationSettlementMessage,
   investigationSettlementMessageId,
   type Investigation,
   type InvestigationCardMessage,
@@ -93,24 +94,32 @@ function staleRow(state: InvestigationState): Investigation {
 
 /**
  * Stands in for the datastore: the conditional settle (`in_progress` only, mirroring
- * `forceSettledInvestigationState`) and the id-deduped append.
+ * `forceSettledInvestigationState`) and the id-deduped append, as one operation —
+ * which is what the real query is, so a half-applied settle can't exist.
  */
 function fakeStore(initial: InvestigationState) {
   const row = { revision: 0, state: initial };
   const appended: InvestigationCardMessage[] = [];
   return {
     row,
     appended,
-    settle: async (params: { id: string; note: string }) => {
+    settleAndClose: async (params: { id: string; chatId: string; note: string }) => {
       if (investigationStateSchema.parse(row.state).outcome !== "in_progress") return null;
-      row.state = forceSettledInvestigationState(investigationStateSchema.parse(row.state));
-      row.revision += 1;
-      return { id: params.id, revision: row.revision, state: row.state };
-    },
-    closeCard: async (params: { chatId: string; message: InvestigationCardMessage }) => {
-      if (appended.some((message) => message.id === params.message.id)) return false;
-      appended.push(params.message);
-      return true;
+      const state = forceSettledInvestigationState(investigationStateSchema.parse(row.state));
+      const revision = row.revision + 1;
+
+      const message = investigationSettlementMessage({
+        investigationId: params.id,
+        revision,
+        state,
+      });
+      if (!message) throw new Error("the closing card didn't validate");
+
+      row.state = state;
+      row.revision = revision;
+      const closed = !appended.some((existing) => existing.id === message.id);
+      if (closed) appended.push(message);
+      return { settled: { id: params.id, revision, state }, closed };
     },
   };
 }
@@ -122,8 +131,7 @@ describe("the dashboard agent investigation sweep's closing card", () => {
 
     const result = await sweepDashboardAgentInvestigations({
       listStale: async () => [staleRow(open)],
-      settle: store.settle,
-      closeCard: store.closeCard,
+      settleAndClose: store.settleAndClose,
     });
 
     expect(store.appended).toHaveLength(1);
@@ -166,8 +174,7 @@ describe("the dashboard agent investigation sweep's closing card", () => {
     const store = fakeStore(open);
     const deps = {
       listStale: async () => [staleRow(open)],
-      settle: store.settle,
-      closeCard: store.closeCard,
+      settleAndClose: store.settleAndClose,
     };
 
     await sweepDashboardAgentInvestigations(deps);

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

@@ -1,12 +1,6 @@
 import { chat } from "@trigger.dev/sdk/ai";
 import { locals, logger, tasks } from "@trigger.dev/sdk";
-import {
-  generateText,
-  stepCountIs,
-  streamText,
-  type ModelMessage,
-  type UIMessage,
-} from "ai";
+import { generateText, stepCountIs, streamText, type ModelMessage, type UIMessage } from "ai";
 import {
   orgAllowsTurnEvals,
   redactEvalToolValue,