fix(webapp): settle an investigation and its closing card in one write

The row settle, the transcript and the session state were three separate
operations. Once the row was terminal, a failed transcript write left a card
that read `in_progress` forever: the stale sweep only selects `in_progress`
rows, so nothing was left to repair it.

Both lanes now commit the pair atomically. The live turn hands its pending
settlements to `persistTurn`, which upserts the revisions, appends their cards
and writes the session in one transaction; the process-local entry survives
until that commits, so a retried `onTurnComplete` still settles. The sweep goes
through `settleInvestigationAndCloseCard`, whose rollback restores the
`in_progress` row the sweep already selects.

That also removes the last reader of the per-run `chatOwners` map, which had no
`delete` and grew for the life of the worker: the failure record now travels in
the transcript write, which needs no userId.

Separately, the consented watch investigation gets the rolling step cache. Its
ten-step `streamText` re-sent every accumulated tool output uncached; the
breakpoint helper and the per-step cache telemetry now live in `step-cache.ts`
and both lanes use them, wrapping any `prepareStep` the resolved options carry.

Author: kathiekiwi

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

@@ -21,6 +21,11 @@ import { createTranscriptOrder, orderTranscript } from "./message-order";
 import { appendRunFilters } from "./navigate-target";
 import { pendingNavigateIntents, pendingWatchIntents } from "./pending-intents";
 import type { AgentPageContext } from "./page-context-types";
+import {
+  fetchChatTranscript,
+  hasOpenInvestigation,
+  pollSettledTranscript,
+} from "./settled-transcript";
 import { useAgentMessageQuota } from "./useAgentMessageQuota";
 import { useTriggerUriResolver } from "./useTriggerUriResolver";
 import { WatchChips, type WatchChip } from "./WatchChips";
@@ -300,13 +305,27 @@ export function DashboardAgentChat({
     aiStop();
   }, [transport, chatId, aiStop]);
 
+  // Read by the settle effect, which must not re-run when the transcript changes.
+  const messagesRef = useRef(messages);
+  messagesRef.current = messages;
+
   const prevStatus = useRef(status);
   useEffect(() => {
     const wasInFlight = prevStatus.current === "streaming" || prevStatus.current === "submitted";
     const nowSettled = status === "ready" || status === "error";
-    if (wasInFlight && nowSettled) onTurnSettled();
     prevStatus.current = status;
-  }, [status, onTurnSettled]);
+    if (!wasInFlight || !nowSettled) return;
+
+    onTurnSettled();
+    // The terminal card is written to the chat row after the stream closes, so this
+    // mounted panel would otherwise keep showing the last `in_progress` revision.
+    if (!hasOpenInvestigation(messagesRef.current)) return;
+    void pollSettledTranscript<UIMessage>({
+      fetchTranscript: () => fetchChatTranscript(actionPath, chatId),
+      apply: (merge) => setMessages((current) => merge(current)),
+      wait: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+    });
+  }, [status, onTurnSettled, actionPath, chatId, setMessages]);
 
   // Not cleared on unmount: the turn carries on server-side and reports again on remount.
   useEffect(() => {

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

@@ -0,0 +1,68 @@
+import { liveInvestigation } from "./progress-line";
+
+/**
+ * Re-reading the stored transcript once a turn settles.
+ *
+ * The turn's terminal records — a force-settled investigation card, a failure
+ * record — are written to the chat row, not pushed as a stream chunk. An open panel
+ * has already closed its stream by then, so without this it keeps rendering the last
+ * `in_progress` revision and spins until the user reloads.
+ */
+
+type Identified = { id: string };
+
+/**
+ * Append-only, keyed on the message id. Ids are stable (a settlement card is
+ * `investigation-settlement:{id}:{revision}`), so re-reading the same transcript any
+ * number of times can never produce a second copy of a card, and nothing already
+ * rendered is reordered or replaced.
+ */
+export function mergeSettledMessages<T extends Identified>(current: T[], fetched: T[]): T[] {
+  const missing = fetched.filter(
+    (message) => !current.some((existing) => existing.id === message.id)
+  );
+  return missing.length === 0 ? current : [...current, ...missing];
+}
+
+/** Whether the transcript still resolves to a card mid-investigation. */
+export function hasOpenInvestigation(messages: ReadonlyArray<unknown>): boolean {
+  return liveInvestigation(messages as never) !== null;
+}
+
+/**
+ * The settlement is written in `onTurnComplete`, which runs AFTER the client's stream
+ * closes, so the first re-read can legitimately land before it. Retry a few times,
+ * then leave it: a reload and the between-turns sweep are both still backstops.
+ */
+export const SETTLE_REFETCH_DELAYS_MS = [200, 800, 2_500];
+
+export async function pollSettledTranscript<T extends Identified>(deps: {
+  fetchTranscript: () => Promise<T[] | null>;
+  apply: (merge: (current: T[]) => T[]) => void;
+  wait: (ms: number) => Promise<void>;
+  delays?: ReadonlyArray<number>;
+}): Promise<void> {
+  for (const delay of deps.delays ?? SETTLE_REFETCH_DELAYS_MS) {
+    await deps.wait(delay);
+    const fetched = await deps.fetchTranscript();
+    if (!fetched) return;
+    deps.apply((current) => mergeSettledMessages(current, fetched));
+    // The stored transcript is the authority on whether anything is still open.
+    if (!hasOpenInvestigation(fetched)) return;
+  }
+}
+
+export async function fetchChatTranscript<T extends Identified>(
+  actionPath: string,
+  chatId: string
+): Promise<T[] | null> {
+  try {
+    const res = await fetch(`${actionPath}?chatId=${encodeURIComponent(chatId)}`);
+    if (!res.ok) return null;
+    const data = (await res.json()) as { messages?: T[] };
+    return data.messages ?? null;
+  } catch (error) {
+    console.error("Dashboard agent: failed to re-read the settled transcript", error);
+    return null;
+  }
+}

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

@@ -4,13 +4,10 @@
  */
 
 import {
-  appendChatMessageOnceByChatId,
-  investigationSettlementMessage,
   listStaleOpenInvestigations,
-  settleInvestigationAsInconclusive,
+  settleInvestigationAndCloseCard,
   type Investigation,
-  type InvestigationCardMessage,
-  type SettledInvestigation,
+  type SettledInvestigationCard,
 } from "@internal/dashboard-agent-db";
 import { UNSETTLED_INVESTIGATION_NOTE } from "@internal/dashboard-agent-contracts";
 import { dashboardAgentDb } from "~/services/dashboardAgentDb.server";
@@ -40,10 +37,15 @@ export type InvestigationSweepDeps = {
   now?: () => Date;
   limit?: number;
   listStale?: (params: { olderThan: Date; limit: number }) => Promise<Investigation[]>;
-  /** 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>;
+  /**
+   * Settle one row and deliver its closing card as a single operation. Null when the
+   * row was no longer `in_progress`.
+   */
+  settleAndClose?: (params: {
+    id: string;
+    chatId: string;
+    note: string;
+  }) => Promise<SettledInvestigationCard | null>;
 };
 
 /**
@@ -57,10 +59,8 @@ export async function sweepDashboardAgentInvestigations(
   const limit = deps.limit ?? SWEEP_BATCH_LIMIT;
   const listStale =
     deps.listStale ?? ((params) => listStaleOpenInvestigations(dashboardAgentDb, params));
-  const settle =
-    deps.settle ?? ((params) => settleInvestigationAsInconclusive(dashboardAgentDb, params));
-  const closeCard =
-    deps.closeCard ?? ((params) => appendChatMessageOnceByChatId(dashboardAgentDb, params));
+  const settleAndClose =
+    deps.settleAndClose ?? ((params) => settleInvestigationAndCloseCard(dashboardAgentDb, params));
 
   const result: InvestigationSweepResult = {
     stale: 0,
@@ -78,29 +78,20 @@ export async function sweepDashboardAgentInvestigations(
 
   for (const investigation of stale) {
     try {
-      const settled = await settle({ id: investigation.id, note: UNSETTLED_INVESTIGATION_NOTE });
-      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,
+      // from its own transcript, so an unappended settle is still a stuck spinner —
+      // which is why both writes are one operation that rolls back together.
+      const outcome = await settleAndClose({
+        id: investigation.id,
+        chatId: investigation.chatId,
+        note: UNSETTLED_INVESTIGATION_NOTE,
       });
-      if (!message) {
-        result.failed++;
-        logger.error("Dashboard agent investigation sweep: the closing card didn't validate", {
-          investigationId: settled.id,
-          chatId: investigation.chatId,
-        });
+      if (!outcome) {
+        result.alreadySettled++;
         continue;
       }
-      if (await closeCard({ chatId: investigation.chatId, message })) result.closed++;
+      result.settled++;
+      if (outcome.closed) result.closed++;
     } catch (error) {
       result.failed++;
       logger.error("Dashboard agent investigation sweep: failed to settle an investigation", {

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

@@ -6,7 +6,7 @@ import {
 import { and, desc, eq, ne, sql, isNull } from "drizzle-orm";
 import type { DashboardAgentDb } from "./client.js";
 import { generateInvestigationId } from "./ids.js";
-import { lockChatForWatches } from "./internal.js";
+import { lockChatForWatches, type DashboardAgentDbOrTx } from "./internal.js";
 import {
   chats,
   chatSessions,
@@ -359,7 +359,7 @@ export async function appendChatMessageOnce(
  * the between-turns sweep runs on its own, off any session.
  */
 export async function appendChatMessageOnceByChatId(
-  db: DashboardAgentDb,
+  db: DashboardAgentDbOrTx,
   params: { chatId: string; message: { id: string } }
 ): Promise<boolean> {
   const rows = await db
@@ -381,9 +381,23 @@ export async function appendChatMessageOnceByChatId(
   return rows.length > 0;
 }
 
+/** An investigation the turn left running, and the terminal state to close it with. */
+export type PendingInvestigationSettlement = {
+  id: string;
+  projectRef: string;
+  environmentRef: string;
+  state: unknown;
+};
+
+export type PersistTurnResult = { settled: SettledInvestigation[] };
+
 /**
  * One transaction: the frontend reads `messages` and `lastEventId` in parallel, so a
  * torn write resumes from a stale cursor and double-renders the last turn.
+ *
+ * `settlements` closes the cards the turn left running in that same transaction. It has
+ * to be the same one: a settled row whose closing card didn't land is a terminal row the
+ * stale sweep no longer selects, and the panel renders the spinner forever.
  */
 export async function persistTurn(
   db: DashboardAgentDb,
@@ -395,12 +409,47 @@ export async function persistTurn(
       lastEventId?: string | null;
       runId?: string | null;
     };
+    settlements?: PendingInvestigationSettlement[];
   }
-): Promise<void> {
-  await db.transaction(async (tx) => {
+): Promise<PersistTurnResult> {
+  return db.transaction(async (tx) => {
+    const settled: SettledInvestigation[] = [];
+    const cards: InvestigationCardMessage[] = [];
+    for (const pending of params.settlements ?? []) {
+      const result = await upsertInvestigationRevision(tx, {
+        id: pending.id,
+        chatId: params.chatId,
+        projectRef: pending.projectRef,
+        environmentRef: pending.environmentRef,
+        state: pending.state,
+      });
+      // A row that no longer belongs to this chat/project/env has nothing to close.
+      if (!result.ok) continue;
+
+      const message = investigationSettlementMessage({
+        investigationId: result.id,
+        revision: result.revision,
+        state: pending.state,
+      });
+      if (!message) {
+        throw new Error(`Investigation ${result.id} settled to a state that isn't renderable`);
+      }
+      settled.push({ id: result.id, revision: result.revision, state: pending.state });
+      cards.push(message);
+    }
+
+    // Revision-stable ids, so a replayed turn writes the same transcript, not a second card.
+    const existing = new Set(
+      params.messages.flatMap((message) => {
+        const id = (message as { id?: unknown }).id;
+        return typeof id === "string" ? [id] : [];
+      })
+    );
+    const messages = [...params.messages, ...cards.filter((card) => !existing.has(card.id))];
+
     await tx
       .update(chats)
-      .set({ messages: params.messages, lastMessageAt: sql`now()`, updatedAt: sql`now()` })
+      .set({ messages, lastMessageAt: sql`now()`, updatedAt: sql`now()` })
       .where(eq(chats.id, params.chatId));
 
     await tx
@@ -420,6 +469,8 @@ export async function persistTurn(
           updatedAt: sql`now()`,
         },
       });
+
+    return { settled };
   });
 }
 
@@ -461,7 +512,7 @@ export type UpsertInvestigationResult =
  * revisions. The chat/project/environment triple is in the `WHERE`: the tenancy check.
  */
 export async function upsertInvestigationRevision(
-  db: DashboardAgentDb,
+  db: DashboardAgentDbOrTx,
   params: {
     id?: string;
     chatId: string;
@@ -688,7 +739,7 @@ export type SettledInvestigation = { id: string; revision: number; state: unknow
  * mirrors `forceSettledInvestigationState`.
  */
 export async function settleInvestigationAsInconclusive(
-  db: DashboardAgentDb,
+  db: DashboardAgentDbOrTx,
   params: { id: string; note: string }
 ): Promise<SettledInvestigation | null> {
   const rows = await db
@@ -716,3 +767,40 @@ export async function settleInvestigationAsInconclusive(
 
   return rows[0] ?? null;
 }
+
+export type SettledInvestigationCard = { settled: SettledInvestigation; closed: boolean };
+
+/**
+ * Settle a stale card and put its closing revision in the transcript, atomically.
+ *
+ * The two halves cannot be separate operations: a settle that commits without its
+ * card leaves a terminal row the stale sweep no longer selects, and the panel — which
+ * renders from the transcript — keeps the spinner forever. Rolling back restores the
+ * `in_progress` row the sweep already looks for, so the next run retries it.
+ *
+ * Null when the row was no longer `in_progress`; `closed` is false when that message
+ * id is already in the chat.
+ */
+export async function settleInvestigationAndCloseCard(
+  db: DashboardAgentDb,
+  params: { id: string; chatId: string; note: string }
+): Promise<SettledInvestigationCard | null> {
+  return db.transaction(async (tx) => {
+    const settled = await settleInvestigationAsInconclusive(tx, params);
+    if (!settled) return null;
+
+    const message = investigationSettlementMessage({
+      investigationId: settled.id,
+      revision: settled.revision,
+      state: settled.state,
+    });
+    // Nothing to deliver means the settle must not stand: a terminal row with no card
+    // is the permanent spinner this transaction exists to prevent.
+    if (!message) {
+      throw new Error(`Investigation ${settled.id} settled to a state that isn't renderable`);
+    }
+
+    const closed = await appendChatMessageOnceByChatId(tx, { chatId: params.chatId, message });
+    return { settled, closed };
+  });
+}