@sentry/junior-dashboard 0.277.0 → 0.278.0

package/src/client/conversations/eventTranscript.ts

@@ -51,9 +51,6 @@ function specialToolIds(events: ConversationReportEvent[]): Set<string> {
   const ids = new Set<string>();
   for (const event of events) {
     const data = event.data;
-    if (data.type === "handoff" && data.triggeringToolCallId) {
-      ids.add(data.triggeringToolCallId);
-    }
     if (data.type === "subagent" && data.parentToolCallId) {
       ids.add(data.parentToolCallId);
     }
@@ -243,6 +240,7 @@ export function transcriptMessagesFromEvents(
         ...(data.explicitMention !== undefined
           ? { explicitMention: data.explicitMention }
           : undefined),
+        ...(data.quiet ? { quiet: data.quiet } : undefined),
         ...(data.reviewItemChanges
           ? { reviewItemChanges: data.reviewItemChanges }
           : undefined),
@@ -308,22 +306,6 @@ export function transcriptMessagesFromEvents(
       continue;
     }
 
-    if (data.type === "turn_routed") {
-      const message = latestUserMessageByTurn.get(data.turnId);
-      if (message) {
-        message.route = {
-          modelProfile: data.modelProfile,
-          modelId: data.modelId,
-          reasoningLevel: data.reasoningLevel,
-          ...(data.confidence !== undefined
-            ? { confidence: data.confidence }
-            : undefined),
-          source: data.source,
-        };
-      }
-      continue;
-    }
-
     if (data.type === "turn_context") {
       const message = latestUserMessageByTurn.get(data.turnId);
       if (message) {
@@ -437,34 +419,19 @@ export function transcriptMessagesFromEvents(
       continue;
     }
 
-    if (data.type === "compaction" || data.type === "handoff") {
+    if (data.type === "compaction") {
       messages.push(
         eventMessage(event, "system", [
           {
             type: "context_event",
             ...(event.mentions ? { mentions: event.mentions } : undefined),
-            event:
-              data.type === "handoff"
-                ? {
-                    type: data.type,
-                    createdAt: event.createdAt,
-                    modelId: data.modelId,
-                    modelProfile: data.modelProfile,
-                    ...(data.summary ? { summary: data.summary } : undefined),
-                    ...(data.reasoningLevel
-                      ? { reasoningLevel: data.reasoningLevel }
-                      : undefined),
-                  }
-                : {
-                    type: data.type,
-                    createdAt: event.createdAt,
-                    ...(data.modelId ? { modelId: data.modelId } : undefined),
-                    ...(data.modelProfile
-                      ? { modelProfile: data.modelProfile }
-                      : undefined),
-                    ...(data.summary ? { summary: data.summary } : undefined),
-                    ...(data.details ? { details: data.details } : undefined),
-                  },
+            event: {
+              type: data.type,
+              createdAt: event.createdAt,
+              ...(data.modelId ? { modelId: data.modelId } : undefined),
+              ...(data.summary ? { summary: data.summary } : undefined),
+              ...(data.details ? { details: data.details } : undefined),
+            },
           },
         ]),
       );

package/src/client/conversations/queries.ts

@@ -1,4 +1,4 @@
-import { useDeferredValue, useEffect, useMemo, useRef } from "react";
+import { useDeferredValue, useEffect, useMemo, useRef, useState } from "react";
 import {
   type QueryClient,
   queryOptions,
@@ -16,6 +16,7 @@ import type {
 } from "@sentry/junior/api/schema";
 import {
   acceptedConversationMessageSchema,
+  CONVERSATION_DETAIL_VERSION_HEADER,
   webMessageId,
   cancelConversationPendingMessagesResponseSchema,
   conversationDetailReportSchema,
@@ -80,9 +81,15 @@ async function readConversationSnapshot(
   conversationId: string,
   signal?: AbortSignal,
   previous?: ConversationSnapshot,
+  unreadPage?: boolean,
 ): Promise<ConversationSnapshot> {
   const mailbox = await readConversationPendingMessages(conversationId, signal);
-  const detail = await readConversationData(conversationId, signal, previous);
+  const detail = await readConversationData(
+    conversationId,
+    signal,
+    previous,
+    unreadPage,
+  );
   return { ...detail, mailbox };
 }
 
@@ -119,8 +126,13 @@ export function conversationDetailQueryOptions(
     awaitingMessage?: boolean;
     /** Poll fast until this time so a new send reaches history quickly. */
     fastPollUntilMs?: number;
+    /** Also read the page around the read position. */
+    unreadPage?: boolean;
   },
 ) {
+  // `unreadPage` adds a page to one fetch. The detail in the cache is the
+  // same, so it stays out of the key.
+  // oxlint-disable-next-line @tanstack/query/exhaustive-deps
   return queryOptions({
     enabled: Boolean(conversationId),
     queryKey: conversationDetailQueryKey(conversationId),
@@ -132,6 +144,7 @@ export function conversationDetailQueryOptions(
         conversationId!,
         signal,
         previous,
+        options?.unreadPage,
       );
       // Side reads do not poll. A new ETag means the Conversation changed,
       // so the details panel may be stale too.
@@ -170,7 +183,8 @@ 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.
+ * finished must not put an older position back in the cache, nor the unread
+ * cursor of that older position.
  */
 function keepLatestReadPosition(
   previous: ConversationSnapshot,
@@ -179,7 +193,8 @@ function keepLatestReadPosition(
   const kept = previous.readPosition;
   if (!kept) return next;
   if ((next.readPosition?.lastReadSeq ?? -1) >= kept.lastReadSeq) return next;
-  return { ...next, readPosition: kept };
+  const { unreadCursor: _olderCursor, ...rest } = next;
+  return { ...rest, readPosition: kept };
 }
 
 /** Create one dashboard conversation and refresh the personal feed. */
@@ -481,9 +496,29 @@ export function useStopConversationTurn(conversationId: string) {
   });
 }
 
+/** The open Conversation's data, from `useConversationData`. */
+export type ConversationData = ReturnType<typeof useConversationData>;
+
 /** Fetch a bounded conversation snapshot and older pages on demand. */
-export function useConversationData(conversationId: string | undefined) {
+export function useConversationData(
+  conversationId: string | undefined,
+  options?: {
+    /**
+     * Ask the first fetch of this visit for the page around the read
+     * position. Polls do not ask, so the server reads that page once.
+     */
+    unreadPageAtOpen?: boolean;
+  },
+) {
   const queryClient = useQueryClient();
+  // The shell keeps one hook across Conversations, so a new Conversation
+  // starts a new visit.
+  const [visit, setVisit] = useState({ conversationId, fetched: false });
+  if (visit.conversationId !== conversationId) {
+    setVisit({ conversationId, fetched: false });
+  }
+  const fetchedAtOpen =
+    visit.conversationId === conversationId && visit.fetched;
   const outbox = useQuery({
     enabled: Boolean(conversationId),
     // Local-only cache. Never replace optimistic rows with an empty fetch result.
@@ -521,11 +556,20 @@ export function useConversationData(conversationId: string | undefined) {
       fastPollUntilMs: latestSendAtMs
         ? latestSendAtMs + FAST_POLL_WINDOW_MS
         : undefined,
+      unreadPage: Boolean(options?.unreadPageAtOpen) && !fetchedAtOpen,
     }),
-    // A reopened Conversation shows the cached copy at once, but it can miss
-    // messages that arrived while the reader was away. Fetch it each visit.
-    refetchOnMount: "always",
   });
+  // A reopened Conversation shows the cached copy at once, but it can miss
+  // messages that arrived while the reader was away. Fetch it once at the
+  // start of each visit, even when the cached copy is still fresh. A fetch
+  // that is already running counts.
+  const refetchDetail = detail.refetch;
+  useEffect(() => {
+    if (conversationId) void refetchDetail({ cancelRefetch: false });
+  }, [conversationId, refetchDetail]);
+  if (!fetchedAtOpen && detail.isFetchedAfterMount && !detail.isFetching) {
+    setVisit({ conversationId, fetched: true });
+  }
   // Defer the whole server snapshot, not history alone. Queue removal and the
   // matching transcript must paint together while composer input stays urgent.
   const deferredDetail = useDeferredValue(detail.data);
@@ -679,7 +723,6 @@ export function useConversationData(conversationId: string | undefined) {
   const isLoadingPreviousPage =
     history.isFetchingNextPage || historyNeedsReconciliation;
 
-  const refetchDetail = detail.refetch;
   useEffect(() => {
     if (shouldRefreshDetail) void refetchDetail();
   }, [refetchDetail, shouldRefreshDetail]);
@@ -695,11 +738,18 @@ export function useConversationData(conversationId: string | undefined) {
 
   const fetchNextHistoryPage = history.fetchNextPage;
   useEffect(() => {
-    if (historyNeedsReconciliation) void fetchNextHistoryPage();
+    if (historyNeedsReconciliation) {
+      void fetchNextHistoryPage({ cancelRefetch: false });
+    }
   }, [fetchNextHistoryPage, historyNeedsReconciliation]);
 
   return {
     data,
+    /**
+     * The latest page alone, without earlier pages. It is not deferred, so it
+     * matches `fetchedDetail` and the read position that came with it.
+     */
+    latest: detail.data,
     error: detail.error,
     historyError,
     historyVersion: conversationHistoryVersion(historyPages ?? []),
@@ -707,6 +757,8 @@ export function useConversationData(conversationId: string | undefined) {
       ? history.hasNextPage
       : Boolean(detailData?.previousCursor),
     isPending: detail.isPending,
+    /** The first fetch of this visit has ended. */
+    fetchedAtOpen,
     /** The latest detail after a fetch in this visit, before it is deferred. */
     fetchedDetail:
       detail.isFetchedAfterMount && !detail.isFetching
@@ -732,8 +784,10 @@ export function useConversationData(conversationId: string | undefined) {
       const hasPreviousPage = history.data
         ? history.hasNextPage
         : Boolean(detailData?.previousCursor);
-      if (conversationId && hasPreviousPage && !history.isFetchingNextPage) {
-        void history.fetchNextPage();
+      if (conversationId && hasPreviousPage) {
+        // A second call joins the read in flight. By default it cancels
+        // that read and starts the same read again.
+        void history.fetchNextPage({ cancelRefetch: false });
       }
     },
   };
@@ -744,15 +798,22 @@ export async function readConversationData(
   conversationId: string,
   signal?: AbortSignal,
   previous?: ConversationSnapshot,
+  unreadPage?: boolean,
 ): Promise<ConversationSnapshot> {
   const response = await readDashboardResponse(
-    `/api/conversations/${encodeURIComponent(conversationId)}`,
+    `/api/conversations/${encodeURIComponent(conversationId)}${unreadPage ? "?unreadPage=true" : ""}`,
     signal,
-    previous?.detailEtag,
+    previous?.detailEtag
+      ? { [CONVERSATION_DETAIL_VERSION_HEADER]: previous.detailEtag }
+      : undefined,
   );
   if (response.status === 304 && previous) return previous;
   const report = conversationDetailReportSchema.parse(await response.json());
-  return { ...report, detailEtag: response.headers.get("etag") ?? undefined };
+  return {
+    ...report,
+    detailEtag:
+      response.headers.get(CONVERSATION_DETAIL_VERSION_HEADER) ?? undefined,
+  };
 }
 
 /** Read accepted mailbox messages that have not reached durable history yet. */

package/src/client/conversations/transcript.ts

@@ -13,22 +13,8 @@ export function buildConversationTranscript(
   detail: ConversationDetailReport,
   historyPages: ConversationHistoryPage[],
 ): ConversationDetailReport {
-  if (detail.eventHistory.status !== "available") {
-    return withoutModelUsage(detail);
-  }
-
-  const restrictedHistory = historyPages.find(
-    (page) => page.eventHistory.status !== "available",
-  );
-  if (restrictedHistory) {
-    return withoutModelUsage({
-      ...detail,
-      eventHistory: restrictedHistory.eventHistory,
-      events: restrictedHistory.events,
-      previousCursor: restrictedHistory.previousCursor,
-    });
-  }
-
+  const restricted = restrictedTranscript(detail, historyPages);
+  if (restricted) return restricted;
   if (historyPages.length === 0) return detail;
 
   return {
@@ -45,6 +31,30 @@ export function buildConversationTranscript(
   };
 }
 
+/**
+ * Build a transcript that opens at the read position.
+ *
+ * `pages` hold one unbroken range of events around the read position. The
+ * caller supplies `latestEvents` only when `pages` reach them, so the
+ * transcript never shows a gap between the two.
+ */
+export function buildUnreadConversationTranscript(
+  detail: ConversationDetailReport,
+  pages: ConversationEventPage[],
+  latestEvents: ConversationReportEvent[],
+): ConversationDetailReport {
+  const restricted = restrictedTranscript(detail, pages);
+  if (restricted) return restricted;
+  return {
+    ...detail,
+    events: orderedEvents([
+      ...pages.flatMap((page) => page.events),
+      ...latestEvents,
+    ]),
+    previousCursor: oldestPreviousCursor(pages),
+  };
+}
+
 /** Materialize one immutable detail snapshot through its exact history cursor chain. */
 export async function loadCompleteConversationTranscript(args: {
   detail: ConversationDetailReport;
@@ -198,6 +208,26 @@ function orderedEvents(
   );
 }
 
+/** Show only what restricted history allows, from detail or from a page. */
+function restrictedTranscript(
+  detail: ConversationDetailReport,
+  pages: ConversationEventPage[],
+): ConversationDetailReport | undefined {
+  if (detail.eventHistory.status !== "available") {
+    return withoutModelUsage(detail);
+  }
+  const restrictedPage = pages.find(
+    (page) => page.eventHistory.status !== "available",
+  );
+  if (!restrictedPage) return undefined;
+  return withoutModelUsage({
+    ...detail,
+    eventHistory: restrictedPage.eventHistory,
+    events: restrictedPage.events,
+    previousCursor: restrictedPage.previousCursor,
+  });
+}
+
 function withoutModelUsage(
   detail: ConversationDetailReport,
 ): ConversationDetailReport {

package/src/client/conversations/transcriptBottomPinning.ts

@@ -20,7 +20,7 @@ import {
 } from "./transcriptScrollAnchor";
 
 const BOTTOM_PROXIMITY_PX = 96;
-const PREVIOUS_PAGE_PROXIMITY_PX = 600;
+const HISTORY_PAGE_PROXIMITY_PX = 600;
 const USER_SCROLL_DELTA_PX = 2;
 // Leave a little earlier context above the "New" marker.
 const UNREAD_START_OFFSET_PX = 48;
@@ -133,8 +133,7 @@ function changesVisibleTranscript(event: ConversationReportEvent): boolean {
     data.type === "subagent" ||
     data.type === "structured_event" ||
     data.type === "attachments_delivered" ||
-    data.type === "compaction" ||
-    data.type === "handoff"
+    data.type === "compaction"
   );
 }
 
@@ -208,18 +207,6 @@ function eventTailVersion(event: ConversationReportEvent | undefined): string {
       ].join(":");
     case "compaction":
       return [data.type, data.summary?.length ?? 0, event.createdAt].join(":");
-    case "handoff":
-      return [
-        data.type,
-        data.modelProfile,
-        data.modelId,
-        data.summary?.length ?? 0,
-        event.createdAt,
-      ].join(":");
-    case "turn_routed":
-      return [data.type, data.turnId, data.modelProfile, data.modelId].join(
-        ":",
-      );
     case "guardian_action_reviewed":
       return [data.type, data.turnId, data.toolCallId, data.decision].join(":");
     case "turn_context":
@@ -262,18 +249,22 @@ export function terminalReplyPinState(input: {
 
 /**
  * Show the jump control only when the reader left the bottom and a newer tail
- * arrived, or when the transcript opened at unread rows. Staying pinned, or
- * intentionally following, must not flash it.
+ * arrived, when the transcript opened at unread rows, or when it does not end
+ * at the latest event. Staying pinned, or intentionally following, must not
+ * flash it.
  */
 export function shouldShowJumpToLatest(input: {
   enabled: boolean;
+  endsAtLatest?: boolean;
   following: boolean;
   hasPendingUpdate: boolean;
   openedAtUnread?: boolean;
 }): boolean {
   return (
     !input.following &&
-    (Boolean(input.openedAtUnread) || (input.enabled && input.hasPendingUpdate))
+    (input.endsAtLatest === false ||
+      Boolean(input.openedAtUnread) ||
+      (input.enabled && input.hasPendingUpdate))
   );
 }
 
@@ -319,6 +310,12 @@ export function programmaticSettleScrollAction(input: {
 export function usePinnedTranscriptBottom(input: {
   conversationId?: string;
   enabled: boolean;
+  /**
+   * False while newer pages are not loaded. The end of the transcript is
+   * then not the latest event, so the reader cannot follow it, and a page
+   * that loads below them does not pull them down.
+   */
+  endsAtLatest?: boolean;
   historyVersion: string;
   juniorMessageVersion: string;
   pinRequestVersion?: number;
@@ -330,6 +327,8 @@ export function usePinnedTranscriptBottom(input: {
   const anchorRef = useRef<HTMLDivElement | null>(null);
   const contentElementRef = useRef<HTMLDivElement | null>(null);
   const enabledRef = useRef(input.enabled);
+  const endsAtLatestRef = useRef(true);
+  endsAtLatestRef.current = input.endsAtLatest ?? true;
   const followingRef = useRef(false);
   const initializedRef = useRef(false);
   const initializedConversationRef = useRef<string | null>(null);
@@ -447,6 +446,7 @@ export function usePinnedTranscriptBottom(input: {
       }
 
       if (intent === "follow") {
+        if (!endsAtLatestRef.current) return;
         setFollowingIntent(true);
         setHasPendingUpdate(false);
         return;
@@ -537,7 +537,7 @@ export function usePinnedTranscriptBottom(input: {
     const snapshot = scrollSnapshot(root);
     previousScrollTopRef.current = snapshot.scrollTop;
     // Unread rows that fit above the bottom leave the reader at the latest.
-    const atBottom = isNearScrollBottom(snapshot);
+    const atBottom = endsAtLatestRef.current && isNearScrollBottom(snapshot);
     setFollowingIntent(atBottom);
     setOpenedAtUnread(!atBottom);
     rememberPlace();
@@ -574,8 +574,13 @@ export function usePinnedTranscriptBottom(input: {
   // reader moved. Then open at the marker, as if it was there at the start.
   const followLatest = useCallback(() => {
     if (awaitingUnreadMarkerRef.current && openAtUnreadMarker()) return;
+    if (!endsAtLatestRef.current) {
+      setFollowingIntent(false);
+      restorePlace();
+      return;
+    }
     scrollToBottom("auto");
-  }, [openAtUnreadMarker, scrollToBottom]);
+  }, [openAtUnreadMarker, restorePlace, scrollToBottom, setFollowingIntent]);
 
   const syncAfterLayoutChange = useCallback(() => {
     if (followingRef.current) {
@@ -749,6 +754,8 @@ export function usePinnedTranscriptBottom(input: {
     const version = input.pinRequestVersion ?? 0;
     if (version === pinRequestVersionRef.current) return;
     pinRequestVersionRef.current = version;
+    // The reader asked for the latest event, not the "New" marker.
+    awaitingUnreadMarkerRef.current = false;
     setFollowingIntent(true);
     setHasPendingUpdate(false);
     scrollToBottom("auto");
@@ -763,6 +770,7 @@ export function usePinnedTranscriptBottom(input: {
       jumpToBottom,
       showJumpToLatest: shouldShowJumpToLatest({
         enabled: input.enabled,
+        endsAtLatest: input.endsAtLatest,
         following,
         hasPendingUpdate,
         openedAtUnread,
@@ -774,14 +782,19 @@ export function usePinnedTranscriptBottom(input: {
       following,
       hasPendingUpdate,
       input.enabled,
+      input.endsAtLatest,
       jumpToBottom,
       openedAtUnread,
     ],
   );
 }
 
-/** Load the previous history page when the reader scrolls near the top. */
-export function useAutoLoadPreviousPage(input: {
+/**
+ * Load the next history page when the reader scrolls near the edge where it
+ * goes: the top for earlier pages, the bottom for newer pages.
+ */
+export function useAutoLoadHistoryPage(input: {
+  edge: "bottom" | "top";
   enabled: boolean;
   historyVersion: string;
   onLoad: () => void;
@@ -803,12 +816,15 @@ export function useAutoLoadPreviousPage(input: {
       },
       {
         root: root && !isWindowRoot(root) ? root : null,
-        rootMargin: `${PREVIOUS_PAGE_PROXIMITY_PX}px 0px 0px 0px`,
+        rootMargin:
+          input.edge === "top"
+            ? `${HISTORY_PAGE_PROXIMITY_PX}px 0px 0px 0px`
+            : `0px 0px ${HISTORY_PAGE_PROXIMITY_PX}px 0px`,
       },
     );
     observer.observe(sentinel);
     return () => observer.disconnect();
-  }, [input.enabled, input.historyVersion, sentinel]);
+  }, [input.edge, input.enabled, input.historyVersion, sentinel]);
 
   return setSentinel;
 }

package/src/client/conversations/transcriptReadPosition.ts

@@ -17,6 +17,7 @@ import { useCallback, useEffect, useRef, useState } from "react";
 import {
   conversationReadPositionSchema,
   type ConversationDetailReport,
+  type ConversationEventPage,
   type ConversationReadPosition,
 } from "@sentry/junior/api/schema";
 import { put } from "../http";
@@ -42,6 +43,10 @@ export type TranscriptUnreadRange = { afterSeq: number; throughSeq: number };
 export type ReadPositionAtOpen = {
   lastReadSeq?: number;
   unread?: TranscriptUnreadRange;
+  /** Set when unread events start before the latest page. */
+  unreadCursor?: string;
+  /** The page around `unreadCursor`, when the fetch brought it. */
+  unreadPage?: ConversationEventPage;
 };
 
 /** Edit the browser-only preference for where Conversations open. */
@@ -74,7 +79,9 @@ export function readConversationStartPosition(): ConversationStartPosition {
  * The read position comes from the first detail, which can be a cached copy.
  * The last unread row comes from the first detail fetched in this visit, so a
  * stale cache cannot hide messages that arrived while the reader was away,
- * and later polls cannot add rows that arrived after open.
+ * and later polls cannot add rows that arrived after open. `unreadCursor`
+ * and its page come from that fetch too: a cache from a visit that read to
+ * the end has no cursor, even when more than a page arrived after that visit.
  */
 export function useReadPositionAtOpen(
   detail: DetailAtOpen | undefined,
@@ -83,24 +90,41 @@ export function useReadPositionAtOpen(
 ): ReadPositionAtOpen {
   // Store derived state during render so the first transcript render has it.
   const [opened, setOpened] = useState<{ lastReadSeq?: number }>();
-  const [fetchedEnd, setFetchedEnd] = useState<{ throughSeq?: number }>();
+  const [fetchedEnd, setFetchedEnd] = useState<{
+    throughSeq?: number;
+    unreadCursor?: string;
+    unreadPage?: ConversationEventPage;
+  }>();
   const read =
     opened ??
     (detail ? { lastReadSeq: detail.readPosition?.lastReadSeq } : undefined);
   if (!opened && read) setOpened(read);
   const end =
     fetchedEnd ??
-    (fetched ? { throughSeq: fetched.events.at(-1)?.seq } : undefined);
+    (fetched
+      ? {
+          throughSeq: fetched.events.at(-1)?.seq,
+          unreadCursor: fetched.unreadCursor,
+          unreadPage: fetched.unreadPage,
+        }
+      : undefined);
   if (!fetchedEnd && end) setFetchedEnd(end);
-  return readPositionAtOpen(
-    read?.lastReadSeq,
-    end ? end.throughSeq : detail?.events.at(-1)?.seq,
-  );
+  return {
+    ...readPositionAtOpen(
+      read?.lastReadSeq,
+      end ? end.throughSeq : detail?.events.at(-1)?.seq,
+    ),
+    ...(end?.unreadCursor
+      ? { unreadCursor: end.unreadCursor, unreadPage: end.unreadPage }
+      : undefined),
+  };
 }
 
 type DetailAtOpen = {
   events: readonly { seq: number }[];
   readPosition?: ConversationReadPosition;
+  unreadCursor?: string;
+  unreadPage?: ConversationEventPage;
 };
 
 /** Find the rows after the read position, through the last row at open. */

package/src/client/conversations/transcriptRenderModel.ts

@@ -234,20 +234,7 @@ export function messageRawText(message: TranscriptViewMessage): string {
           .map((attachment) => attachment.filename)
           .join("\n");
       }
-      if (part.event.type !== "handoff") {
-        return ["context compacted", part.event.summary]
-          .filter((line): line is string => line !== undefined)
-          .join("\n");
-      }
-      return [
-        "model handoff",
-        `model ${part.event.modelId}`,
-        `profile ${part.event.modelProfile}`,
-        part.event.summary,
-        part.event.reasoningLevel
-          ? `reasoning ${part.event.reasoningLevel}`
-          : undefined,
-      ]
+      return ["context compacted", part.event.summary]
         .filter((line): line is string => line !== undefined)
         .join("\n");
     })

package/src/client/conversations/transcriptSearch.tsx

@@ -194,17 +194,9 @@ export function entryMatchesSearch(
 
   if (entry.kind === "context") {
     const event = entry.part.event;
-    return event.type === "handoff"
-      ? [
-          "model handoff",
-          event.modelProfile,
-          event.modelId,
-          event.reasoningLevel,
-          event.summary,
-        ].some((value) => textContains(value, normalizedQuery))
-      : ["context compacted", event.summary].some((value) =>
-          textContains(value, normalizedQuery),
-        );
+    return ["context compacted", event.summary].some((value) =>
+      textContains(value, normalizedQuery),
+    );
   }
 
   return false;