fix(webapp): have the stale-investigation sweep close the card it settles

The sweep settled the row and appended nothing, so it visibly fixed nothing: the
chat kept rendering the last card it had, which was still "Working…". The settle
now returns the state and revision it wrote, and the sweep appends that as the
closing card revision on the chat — id-deduped on
`investigation-settlement:{id}:{revision}`, so a retried run can neither stack a
second card nor open a second investigation.

The append is scoped by chat id: a sweep runs off any session and has no user in
context, unlike the turn lane.

Author: kathiekiwi

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

@@ -4,9 +4,13 @@
  */
 
 import {
+  appendChatMessageOnceByChatId,
+  investigationSettlementMessage,
   listStaleOpenInvestigations,
   settleInvestigationAsInconclusive,
   type Investigation,
+  type InvestigationCardMessage,
+  type SettledInvestigation,
 } from "@internal/dashboard-agent-db";
 import { UNSETTLED_INVESTIGATION_NOTE } from "@internal/dashboard-agent-contracts";
 import { dashboardAgentDb } from "~/services/dashboardAgentDb.server";
@@ -25,6 +29,8 @@ export type InvestigationSweepResult = {
   /** Stale `in_progress` rows seen. */
   stale: number;
   settled: number;
+  /** Settled rows whose closing card reached the chat. */
+  closed: number;
   /** A turn (or another sweep) settled it first. */
   alreadySettled: number;
   failed: number;
@@ -34,8 +40,10 @@ export type InvestigationSweepDeps = {
   now?: () => Date;
   limit?: number;
   listStale?: (params: { olderThan: Date; limit: number }) => Promise<Investigation[]>;
-  /** Settle one row. False when it was no longer `in_progress`. */
-  settle?: (params: { id: string; note: string }) => Promise<boolean>;
+  /** Settle one row. Null when it was no longer `in_progress`. */
+  settle?: (params: { id: string; note: string }) => Promise<SettledInvestigation | null>;
+  /** Append the closing card to the chat. False when that message id is already there. */
+  closeCard?: (params: { chatId: string; message: InvestigationCardMessage }) => Promise<boolean>;
 };
 
 /**
@@ -51,10 +59,13 @@ export async function sweepDashboardAgentInvestigations(
     deps.listStale ?? ((params) => listStaleOpenInvestigations(dashboardAgentDb, params));
   const settle =
     deps.settle ?? ((params) => settleInvestigationAsInconclusive(dashboardAgentDb, params));
+  const closeCard =
+    deps.closeCard ?? ((params) => appendChatMessageOnceByChatId(dashboardAgentDb, params));
 
   const result: InvestigationSweepResult = {
     stale: 0,
     settled: 0,
+    closed: 0,
     alreadySettled: 0,
     failed: 0,
   };
@@ -68,8 +79,28 @@ export async function sweepDashboardAgentInvestigations(
   for (const investigation of stale) {
     try {
       const settled = await settle({ id: investigation.id, note: UNSETTLED_INVESTIGATION_NOTE });
-      if (settled) result.settled++;
-      else result.alreadySettled++;
+      if (!settled) {
+        result.alreadySettled++;
+        continue;
+      }
+      result.settled++;
+
+      // Settling the row fixes nothing on its own: the chat renders the winning card
+      // from its own transcript, so an unappended settle is still a stuck spinner.
+      const message = investigationSettlementMessage({
+        investigationId: settled.id,
+        revision: settled.revision,
+        state: settled.state,
+      });
+      if (!message) {
+        result.failed++;
+        logger.error("Dashboard agent investigation sweep: the closing card didn't validate", {
+          investigationId: settled.id,
+          chatId: investigation.chatId,
+        });
+        continue;
+      }
+      if (await closeCard({ chatId: investigation.chatId, message })) result.closed++;
     } catch (error) {
       result.failed++;
       logger.error("Dashboard agent investigation sweep: failed to settle an investigation", {

apps/webapp/test/dashboardAgentInvestigationSweep.test.ts

@@ -1,7 +1,9 @@
 import {
   createChat,
   createDashboardAgentDb,
+  getChatMessages,
   getInvestigation,
+  investigationSettlementMessageId,
   listStaleOpenInvestigations,
   settleInvestigationAsInconclusive,
   upsertInvestigationRevision,
@@ -155,7 +157,38 @@ describe("the dashboard agent investigation sweep", () => {
       expect(state.hypotheses).toHaveLength(1);
       expect(state.title).toBe("send-order-receipt keeps failing");
       expect(row?.revision).toBe(1);
-    }
+
+      // The settled row is invisible on its own: the panel resolves the card from the
+      // transcript, so the closing revision has to be in the chat too.
+      const messages = (await getChatMessages(ctx.agentDb, {
+        chatId: "chat_stale",
+        userId: "user_sweep",
+        organizationId: "org_sweep",
+      })) as { id: string; parts: Record<string, any>[] }[] | null;
+      expect(messages?.map((message) => message.id)).toEqual([
+        investigationSettlementMessageId(id, 1),
+      ]);
+      const block = messages![0]!.parts[0]!.output.blocks[0];
+      expect(block).toMatchObject({ type: "investigation", id, revision: 1 });
+      expect(block.investigation.outcome).toBe("inconclusive");
+      expect(result.closed).toBe(1);
+
+      // A second run can't stack a second card: the settle is a no-op and the append
+      // is deduped on the same message id.
+      expect(await sweepDashboardAgentInvestigations()).toMatchObject({ stale: 0, settled: 0 });
+      expect(
+        (
+          (await getChatMessages(ctx.agentDb, {
+            chatId: "chat_stale",
+            userId: "user_sweep",
+            organizationId: "org_sweep",
+          })) as unknown[]
+        ).length
+      ).toBe(1);
+    },
+    // This one pays the container boot and the schema replay, and now asserts the
+    // transcript on top.
+    30_000
   );
 
   postgresTest(
@@ -260,7 +293,13 @@ describe("the dashboard agent investigation sweep", () => {
       expect(concluded.ok).toBe(true);
 
       const result = await sweepDashboardAgentInvestigations({ listStale: async () => stale });
-      expect(result).toMatchObject({ stale: 1, settled: 0, alreadySettled: 1, failed: 0 });
+      expect(result).toMatchObject({
+        stale: 1,
+        settled: 0,
+        closed: 0,
+        alreadySettled: 1,
+        failed: 0,
+      });
 
       const row = await getInvestigation(ctx.agentDb, { id });
       const state = investigationStateSchema.parse(row?.state);

apps/webapp/test/dashboardAgentInvestigationSweepCard.test.ts

@@ -0,0 +1,182 @@
+import {
+  investigationSettlementMessageId,
+  type Investigation,
+  type InvestigationCardMessage,
+} from "@internal/dashboard-agent-db";
+import {
+  forceSettledInvestigationState,
+  investigationStateSchema,
+  UNSETTLED_INVESTIGATION_NOTE,
+  VIEW_BLOCK_VERSION,
+  type InvestigationState,
+} from "@internal/dashboard-agent-contracts";
+import { describe, expect, it, vi } from "vitest";
+import { liveInvestigation } from "~/components/dashboard-agent/progress-line";
+
+// The sweep's own datastore is never reached here: every write is injected. The
+// connection is only stubbed so importing the service doesn't open a pool.
+vi.mock("~/services/dashboardAgentDb.server", () => ({ dashboardAgentDb: undefined }));
+
+const { sweepDashboardAgentInvestigations } =
+  await import("~/services/dashboardAgentInvestigationSweep.server");
+
+/**
+ * The transcript half of the sweep, without a container: settling the row is invisible
+ * to the panel, which resolves a card from the chat's own `render_view` parts.
+ *
+ * The database half — that the closing card actually lands in `chats.messages` — is
+ * covered by `dashboardAgentInvestigationSweep.test.ts`, which needs Postgres.
+ */
+
+const CHAT_ID = "chat_sweep_card";
+const INVESTIGATION_ID = "inv_sweep_card";
+
+function openState(): InvestigationState {
+  return investigationStateSchema.parse({
+    outcome: "in_progress",
+    severity: "warn",
+    confidence: "medium",
+    title: "send-order-receipt keeps failing",
+    headline: "Checking whether the failures share a payload.",
+    progress: "Reading the run's spans",
+    hypotheses: [
+      {
+        id: "h1",
+        statement: "The new payload dropped a field the task reads.",
+        verdict: "testing",
+        evidence: [],
+      },
+    ],
+    evidence: [],
+  });
+}
+
+/** The card the agent left behind, as the transcript holds it. */
+function openCardMessage(state: InvestigationState) {
+  return {
+    id: "msg_open",
+    role: "assistant",
+    parts: [
+      {
+        type: "tool-render_view",
+        toolCallId: "tc_open",
+        state: "output-available",
+        input: { blocks: [{ type: "investigation", investigation: state }] },
+        output: {
+          blocks: [
+            {
+              type: "investigation",
+              investigation: state,
+              id: INVESTIGATION_ID,
+              revision: 0,
+              version: VIEW_BLOCK_VERSION,
+            },
+          ],
+        },
+      },
+    ],
+  };
+}
+
+function staleRow(state: InvestigationState): Investigation {
+  return {
+    id: INVESTIGATION_ID,
+    chatId: CHAT_ID,
+    projectRef: "proj_sweep",
+    environmentRef: "env_sweep",
+    revision: 0,
+    state,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  } as Investigation;
+}
+
+/**
+ * Stands in for the datastore: the conditional settle (`in_progress` only, mirroring
+ * `forceSettledInvestigationState`) and the id-deduped append.
+ */
+function fakeStore(initial: InvestigationState) {
+  const row = { revision: 0, state: initial };
+  const appended: InvestigationCardMessage[] = [];
+  return {
+    row,
+    appended,
+    settle: async (params: { id: 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;
+    },
+  };
+}
+
+describe("the dashboard agent investigation sweep's closing card", () => {
+  it("appends the terminal card to the chat, so the panel stops spinning", async () => {
+    const open = openState();
+    const store = fakeStore(open);
+
+    const result = await sweepDashboardAgentInvestigations({
+      listStale: async () => [staleRow(open)],
+      settle: store.settle,
+      closeCard: store.closeCard,
+    });
+
+    expect(store.appended).toHaveLength(1);
+    expect(result).toMatchObject({ stale: 1, settled: 1, closed: 1, alreadySettled: 0, failed: 0 });
+
+    const message = store.appended[0]!;
+    expect(message.id).toBe(investigationSettlementMessageId(INVESTIGATION_ID, 1));
+    expect(message.role).toBe("assistant");
+
+    const part = message.parts[0] as {
+      type: string;
+      state: string;
+      output: { blocks: Record<string, any>[] };
+    };
+    expect(part.type).toBe("tool-render_view");
+    expect(part.state).toBe("output-available");
+    expect(part.output.blocks[0]).toMatchObject({
+      type: "investigation",
+      id: INVESTIGATION_ID,
+      revision: 1,
+      version: VIEW_BLOCK_VERSION,
+    });
+    const settled = part.output.blocks[0]!.investigation;
+    expect(settled.outcome).toBe("inconclusive");
+    expect(settled.confidence).toBe("low");
+    expect(settled.progress).toBeUndefined();
+    expect(settled.headline).toContain(UNSETTLED_INVESTIGATION_NOTE);
+    // What was checked survives: the card closes honestly, it doesn't get blanked.
+    expect(settled.hypotheses).toHaveLength(1);
+
+    // The panel, over the transcript a refresh loads: the spinner was there, and the
+    // appended revision is what ends it.
+    const transcript = [openCardMessage(open)];
+    expect(liveInvestigation(transcript)).toEqual({ progress: "Reading the run's spans" });
+    expect(liveInvestigation([...transcript, message as never])).toBeNull();
+  });
+
+  it("a retried run neither duplicates the card nor opens a second investigation", async () => {
+    const open = openState();
+    const store = fakeStore(open);
+    const deps = {
+      listStale: async () => [staleRow(open)],
+      settle: store.settle,
+      closeCard: store.closeCard,
+    };
+
+    await sweepDashboardAgentInvestigations(deps);
+    const second = await sweepDashboardAgentInvestigations(deps);
+
+    expect(store.appended.map((message) => message.id)).toEqual([
+      investigationSettlementMessageId(INVESTIGATION_ID, 1),
+    ]);
+    expect(second).toMatchObject({ stale: 1, settled: 0, closed: 0, alreadySettled: 1, failed: 0 });
+    expect(store.row.revision).toBe(1);
+  });
+});

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

@@ -679,14 +679,18 @@ export async function listStaleOpenInvestigations(
   return rows.map((row) => row.investigation);
 }
 
+/** What the settle wrote, which is what the closing card has to render. */
+export type SettledInvestigation = { id: string; revision: number; state: unknown };
+
 /**
  * Backstop for {@link listStaleOpenInvestigations}. One statement, so a turn that
- * concludes the card first wins. The merge mirrors `forceSettledInvestigationState`.
+ * concludes the card first wins — null means it was no longer `in_progress`. The merge
+ * mirrors `forceSettledInvestigationState`.
  */
 export async function settleInvestigationAsInconclusive(
   db: DashboardAgentDb,
   params: { id: string; note: string }
-): Promise<boolean> {
+): Promise<SettledInvestigation | null> {
   const rows = await db
     .update(investigations)
     .set({
@@ -704,7 +708,11 @@ export async function settleInvestigationAsInconclusive(
         sql`${investigations.state}->>'outcome' = 'in_progress'`
       )
     )
-    .returning({ id: investigations.id });
+    .returning({
+      id: investigations.id,
+      revision: investigations.revision,
+      state: investigations.state,
+    });
 
-  return rows.length > 0;
+  return rows[0] ?? null;
 }