@sentry/junior-dashboard 0.279.0 → 0.281.0

package/src/client/conversations/TranscriptActivityGroup.tsx

@@ -1,4 +1,4 @@
-import { Fragment, useState, type ReactNode } from "react";
+import { Fragment, type ReactNode } from "react";
 import { ChevronRight } from "lucide-react";
 
 import { ShimmerText } from "../components/ShimmerText";
@@ -15,6 +15,7 @@ import type { RenderedTranscriptEntry } from "./transcriptRenderModel";
 import { cn } from "../styles";
 import { useTranscriptSearch } from "./transcriptSearch";
 import { TranscriptActivityNesting } from "./TranscriptRailEvent";
+import { useTranscriptRowOpen } from "./TranscriptRows";
 import { TranscriptSummaryTrigger } from "./TranscriptSummary";
 
 function countLabel(count: number, singular: string, plural: string): string {
@@ -175,18 +176,16 @@ function hasLiveActivity(entries: RenderedTranscriptEntry[]): boolean {
   );
 }
 
-/** Keep activity collapsed until the reader explicitly opens it. */
-export function activityGroupOpen(userOpen: boolean | null): boolean {
-  return userOpen ?? false;
-}
-
 /** Collapse completed non-message activity so chat messages stay primary. */
 export function TranscriptActivityGroup(props: {
   entries: RenderedTranscriptEntry[];
+  /** Keeps the group open while it unmounts outside the viewport. */
+  openKey?: string;
   renderEntry: (entry: RenderedTranscriptEntry) => ReactNode;
 }) {
   const { active: searchActive } = useTranscriptSearch();
-  const [userOpen, setUserOpen] = useState<boolean | null>(null);
+  // Activity stays collapsed until the reader opens it.
+  const [open, setOpen] = useTranscriptRowOpen(props.openKey);
   const rows = props.entries.map((entry) => (
     <Fragment key={entry.key}>{props.renderEntry(entry)}</Fragment>
   ));
@@ -202,14 +201,8 @@ export function TranscriptActivityGroup(props: {
     );
   }
 
-  const open = activityGroupOpen(userOpen);
-
   return (
-    <Collapsible
-      className="min-w-0 py-0.5"
-      onOpenChange={setUserOpen}
-      open={open}
-    >
+    <Collapsible className="min-w-0 py-0.5" onOpenChange={setOpen} open={open}>
       <TranscriptSummaryTrigger
         flush
         className={cn(

package/src/client/conversations/TranscriptEventView.tsx

@@ -1,5 +1,4 @@
 import { ChevronRight } from "lucide-react";
-import { useState } from "react";
 
 import { Collapsible, CollapsibleContent } from "../components/ui/collapsible";
 import { cn, dashboardDisclosureChevronClass } from "../styles";
@@ -9,6 +8,7 @@ import { messageRawText } from "./transcriptRenderModel";
 import { HighlightText, useTranscriptSearch } from "./transcriptSearch";
 import { RedactedMarker } from "./TranscriptRedacted";
 import type { TranscriptViewMessage } from "../types";
+import { useTranscriptRowOpen } from "./TranscriptRows";
 import { TranscriptSummaryTrigger } from "./TranscriptSummary";
 
 function EventTypeChip(props: { eventType: string }) {
@@ -28,9 +28,13 @@ function batchSummary(events: readonly { label?: string }[]): string {
 }
 
 /** Render an Event Message whose heading expands its full text. */
-export function TranscriptEventView(props: { message: TranscriptViewMessage }) {
+export function TranscriptEventView(props: {
+  message: TranscriptViewMessage;
+  /** Keeps the text open while the row unmounts outside the viewport. */
+  openKey?: string;
+}) {
   const { active: searchActive } = useTranscriptSearch();
-  const [open, setOpen] = useState(false);
+  const [open, setOpen] = useTranscriptRowOpen(props.openKey);
   const text = messageRawText(props.message);
   const redacted = props.message.parts.some(
     (part) => part.type === "text" && part.redacted,

package/src/client/conversations/TranscriptReasoningView.tsx

@@ -1,4 +1,3 @@
-import { useState } from "react";
 import { Lightbulb } from "lucide-react";
 
 import {
@@ -13,15 +12,18 @@ import {
   TranscriptHeadingMeta,
   TranscriptHeadingRow,
 } from "./TranscriptHeadingRow";
+import { useTranscriptRowOpen } from "./TranscriptRows";
 import { useTranscriptSearch } from "./transcriptSearch";
 
 /** Render reasoning collapsed with a short preview until expanded or searched. */
 export function TranscriptReasoningView(props: {
+  /** Keeps the entry open while it unmounts outside the viewport. */
+  openKey?: string;
   part: TranscriptViewReasoningPart;
   timestamp?: number;
 }) {
   const { active: searchActive } = useTranscriptSearch();
-  const [open, setOpen] = useState(false);
+  const [open, setOpen] = useTranscriptRowOpen(props.openKey);
   const expanded = searchActive || open;
   const rendered = props.part.redacted ? "Reasoning redacted" : props.part.text;
   const timestamp = formatMessageTimestamp(props.timestamp);

package/src/client/conversations/TranscriptRows.tsx

@@ -1,6 +1,16 @@
-import type { ComponentPropsWithoutRef, ReactNode } from "react";
+import {
+  createContext,
+  useContext,
+  useState,
+  type ComponentPropsWithoutRef,
+  type ReactNode,
+} from "react";
 
 import { cn } from "../styles";
+import {
+  ConversationCatchUpButton,
+  ConversationCatchUpCard,
+} from "./ConversationCatchUp";
 
 /** Keep row padding and the gap between transcript entries in one place. */
 export function TranscriptRows({
@@ -20,28 +30,63 @@ export function TranscriptRows({
  */
 export function TranscriptUnreadMarker() {
   return (
-    <div
-      className="flex items-center gap-3 py-1"
-      data-transcript-unread-marker=""
-      role="separator"
-      aria-label="New messages"
-    >
-      <span className="h-px flex-1 bg-dashboard-accent/50" />
-      <span className="shrink-0 font-sans text-xs font-semibold text-dashboard-accent-text">
-        New
-      </span>
-      <span className="h-px flex-1 bg-dashboard-accent/50" />
+    <div className="grid gap-2 py-1" data-transcript-unread-marker="">
+      {/* Equal side columns keep "New" centered when the catch-up offer shows. */}
+      <div className="grid grid-cols-[1fr_auto_1fr] items-center gap-3">
+        <span
+          aria-label="New messages"
+          className="h-px bg-dashboard-accent/50"
+          role="separator"
+        />
+        <span
+          aria-hidden="true"
+          className="font-sans text-xs font-semibold text-dashboard-accent-text"
+        >
+          New
+        </span>
+        <div className="flex min-w-0 items-center gap-3">
+          <span className="h-px flex-1 bg-dashboard-accent/50" />
+          <ConversationCatchUpButton />
+        </div>
+      </div>
+      <ConversationCatchUpCard />
     </div>
   );
 }
 
+/**
+ * Open rows by key, for the rows of one transcript list. Rows far from the
+ * viewport unmount, so a row that opens again reads its state here.
+ */
+export const TranscriptOpenRows = createContext<Map<string, boolean> | null>(
+  null,
+);
+
+/**
+ * Hold whether a transcript row part is open. With a key, the state stays
+ * while the row unmounts outside the viewport.
+ */
+export function useTranscriptRowOpen(
+  key: string | undefined,
+): [boolean, (open: boolean) => void] {
+  const openRows = useContext(TranscriptOpenRows);
+  const [open, setOpenState] = useState(
+    () => (key !== undefined && openRows?.get(key)) || false,
+  );
+  const setOpen = (value: boolean) => {
+    setOpenState(value);
+    if (key !== undefined) openRows?.set(key, value);
+  };
+  return [open, setOpen];
+}
+
 /**
  * Lay out one transcript row at its real size.
  *
- * Rows do not use `content-visibility: auto`. A skipped row has an estimated
- * size, and it changes size when the reader scrolls near it. Above the
- * reader, each change needs a scroll correction while they scroll, and on
- * phones those corrections make the transcript jump.
+ * Rows do not use `content-visibility: auto`. The list mounts only the rows
+ * near the viewport, and a row that mounts above the reader can measure a
+ * different size than its estimate. The scroll owner corrects the scroll
+ * position for that, so keep estimates close and overscan large.
  */
 export function TranscriptRow(props: {
   /** Stable row id that holds the reader's place while layout changes. */

package/src/client/conversations/TranscriptView.tsx

@@ -12,6 +12,7 @@ import { cn } from "../styles";
 import { ConversationTranscriptView } from "./ConversationTranscript";
 import { ConversationEventLog } from "./ConversationEventLog";
 import {
+  TranscriptJumpToLatestContext,
   transcriptBottomVersion,
   transcriptJuniorMessageVersion,
   useAutoLoadHistoryPage,
@@ -23,7 +24,7 @@ import {
   type TranscriptUnreadRange,
 } from "./transcriptReadPosition";
 import { TranscriptSearchProvider } from "./transcriptSearch";
-import type { TranscriptHistory } from "./transcriptUnreadHistory";
+import type { TranscriptHistory } from "./transcriptAroundHistory";
 import {
   TurnContextPanelProvider,
   type TurnContextPanel,
@@ -51,6 +52,8 @@ export function Transcript(props: {
   /** The reader's own sends to show at the end until history has them. */
   pendingMessages?: readonly ConversationMailboxMessage[];
   responding?: boolean;
+  /** Keep the rows around this event seq mounted, so the page can show it. */
+  revealSeq?: number;
   search?: string;
   onSearchChange?(value: string): void;
   selectedEventSeq?: number;
@@ -61,6 +64,8 @@ export function Transcript(props: {
   transcript?: ConversationTranscript;
   /** Show turn context in the owner's panel. Without it, a drawer opens. */
   turnContextPanel?: TurnContextPanel;
+  /** Open where a link shows its row instead of the latest message. */
+  startAtLink?: boolean;
   /** Open at the "New" marker instead of the latest message. */
   startAtUnread?: boolean;
   /** Rows that were unread when the Conversation opened get a marker. */
@@ -79,6 +84,7 @@ export function Transcript(props: {
     historyVersion: props.historyVersion ?? "empty",
     juniorMessageVersion: transcriptJuniorMessageVersion(props.transcript),
     pinRequestVersion: props.pinRequestVersion,
+    startAtLink: props.startAtLink,
     startAtUnread: view === "rich" && props.startAtUnread,
     view,
     versions: {
@@ -114,6 +120,11 @@ export function Transcript(props: {
     historyVersion: props.historyVersion ?? "empty",
     onLoad: () => newer?.load(),
   });
+  const jumpToLatest = () => {
+    // The latest page is in the detail, so the jump needs no request.
+    newer?.showLatest();
+    bottomPinning.jumpToBottom();
+  };
 
   if (!props.transcript) {
     return (
@@ -162,17 +173,22 @@ export function Transcript(props: {
             conversation={props.transcript}
             onSearchChange={props.onSearchChange ?? setLocalSearch}
             onSelectedSeqChange={props.onSelectedEventSeqChange}
+            scrollAnchorKey={bottomPinning.scrollAnchorKey}
             selectedSeq={props.selectedEventSeq}
           />
         ) : (
           <TurnContextPanelProvider panel={props.turnContextPanel}>
-            <ConversationTranscriptView
-              onOpenSubagentTranscript={props.onOpenSubagentTranscript}
-              conversation={props.transcript}
-              pendingMessages={props.pendingMessages}
-              responding={props.responding ?? props.live ?? false}
-              unread={props.unread}
-            />
+            <TranscriptJumpToLatestContext value={jumpToLatest}>
+              <ConversationTranscriptView
+                onOpenSubagentTranscript={props.onOpenSubagentTranscript}
+                conversation={props.transcript}
+                pendingMessages={props.pendingMessages}
+                responding={props.responding ?? props.live ?? false}
+                revealSeq={props.revealSeq}
+                scrollAnchorKey={bottomPinning.scrollAnchorKey}
+                unread={props.unread}
+              />
+            </TranscriptJumpToLatestContext>
           </TurnContextPanelProvider>
         )}
         {newer ? (
@@ -206,11 +222,7 @@ export function Transcript(props: {
         />
         <JumpToLatestButton
           hasPendingUpdate={bottomPinning.hasPendingUpdate}
-          onClick={() => {
-            // The latest page is in the detail, so the jump needs no request.
-            newer?.showLatest();
-            bottomPinning.jumpToBottom();
-          }}
+          onClick={jumpToLatest}
           visible={bottomPinning.showJumpToLatest}
         />
       </div>

package/src/client/conversations/conversationArchive.ts

@@ -11,6 +11,7 @@ import type {
 import { archiveConversationResponseSchema } from "@sentry/junior/api/schema";
 
 import { patch } from "../http";
+import type { Conversation } from "../types";
 import {
   conversationDetailQueryKey,
   type ConversationSnapshot,
@@ -82,6 +83,27 @@ export function usePendingArchiveConversationUpdates() {
   });
 }
 
+/**
+ * Router state for home after a conversation archives itself. Home reports
+ * the background archive result, because the conversation page is gone.
+ */
+export type ArchivedFromConversationState = {
+  archivedConversation: Conversation;
+};
+
+/** Read the newest archive or restore status for one conversation. */
+export function useLatestArchiveStatus(conversationId: string | undefined) {
+  const statuses = useMutationState({
+    filters: {
+      exact: true,
+      mutationKey: [...archiveConversationMutationKey, conversationId],
+    },
+    select: (mutation) => mutation.state.status,
+  });
+  // The mutation cache keeps insertion order, so the last entry is newest.
+  return conversationId ? statuses.at(-1) : undefined;
+}
+
 /** Archive or restore one conversation with an immediate reversible cache update. */
 export function useArchiveConversation(
   conversationId: string,

package/src/client/conversations/conversationCatchUpState.ts

@@ -0,0 +1,96 @@
+/**
+ * Offer a catch-up when a reader comes back to a lot of unread activity. The
+ * reader asks for it, because each summary costs a model call and a short
+ * wait.
+ */
+import { useMutation } from "@tanstack/react-query";
+import { createContext, useContext } from "react";
+
+import {
+  conversationCatchUpSchema,
+  type ConversationCatchUp,
+  type ConversationDetailReport,
+} from "@sentry/junior/api/schema";
+import { post } from "../http";
+import type { TranscriptUnreadRange } from "./transcriptReadPosition";
+
+/** Fewer unread Turns than this are quicker to read than a summary. */
+const CATCH_UP_MIN_TURNS = 2;
+
+/** The catch-up offer for the unread range of one Conversation visit. */
+export type ConversationCatchUpState = {
+  data?: ConversationCatchUp;
+  error: boolean;
+  pending: boolean;
+  request(): void;
+};
+
+/**
+ * Count the Turns that finished in the unread range. When the range goes past
+ * the loaded rows, the reader has at least a page of unread rows.
+ */
+function hasEnoughUnread(
+  events: ConversationDetailReport["events"],
+  unread: TranscriptUnreadRange,
+  pages: { hasNewerPage: boolean; hasPreviousPage: boolean },
+): boolean {
+  if (pages.hasNewerPage) return true;
+  const first = events[0];
+  if (pages.hasPreviousPage && first && first.seq > unread.afterSeq) {
+    return true;
+  }
+  let turns = 0;
+  for (const event of events) {
+    if (event.seq <= unread.afterSeq || event.seq > unread.throughSeq) continue;
+    if (
+      event.data.type === "turn_lifecycle" &&
+      event.data.state !== "started"
+    ) {
+      turns += 1;
+    }
+  }
+  return turns >= CATCH_UP_MIN_TURNS;
+}
+
+/** Offer a catch-up only when enough is unread. */
+export function useConversationCatchUp(input: {
+  conversationId: string;
+  events?: ConversationDetailReport["events"];
+  hasNewerPage: boolean;
+  hasPreviousPage: boolean;
+  unread?: TranscriptUnreadRange;
+}): ConversationCatchUpState | undefined {
+  const { unread } = input;
+  const mutation = useMutation({
+    mutationFn: (range: TranscriptUnreadRange) =>
+      post(
+        conversationCatchUpSchema,
+        `/api/conversations/${encodeURIComponent(input.conversationId)}/catch-up`,
+        range,
+      ),
+  });
+  // Once asked, keep the answer even if the loaded rows change.
+  const asked = !mutation.isIdle;
+  if (
+    !unread ||
+    (!asked && (!input.events || !hasEnoughUnread(input.events, unread, input)))
+  ) {
+    return undefined;
+  }
+  return {
+    data: mutation.data,
+    error: mutation.isError,
+    pending: mutation.isPending,
+    request: () => mutation.mutate(unread),
+  };
+}
+
+/** Only the Conversation page sets it, so nested transcripts offer nothing. */
+export const ConversationCatchUpContext = createContext<
+  ConversationCatchUpState | undefined
+>(undefined);
+
+/** Read the catch-up offer of the current Conversation page. */
+export function useConversationCatchUpState() {
+  return useContext(ConversationCatchUpContext);
+}

package/src/client/conversations/conversationMemory.ts

@@ -1,6 +1,6 @@
 import { useQuery } from "@tanstack/react-query";
 import { createContext, useContext } from "react";
-import { z } from "zod";
+import * as z from "zod";
 
 import { fetchDashboardJson } from "../http";
 import { conversationSideReadQueryKey } from "./queries";
@@ -11,6 +11,7 @@ const conversationMemoryListSchema = z
       z
         .object({
           memoryIds: z.array(z.string().min(1)).min(1),
+          seq: z.number().int().min(0),
           source: z.enum(["captured", "recalled"]),
           turnId: z.string().min(1).optional(),
         })
@@ -76,6 +77,8 @@ export function anchorMemories(
 /** One row of the Conversation memory list. */
 export type ConversationMemoryEntry = {
   memory: ConversationMemory;
+  /** The recall or capture event, where the transcript opens. */
+  seq: number;
   source: MemorySource;
   turnId?: string;
 };
@@ -99,6 +102,7 @@ export function conversationMemoryEntries(
       seen.add(key);
       entries.push({
         memory,
+        seq: event.seq,
         source: event.source,
         ...(event.turnId ? { turnId: event.turnId } : undefined),
       });
@@ -110,6 +114,9 @@ export function conversationMemoryEntries(
 /** The open memory popover, and the memory it highlights. */
 export type OpenMemoryPopover = MemoryAnchor & { memoryId?: string };
 
+/** A memory chosen in details, and the event where the transcript opens. */
+export type MemoryJump = OpenMemoryPopover & { seq: number };
+
 /** Shared memory popover state for one Conversation page. */
 export type ConversationMemoryState = {
   list?: ConversationMemoryList;

package/src/client/conversations/queries.ts

@@ -1,4 +1,5 @@
 import { useDeferredValue, useEffect, useMemo, useRef, useState } from "react";
+import * as z from "zod";
 import {
   type QueryClient,
   queryOptions,
@@ -22,13 +23,14 @@ import {
   conversationDetailReportSchema,
   conversationDetailWithMailboxReportSchema,
   conversationEventPageSchema,
-  conversationPendingMessagesReportSchema,
+  conversationUnchangedDetailWithMailboxSchema,
   forkConversationResponseSchema,
   steerConversationPendingMessagesResponseSchema,
   stopConversationTurnResponseSchema,
 } from "@sentry/junior/api/schema";
 
 import { REVIEW_ITEMS_QUERY_KEY } from "../review-desk/queries";
+import { readResponseJson } from "../sentry";
 import {
   DashboardApiError,
   del,
@@ -102,29 +104,6 @@ function isOpenPrefetch(snapshot: ConversationSnapshot | undefined) {
   );
 }
 
-/** Read the mailbox before history so acknowledged input is already committed. */
-async function readConversationSnapshot(
-  conversationId: string,
-  signal?: AbortSignal,
-  previous?: ConversationSnapshot,
-  unreadPage?: boolean,
-): Promise<ConversationSnapshot> {
-  // With no cached copy, the transcript waits for this read. The server reads
-  // both in the same order in one request, which saves a round trip. Polls
-  // read the mailbox apart, so the detail can still answer 304.
-  if (!previous) {
-    return readConversationData(conversationId, signal, undefined, {
-      mailbox: true,
-      unreadPage,
-    });
-  }
-  const mailbox = await readConversationPendingMessages(conversationId, signal);
-  const detail = await readConversationData(conversationId, signal, previous, {
-    unreadPage,
-  });
-  return { ...detail, mailbox };
-}
-
 const CONVERSATION_SIDE_READS = ["agents", "memories", "watches"] as const;
 
 /**
@@ -185,11 +164,13 @@ export function conversationDetailQueryOptions(
       const previous = client.getQueryData<ConversationSnapshot>(
         conversationDetailQueryKey(conversationId),
       );
-      const next = await readConversationSnapshot(
+      // The server reads the mailbox before history, so acknowledged input
+      // is in at least one of them.
+      const next = await readConversationData(
         conversationId!,
         signal,
         previous,
-        options?.unreadPage,
+        { mailbox: true, unreadPage: options?.unreadPage },
       );
       refreshSideReadsOnChange(client, conversationId!, previous, next);
       return next;
@@ -221,7 +202,9 @@ export function conversationDetailQueryOptions(
 /**
  * Read positions only move forward. A poll that started before a read report
  * finished must not put an older position back in the cache, nor the unread
- * cursor of that older position.
+ * cursor of that older position. The cache already holds the cursor for the
+ * newer position: a read does not change the detail version, so no later poll
+ * would bring it back.
  */
 function keepLatestReadPosition(
   previous: ConversationSnapshot,
@@ -230,8 +213,14 @@ function keepLatestReadPosition(
   const kept = previous.readPosition;
   if (!kept) return next;
   if ((next.readPosition?.lastReadSeq ?? -1) >= kept.lastReadSeq) return next;
-  const { unreadCursor: _olderCursor, ...rest } = next;
-  return { ...rest, readPosition: kept };
+  const { unreadCursor: _olderCursor, unreadPage: _olderPage, ...rest } = next;
+  return {
+    ...rest,
+    readPosition: kept,
+    ...(previous.unreadCursor
+      ? { unreadCursor: previous.unreadCursor, unreadPage: previous.unreadPage }
+      : undefined),
+  };
 }
 
 /** Create one dashboard conversation and refresh the personal feed. */
@@ -858,6 +847,10 @@ export async function readConversationData(
   const query = new URLSearchParams();
   if (options?.unreadPage) query.set("unreadPage", "true");
   if (options?.mailbox) query.set("mailbox", "true");
+  // A poll asks only for the events after the cached ones. The unread page
+  // needs the latest page, so a read that asks for it reads that page.
+  const after = options?.unreadPage ? undefined : previous?.appendCursor;
+  if (after) query.set("after", after);
   const search = query.size ? `?${query}` : "";
   const response = await readDashboardResponse(
     `/api/conversations/${encodeURIComponent(conversationId)}${search}`,
@@ -867,11 +860,69 @@ export async function readConversationData(
       : undefined,
   );
   if (response.status === 304 && previous) return previous;
-  const report = (
-    options?.mailbox
-      ? conversationDetailWithMailboxReportSchema
-      : conversationDetailReportSchema
-  ).parse(await response.json());
+  if (!options?.mailbox) {
+    return withDetailEtag(
+      withCachedEvents(
+        await readResponseJson(response, conversationDetailReportSchema),
+        previous,
+      ),
+      response,
+    );
+  }
+  const report = await readResponseJson(
+    response,
+    z.union([
+      conversationUnchangedDetailWithMailboxSchema,
+      conversationDetailWithMailboxReportSchema,
+    ]),
+  );
+  if (!("unchanged" in report)) {
+    return withDetailEtag(withCachedEvents(report, previous), response);
+  }
+  // Only a request that sent a version can get this answer.
+  if (!previous) throw new Error("Unchanged detail without a cached copy");
+  return { ...previous, mailbox: report.mailbox };
+}
+
+/**
+ * Put the cached events before the newer events of an `appended` report.
+ * The cached detail keeps its cursors: they still point before its events.
+ */
+function withCachedEvents(
+  report: ConversationSnapshot,
+  previous: ConversationSnapshot | undefined,
+): ConversationSnapshot {
+  if (!report.appended) return report;
+  // Only a request that sent an `appendCursor` can get this answer.
+  if (!previous) throw new Error("Appended detail without a cached copy");
+  const { appended: _appended, ...rest } = report;
+  const lastSeq = previous.events.at(-1)?.seq ?? -1;
+  const firstSeq = previous.events[0]?.seq;
+  // Like the server, keep the unread cursor while the reader is behind the
+  // first event.
+  const behind =
+    rest.readPosition !== undefined &&
+    firstSeq !== undefined &&
+    rest.readPosition.lastReadSeq + 1 < firstSeq;
+  return {
+    ...rest,
+    events: [
+      ...previous.events,
+      ...report.events.filter((event) => event.seq > lastSeq),
+    ],
+    ...(previous.previousCursor
+      ? { previousCursor: previous.previousCursor }
+      : undefined),
+    ...(behind && previous.unreadCursor
+      ? { unreadCursor: previous.unreadCursor, unreadPage: previous.unreadPage }
+      : undefined),
+  };
+}
+
+function withDetailEtag<T extends ConversationDetailReport>(
+  report: T,
+  response: Response,
+): T & { detailEtag?: string } {
   return {
     ...report,
     detailEtag:
@@ -879,18 +930,6 @@ export async function readConversationData(
   };
 }
 
-/** Read accepted mailbox messages that have not reached durable history yet. */
-export function readConversationPendingMessages(
-  conversationId: string,
-  signal?: AbortSignal,
-): Promise<ConversationPendingMessagesReport> {
-  return fetchDashboardJson(
-    conversationPendingMessagesReportSchema,
-    `/api/conversations/${encodeURIComponent(conversationId)}/pending-messages`,
-    signal,
-  );
-}
-
 /** Read one bounded page of events before the supplied history cursor. */
 export function readConversationEvents(
   conversationId: string,