feat(dashboard-agent): persist the conversation through the chat.agent transcript storage

The in-dashboard agent now persists its conversation through the
`chat.agent` transcript storage adapter over its own message rows,
instead of the platform snapshot plus its own hook writes. The runtime
writes the question at turn start, the answer at turn complete, every
history edit an action makes, and the resume cursors; the panel reads
the same rows.

- The hook writes the runtime now owns are removed. Investigation
settlement keeps its own transaction so a settled row and its closing
card still commit together.
- The storage adapter normalises message bodies before writing and
refuses to save into a chat owned by another tenant.
- The panel's resume cursor comes from the transcript cursors, falling
back to the previous session column for chats written by the earlier
agent build.
- Tests assert on the transcript the runtime saved instead of on store
call counts.
- Watch wakes and consented investigations are answered with
`chat.turn()`. The action files what it has to say as a user-role
request under a stable id and returns the turn, so an ordinary turn
answers it with the agent's prompt, tools, hooks and transcript save;
the response is pinned to the id the panel already knows the record by.
The request messages are hidden by the panel and excluded from the
message cap. A wake whose wording is fixed is still streamed directly
with no model call.

Mono-RevId: 7e72e1783e44bd7e7fdec3add6e3c331622c24d1

Author: ericallam

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

@@ -2,7 +2,8 @@ import { useChat } from "@ai-sdk/react";
 import type { UIMessage } from "@ai-sdk/react";
 import type { dashboardAgent } from "@internal/dashboard-agent";
 import {
-  isWatchRequestMessageId,
+  isAgentRequestMessageId,
+  isTurnRequestMessageId,
   type AgentIntent,
   type SuggestedPrompt,
   type WatchSpec,
@@ -438,7 +439,7 @@ export function DashboardAgentChat({
   const retry = useCallback(() => {
     if (atMessageCap) return;
     const action = retryAction(
-      messages.filter((m) => !(m.role === "user" && isWatchRequestMessageId(m.id)))
+      messages.filter((m) => !(m.role === "user" && isAgentRequestMessageId(m.id)))
     );
     retryAgainstAction(action);
   }, [messages, atMessageCap, retryAgainstAction]);
@@ -621,7 +622,10 @@ export function DashboardAgentChat({
         />
       ) : (
         <DashboardAgentMessages
-          messages={messages}
+          // The request a wake or investigation turn answered is the agent asking
+          // itself, not something the user typed: it stays in the transcript for
+          // the runtime and the retry logic, and never renders.
+          messages={messages.filter((m) => !(m.role === "user" && isTurnRequestMessageId(m.id)))}
           activity={activity}
           error={effectiveError}
           onRetry={retry}

apps/webapp/app/components/dashboard-agent/message-quota.ts

@@ -1,4 +1,4 @@
-import { isWatchRequestMessageId } from "@internal/dashboard-agent-contracts";
+import { isAgentRequestMessageId } from "@internal/dashboard-agent-contracts";
 
 // Counted per user across their chats in the org, not per chat, which "New chat"
 // would reset.
@@ -106,7 +106,7 @@ export const MESSAGE_QUOTA_REACHED_REASON = "You've used your message allowance"
 export function countUserMessages(messages: { role: string; id?: string }[]): number {
   return messages.reduce(
     (total, message) =>
-      message.role === "user" && !isWatchRequestMessageId(message.id) ? total + 1 : total,
+      message.role === "user" && !isAgentRequestMessageId(message.id) ? total + 1 : total,
     0
   );
 }

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

@@ -1,3 +1,5 @@
+import { WATCH_REQUEST_MESSAGE_ID_PREFIX } from "./watch.js";
+
 /**
  * Message ids for the records the agent appends to a chat outside a user's turn.
  *
@@ -25,6 +27,48 @@ export function settledMessageId(messageId: string): string {
   return `${messageId}${SETTLED_MESSAGE_ID_SUFFIX}`;
 }
 
+/**
+ * The user-role message a wake or investigation turn answers. A watch action is an
+ * edit to the conversation, and the turn that follows it needs something to answer,
+ * so the action files the wake's facts (or the investigation brief) as a request under
+ * a stable id. It is the agent asking itself, not the user typing, so the panel hides
+ * it and it never counts against the message cap.
+ */
+export const WAKE_REQUEST_MESSAGE_ID_PREFIX = "wake-request:";
+export const INVESTIGATE_REQUEST_MESSAGE_ID_PREFIX = "investigate-request:";
+
+export function wakeRequestMessageId(actionId: string): string {
+  return `${WAKE_REQUEST_MESSAGE_ID_PREFIX}${actionId}`;
+}
+
+export function investigateRequestMessageId(actionId: string): string {
+  return `${INVESTIGATE_REQUEST_MESSAGE_ID_PREFIX}${actionId}`;
+}
+
+const AGENT_REQUEST_ID_PREFIXES = [
+  WATCH_REQUEST_MESSAGE_ID_PREFIX,
+  WAKE_REQUEST_MESSAGE_ID_PREFIX,
+  INVESTIGATE_REQUEST_MESSAGE_ID_PREFIX,
+];
+
+/** The request a wake or investigation turn answers: the agent asking itself. */
+export function isTurnRequestMessageId(id: string | undefined | null): boolean {
+  return (
+    typeof id === "string" &&
+    (id.startsWith(WAKE_REQUEST_MESSAGE_ID_PREFIX) ||
+      id.startsWith(INVESTIGATE_REQUEST_MESSAGE_ID_PREFIX))
+  );
+}
+
+/**
+ * A user-role message the user did not type: a watch consent record, or the request
+ * a wake or investigation turn answers. Hidden by the panel, excluded from the message
+ * cap, and never the exchange that names a chat.
+ */
+export function isAgentRequestMessageId(id: string | undefined | null): boolean {
+  return typeof id === "string" && AGENT_REQUEST_ID_PREFIXES.some((p) => id.startsWith(p));
+}
+
 const TRAILING_RECORD_ID_PREFIXES = [
   WAKE_MESSAGE_ID_PREFIX,
   INVESTIGATE_MESSAGE_ID_PREFIX,

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

@@ -1,7 +1,9 @@
 import {
+  INVESTIGATE_REQUEST_MESSAGE_ID_PREFIX,
   investigationBlockSchema,
   toWellFormedDeep,
   VIEW_BLOCK_VERSION,
+  WAKE_REQUEST_MESSAGE_ID_PREFIX,
   WATCH_REQUEST_MESSAGE_ID_PREFIX,
 } from "@internal/dashboard-agent-contracts";
 import { and, desc, eq, inArray, ne, notLike, sql, isNull, type SQL } from "drizzle-orm";
@@ -17,7 +19,6 @@ import {
   investigations,
   watches,
   watchSubmissions,
-  type ChatSession,
   type Investigation,
   type NewChatTurnEval,
   type Watch,
@@ -121,7 +122,11 @@ export async function countUserMessages(
         eq(chats.userId, params.userId),
         isNull(chats.deletedAt),
         eq(chatMessages.role, "user"),
+        // The user-role messages the user did not type: a watch consent record, and
+        // the request a wake or investigation turn answers.
         notLike(chatMessages.messageId, `${WATCH_REQUEST_MESSAGE_ID_PREFIX}%`),
+        notLike(chatMessages.messageId, `${WAKE_REQUEST_MESSAGE_ID_PREFIX}%`),
+        notLike(chatMessages.messageId, `${INVESTIGATE_REQUEST_MESSAGE_ID_PREFIX}%`),
         params.excludeChatId ? ne(chatMessages.chatId, params.excludeChatId) : undefined
       )
     );
@@ -193,30 +198,60 @@ export async function countChatsWithUnreadWork(
   return rows[0]?.count ?? 0;
 }
 
-/** Joins `chats` to scope by owner, because `chat_sessions` has no `userId`. */
+/** What a refreshed client needs to resume a chat's live stream. */
+export type ChatResumeSession = {
+  chatId: string;
+  /** The agent run's own token. The webapp mints the browser its own; this is kept for replay. */
+  publicAccessToken: string | null;
+  /** The `.out` cursor a reconnecting client resumes from. */
+  lastEventId: string | null;
+  runId: string | null;
+  updatedAt: Date;
+};
+
+/**
+ * Scoped by owner through `chats`, because `chat_sessions` has no `userId`.
+ *
+ * The cursor comes from `chats.transcript_cursors`, which the `chat.agent` runtime
+ * writes through the agent's `TranscriptStorage`. Chats last written by an agent build
+ * that persisted through its own hooks have it on `chat_sessions.last_event_id`
+ * instead, so that row is the fallback. Null when neither has been written yet.
+ */
 export async function getSession(
   db: DashboardAgentDb,
   params: { chatId: string; userId: string; organizationId: string }
-): Promise<ChatSession | null> {
+): Promise<ChatResumeSession | null> {
   const rows = await db
     .select({
-      chatId: chatSessions.chatId,
+      chatId: chats.id,
+      cursors: chats.transcriptCursors,
+      chatUpdatedAt: chats.updatedAt,
       publicAccessToken: chatSessions.publicAccessToken,
-      lastEventId: chatSessions.lastEventId,
+      sessionLastEventId: chatSessions.lastEventId,
       runId: chatSessions.runId,
-      updatedAt: chatSessions.updatedAt,
+      sessionUpdatedAt: chatSessions.updatedAt,
     })
-    .from(chatSessions)
-    .innerJoin(chats, eq(chats.id, chatSessions.chatId))
+    .from(chats)
+    .leftJoin(chatSessions, eq(chatSessions.chatId, chats.id))
     .where(
       and(
-        eq(chatSessions.chatId, params.chatId),
+        eq(chats.id, params.chatId),
         eq(chats.userId, params.userId),
-        eq(chats.organizationId, params.organizationId)
+        eq(chats.organizationId, params.organizationId),
+        isNull(chats.deletedAt)
       )
     )
     .limit(1);
-  return rows[0] ?? null;
+  const row = rows[0];
+  if (!row) return null;
+  if (!row.cursors && row.publicAccessToken === null) return null;
+  return {
+    chatId: row.chatId,
+    publicAccessToken: row.publicAccessToken,
+    lastEventId: row.cursors?.lastOutEventId ?? row.sessionLastEventId ?? null,
+    runId: row.runId,
+    updatedAt: row.sessionUpdatedAt ?? row.chatUpdatedAt,
+  };
 }
 
 /** Owner check for chat-scoped actions, before a session row necessarily exists. */
@@ -645,6 +680,57 @@ export type PendingInvestigationSettlement = {
 
 export type PersistTurnResult = { settled: SettledInvestigation[] };
 
+export type SettleTurnInvestigationsResult = {
+  settled: SettledInvestigation[];
+  /** The closing cards, one per settled row, in the order they were written. */
+  cards: InvestigationCardMessage[];
+};
+
+/**
+ * Close the investigations a turn left running: each terminal revision and its closing
+ * card, in one transaction. The card is an id-deduped append, so a retried turn writes
+ * the same transcript rather than a second card.
+ *
+ * The transcript itself is the `chat.agent` runtime's to write, through the agent's
+ * `TranscriptStorage`. Only the settlement lives here, and it has to commit with its
+ * card: 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 settleTurnInvestigations(
+  db: DashboardAgentDb,
+  params: { chatId: string; settlements: PendingInvestigationSettlement[] }
+): Promise<SettleTurnInvestigationsResult> {
+  if (params.settlements.length === 0) return { settled: [], cards: [] };
+  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`);
+      }
+      await appendChatMessageOnceByChatId(tx, { chatId: params.chatId, message });
+      settled.push({ id: result.id, revision: result.revision, state: pending.state });
+      cards.push(message);
+    }
+    return { settled, cards };
+  });
+}
+
 /**
  * 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.