@sentry/junior-dashboard 0.276.0 → 0.278.0

package/src/client/conversations/TranscriptContextEventView.tsx

@@ -16,24 +16,15 @@ export function TranscriptContextEventView(props: {
   timestamp?: number;
 }) {
   const event = props.part.event;
-  const handoff = event.type === "handoff";
-  const compactionDetail =
-    event.type === "compaction" && event.details
-      ? ` at approximately ${formatCompactNumber(event.details.estimatedInputTokens)} estimated tokens`
-      : "";
-  const compactionModel =
-    event.type === "compaction" && event.modelProfile && event.modelId
-      ? ` using the ${event.modelProfile} profile (${event.modelId})`
-      : "";
+  const compactionDetail = event.details
+    ? ` at approximately ${formatCompactNumber(event.details.estimatedInputTokens)} estimated tokens`
+    : "";
+  const compactionModel = event.modelId ? ` using ${event.modelId}` : "";
   return (
     <article className="min-w-0 py-0.5">
       <div className="flex min-w-0 flex-wrap items-center justify-between gap-x-3 gap-y-1">
-        <strong
-          className={`font-sans text-xs font-semibold ${
-            handoff ? "text-sky-100" : "text-amber-100"
-          }`}
-        >
-          {handoff ? "Model handoff" : "Context compacted"}
+        <strong className="font-sans text-xs font-semibold text-amber-100">
+          Context compacted
         </strong>
         {typeof props.timestamp === "number" ? (
           <span className="text-xs text-dashboard-text-muted">
@@ -42,9 +33,7 @@ export function TranscriptContextEventView(props: {
         ) : null}
       </div>
       <div className="mt-1 text-xs leading-relaxed text-dashboard-text-muted">
-        {handoff
-          ? `Handed off to ${event.modelId} via the ${event.modelProfile} profile${event.reasoningLevel ? ` (${event.reasoningLevel})` : ""}.`
-          : `Earlier context was summarized${compactionDetail}${compactionModel} before execution continued.`}
+        {`Earlier context was summarized${compactionDetail}${compactionModel} before execution continued.`}
       </div>
       {event.summary ? (
         <Collapsible className="mt-2">

package/src/client/conversations/TranscriptMemoryPopover.tsx

@@ -18,6 +18,7 @@ import {
   type ConversationMemoryState,
   type MemoryAnchor,
 } from "./conversationMemory";
+import { MemoryLinkIcons } from "./MemoryIcons";
 import { memoryRecallContent } from "./turnContext";
 
 function memoryCount(count: number): string {
@@ -54,32 +55,26 @@ function MemoryPopover(props: {
         aria-label={props.label}
         className="max-h-[min(28rem,var(--available-height))] w-96 p-1.5"
       >
-        <ul className="m-0 grid list-none gap-0.5 p-0">
+        <ul className="m-0 grid list-none divide-y divide-dashboard-border-subtle p-0">
           {props.memories.map((memory) => (
-            <li
-              className={cn(
-                "grid gap-1.5 rounded-md px-2.5 py-2",
-                memory.id === highlightId && "bg-dashboard-fill-strong",
-              )}
-              key={memory.id}
-              ref={
-                memory.id === highlightId
-                  ? (node) => node?.scrollIntoView({ block: "nearest" })
-                  : undefined
-              }
-            >
-              <p className="m-0 whitespace-pre-wrap break-words text-sm leading-relaxed text-dashboard-text">
-                {memory.content}
-              </p>
-              <div className="flex items-center gap-3 text-xs text-dashboard-text-muted">
-                {memory.visibility === "private" ? <span>Private</span> : null}
-                <Link
-                  className="text-dashboard-text-muted no-underline hover:text-dashboard-text hover:underline"
-                  to={memoryPath(memory.id)}
-                >
-                  Open
-                </Link>
-              </div>
+            <li className="py-1 first:pt-0 last:pb-0" key={memory.id}>
+              <Link
+                className={cn(
+                  "group grid grid-cols-[minmax(0,1fr)_auto] items-start gap-3 rounded-md px-2.5 py-2 no-underline transition-colors hover:bg-dashboard-fill-hover focus-visible:outline-2 focus-visible:-outline-offset-2 focus-visible:outline-dashboard-focus",
+                  memory.id === highlightId && "bg-dashboard-fill-strong",
+                )}
+                ref={
+                  memory.id === highlightId
+                    ? (node) => node?.scrollIntoView({ block: "nearest" })
+                    : undefined
+                }
+                to={memoryPath(memory.id)}
+              >
+                <p className="m-0 line-clamp-4 whitespace-pre-wrap break-words text-sm leading-relaxed text-dashboard-text">
+                  {memory.content}
+                </p>
+                <MemoryLinkIcons private={memory.visibility === "private"} />
+              </Link>
             </li>
           ))}
         </ul>

package/src/client/conversations/TranscriptRailEvent.tsx

@@ -14,7 +14,6 @@ import {
   MessageSquareText,
   Minimize2,
   Paperclip,
-  Send,
   Sparkles,
   TriangleAlert,
   Webhook,
@@ -27,7 +26,6 @@ import type { TranscriptViewStructuredEventPart } from "../types";
 type TranscriptRailEventKind =
   | "attachments_delivered"
   | "compaction"
-  | "handoff"
   | "message_context"
   | "event"
   | "structured_event"
@@ -119,12 +117,6 @@ function transcriptRailMarker(kind: TranscriptRailEventKind): {
       icon: Bot,
     };
   }
-  if (kind === "handoff") {
-    return {
-      className: "text-sky-200",
-      icon: Send,
-    };
-  }
   return {
     className: "text-amber-200",
     icon: Minimize2,

package/src/client/conversations/TranscriptTurnContextView.tsx

@@ -29,6 +29,7 @@ import {
 } from "./turnContext";
 import { cn } from "../styles";
 import { DetailsCard } from "./DetailsList";
+import { MemoryLinkIcons } from "./MemoryIcons";
 import { HighlightText } from "./transcriptSearch";
 
 /** What one turn context view shows: who spoke, when, and the context. */
@@ -270,17 +271,20 @@ function TurnContextCard(props: { context: TranscriptViewTurnContext }) {
   );
 }
 
-// Each row links to the memory's page, which shows its details.
+// Each row shows the full memory and links to the memory's page.
 function MemoryRecall(props: { memories: MemoryRecallContent["memories"] }) {
   return (
-    <ul className="-mx-1.5 -mb-1.5 -mt-1 grid list-none gap-0.5 p-0">
+    <ul className="-mx-1.5 -mb-1.5 -mt-1 grid list-none divide-y divide-dashboard-border-subtle p-0">
       {props.memories.map((memory) => (
-        <li key={memory.id}>
+        <li className="py-1 first:pt-0 last:pb-0" key={memory.id}>
           <Link
-            className="line-clamp-2 rounded-md px-1.5 py-1.5 text-sm leading-5 text-dashboard-text no-underline transition-colors hover:bg-dashboard-surface-hover focus-visible:outline focus-visible:outline-2 focus-visible:-outline-offset-2 focus-visible:outline-dashboard-focus"
+            className="group grid grid-cols-[minmax(0,1fr)_auto] items-start gap-3 rounded-md px-1.5 py-1.5 no-underline transition-colors hover:bg-dashboard-surface-hover focus-visible:outline focus-visible:outline-2 focus-visible:-outline-offset-2 focus-visible:outline-dashboard-focus"
             to={memoryPath(memory.id)}
           >
-            <HighlightText text={memory.content} />
+            <span className="whitespace-pre-wrap break-words text-sm leading-relaxed text-dashboard-text">
+              <HighlightText text={memory.content} />
+            </span>
+            <MemoryLinkIcons private={memory.scope === "personal"} />
           </Link>
         </li>
       ))}

package/src/client/conversations/TranscriptView.tsx

@@ -1,4 +1,4 @@
-import { useState } from "react";
+import { useState, type ReactNode, type Ref } from "react";
 import type { ConversationMailboxMessage } from "./conversationOutbox";
 import { ArrowDown } from "lucide-react";
 
@@ -8,12 +8,13 @@ import type {
 } from "../types";
 import { EmptyTelemetry } from "../components/EmptyTelemetry";
 import { Button } from "../components/ui/button";
+import { cn } from "../styles";
 import { ConversationTranscriptView } from "./ConversationTranscript";
 import { ConversationEventLog } from "./ConversationEventLog";
 import {
   transcriptBottomVersion,
   transcriptJuniorMessageVersion,
-  useAutoLoadPreviousPage,
+  useAutoLoadHistoryPage,
   usePinnedTranscriptBottom,
 } from "./transcriptBottomPinning";
 import type { TranscriptViewMode } from "./transcriptRenderModel";
@@ -22,6 +23,7 @@ import {
   type TranscriptUnreadRange,
 } from "./transcriptReadPosition";
 import { TranscriptSearchProvider } from "./transcriptSearch";
+import type { TranscriptHistory } from "./transcriptUnreadHistory";
 import {
   TurnContextPanelProvider,
   type TurnContextPanel,
@@ -36,6 +38,11 @@ export function Transcript(props: {
   /** The read position when the Conversation opened. */
   lastReadSeq?: number;
   loadingPreviousPage?: boolean;
+  /**
+   * Newer pages between the read position and the latest. They load on
+   * scroll. Jump to latest skips them.
+   */
+  newerHistory?: TranscriptHistory["newer"];
   pinRequestVersion?: number;
   onLoadPreviousPage?: () => void;
   /** Receive the last event sequence the reader saw in the transcript. */
@@ -68,6 +75,7 @@ export function Transcript(props: {
   const bottomPinning = usePinnedTranscriptBottom({
     conversationId: props.transcript?.conversationId,
     enabled: props.live ?? false,
+    endsAtLatest: !props.newerHistory,
     historyVersion: props.historyVersion ?? "empty",
     juniorMessageVersion: transcriptJuniorMessageVersion(props.transcript),
     pinRequestVersion: props.pinRequestVersion,
@@ -88,7 +96,8 @@ export function Transcript(props: {
     paused: view !== "rich" || search.trim().length > 0,
   });
   const loadPreviousPage = () => props.onLoadPreviousPage?.();
-  const previousPageRef = useAutoLoadPreviousPage({
+  const previousPageRef = useAutoLoadHistoryPage({
+    edge: "top",
     enabled: Boolean(
       props.onLoadPreviousPage &&
       props.hasPreviousPage &&
@@ -98,6 +107,13 @@ export function Transcript(props: {
     historyVersion: props.historyVersion ?? "empty",
     onLoad: loadPreviousPage,
   });
+  const newer = props.newerHistory;
+  const newerPageRef = useAutoLoadHistoryPage({
+    edge: "bottom",
+    enabled: Boolean(newer && !newer.loading && !newer.error),
+    historyVersion: props.historyVersion ?? "empty",
+    onLoad: () => newer?.load(),
+  });
 
   if (!props.transcript) {
     return (
@@ -120,22 +136,17 @@ export function Transcript(props: {
           </div>
         ) : null}
         {props.hasPreviousPage || props.loadingPreviousPage ? (
-          <div className="mb-3 flex items-center gap-3" ref={previousPageRef}>
-            <span className="h-px min-w-4 flex-1 bg-dashboard-fill-strong" />
-            <button
-              aria-label="Load earlier events"
-              className="shrink-0 cursor-pointer border-0 bg-transparent px-1 py-0.5 font-sans text-xs font-medium text-dashboard-text-muted transition-colors hover:text-dashboard-text focus-visible:outline focus-visible:outline-1 focus-visible:outline-dashboard-focus/55 disabled:cursor-not-allowed disabled:opacity-50"
-              disabled={props.loadingPreviousPage}
-              onClick={loadPreviousPage}
-              title="Load earlier events"
-              type="button"
-            >
-              {props.loadingPreviousPage
-                ? `Loading earlier ${historyLabel}…`
-                : `Show earlier ${historyLabel}`}
-            </button>
-            <span className="h-px min-w-4 flex-1 bg-dashboard-fill-strong" />
-          </div>
+          <HistoryPageControl
+            className="mb-3"
+            label="Load earlier events"
+            loading={props.loadingPreviousPage}
+            onClick={loadPreviousPage}
+            ref={previousPageRef}
+          >
+            {props.loadingPreviousPage
+              ? `Loading earlier ${historyLabel}…`
+              : `Show earlier ${historyLabel}`}
+          </HistoryPageControl>
         ) : null}
         {props.historyError ? (
           <div
@@ -164,6 +175,30 @@ export function Transcript(props: {
             />
           </TurnContextPanelProvider>
         )}
+        {newer ? (
+          <>
+            {newer.error ? (
+              <div
+                aria-live="polite"
+                className="mt-2 text-center font-sans text-xs text-amber-100/65"
+              >
+                Newer events could not be loaded.
+              </div>
+            ) : null}
+            {/* The bottom margin keeps the jump control off this row. */}
+            <HistoryPageControl
+              className="mb-12 mt-3"
+              label="Load newer events"
+              loading={newer.loading}
+              onClick={newer.load}
+              ref={newerPageRef}
+            >
+              {newer.loading
+                ? `Loading newer ${historyLabel}…`
+                : `Show newer ${historyLabel}`}
+            </HistoryPageControl>
+          </>
+        ) : null}
         <div
           aria-hidden="true"
           className="h-px"
@@ -171,7 +206,11 @@ export function Transcript(props: {
         />
         <JumpToLatestButton
           hasPendingUpdate={bottomPinning.hasPendingUpdate}
-          onClick={bottomPinning.jumpToBottom}
+          onClick={() => {
+            // The latest page is in the detail, so the jump needs no request.
+            newer?.showLatest();
+            bottomPinning.jumpToBottom();
+          }}
           visible={bottomPinning.showJumpToLatest}
         />
       </div>
@@ -179,6 +218,36 @@ export function Transcript(props: {
   );
 }
 
+/** A divider with one control that loads another page of history. */
+function HistoryPageControl(props: {
+  children: ReactNode;
+  className: string;
+  label: string;
+  loading?: boolean;
+  onClick: () => void;
+  ref?: Ref<HTMLDivElement>;
+}) {
+  return (
+    <div
+      className={cn("flex items-center gap-3", props.className)}
+      ref={props.ref}
+    >
+      <span className="h-px min-w-4 flex-1 bg-dashboard-fill-strong" />
+      <button
+        aria-label={props.label}
+        className="shrink-0 cursor-pointer border-0 bg-transparent px-1 py-0.5 font-sans text-xs font-medium text-dashboard-text-muted transition-colors hover:text-dashboard-text focus-visible:outline focus-visible:outline-1 focus-visible:outline-dashboard-focus/55 disabled:cursor-not-allowed disabled:opacity-50"
+        disabled={props.loading}
+        onClick={props.onClick}
+        title={props.label}
+        type="button"
+      >
+        {props.children}
+      </button>
+      <span className="h-px min-w-4 flex-1 bg-dashboard-fill-strong" />
+    </div>
+  );
+}
+
 function JumpToLatestButton(props: {
   hasPendingUpdate: boolean;
   onClick: () => void;

package/src/client/conversations/autoArchiveQueries.ts

@@ -0,0 +1,53 @@
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import {
+  archiveDoneConversationsResponseSchema,
+  conversationAutoArchiveSchema,
+  type ConversationDetailReport,
+} from "@sentry/junior/api/schema";
+
+import { patch, post } from "../http";
+import { conversationDetailQueryKey } from "./queries";
+
+/** Turn auto-archive on or off for one conversation and the viewer. */
+export function useSetConversationAutoArchive(conversationId: string) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (autoArchive: boolean) =>
+      patch(
+        conversationAutoArchiveSchema,
+        `/api/conversations/${encodeURIComponent(conversationId)}/auto-archive`,
+        { autoArchive },
+      ),
+    onSuccess: (result) => {
+      queryClient.setQueryData<
+        ConversationDetailReport & { detailEtag?: string }
+      >(conversationDetailQueryKey(conversationId), (detail) =>
+        detail
+          ? {
+              ...detail,
+              autoArchive: result.autoArchive,
+              detailEtag: undefined,
+            }
+          : detail,
+      );
+    },
+  });
+}
+
+/** Archive all of the viewer's done conversations once. */
+export function useArchiveDoneConversations() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: () =>
+      post(
+        archiveDoneConversationsResponseSchema,
+        "/api/conversations/archive-done",
+        {},
+      ),
+    onSuccess: async () => {
+      await queryClient.invalidateQueries({
+        queryKey: ["dashboard", "conversations"],
+      });
+    },
+  });
+}

package/src/client/conversations/conversationArchive.ts

@@ -0,0 +1,255 @@
+import {
+  useMutation,
+  useMutationState,
+  useQueryClient,
+} from "@tanstack/react-query";
+import type {
+  ConversationDetailReport,
+  ConversationFeed,
+  ConversationSummaryReport,
+} from "@sentry/junior/api/schema";
+import { archiveConversationResponseSchema } from "@sentry/junior/api/schema";
+
+import { patch } from "../http";
+import {
+  conversationDetailQueryKey,
+  type ConversationSnapshot,
+} from "./queries";
+
+function archivedConversationQueryKey(conversationId: string) {
+  return ["dashboard", "archived-conversation", conversationId] as const;
+}
+
+/** Read active/archived status from a dashboard conversations query key. */
+function conversationFeedStatus(
+  queryKey: readonly unknown[],
+): "active" | "archived" | undefined {
+  const status = queryKey[queryKey.length - 1];
+  return status === "active" || status === "archived" ? status : undefined;
+}
+
+type ArchivedConversationSnapshot = {
+  conversation: ConversationSummaryReport;
+  feedQueryHashes: string[];
+};
+
+const archiveConversationMutationKey = [
+  "dashboard",
+  "archive-conversation",
+] as const;
+
+type ArchiveConversationVariables = {
+  archived: boolean;
+  lastSeenAt: string;
+};
+
+type ArchiveConversationMutationContext = {
+  archivedQueryKey: ReturnType<typeof archivedConversationQueryKey>;
+  archivedSnapshot?: ArchivedConversationSnapshot;
+  detailQueryKey: ReturnType<typeof conversationDetailQueryKey>;
+  previousArchivedSnapshot?: ArchivedConversationSnapshot;
+  previousDetail?: ConversationDetailReport;
+  previousFeeds: Array<[readonly unknown[], ConversationFeed | undefined]>;
+};
+
+export type PendingArchiveConversationUpdate = {
+  archived: boolean;
+  conversation?: ConversationSummaryReport;
+  conversationId: string;
+};
+
+/** Read pending archive state so refetches cannot visually replace optimistic UI. */
+export function usePendingArchiveConversationUpdates() {
+  return useMutationState({
+    filters: {
+      mutationKey: archiveConversationMutationKey,
+      status: "pending",
+    },
+    select: (mutation) => {
+      const variables = mutation.state
+        .variables as ArchiveConversationVariables;
+      const context = mutation.state.context as
+        | ArchiveConversationMutationContext
+        | undefined;
+      const conversationId = mutation.options.mutationKey?.[2];
+      return {
+        archived: variables.archived,
+        conversation: context?.archivedSnapshot?.conversation,
+        conversationId:
+          typeof conversationId === "string" ? conversationId : "",
+      } satisfies PendingArchiveConversationUpdate;
+    },
+  });
+}
+
+/** Archive or restore one conversation with an immediate reversible cache update. */
+export function useArchiveConversation(
+  conversationId: string,
+  options?: {
+    onError?(): void;
+    onSuccess?(archivedAt: string | null): void;
+  },
+) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationKey: [...archiveConversationMutationKey, conversationId],
+    mutationFn: (args: ArchiveConversationVariables) =>
+      patch(
+        archiveConversationResponseSchema,
+        `/api/conversations/${encodeURIComponent(conversationId)}/archive`,
+        args,
+      ),
+    onMutate: async (args) => {
+      const conversationQueries = { queryKey: ["dashboard", "conversations"] };
+      const detailQueryKey = conversationDetailQueryKey(conversationId);
+      const archivedQueryKey = archivedConversationQueryKey(conversationId);
+      await Promise.all([
+        queryClient.cancelQueries(conversationQueries),
+        queryClient.cancelQueries({ queryKey: detailQueryKey }),
+      ]);
+      const previousFeeds =
+        queryClient.getQueriesData<ConversationFeed>(conversationQueries);
+      const previousDetail =
+        queryClient.getQueryData<ConversationDetailReport>(detailQueryKey);
+      const previousArchivedSnapshot =
+        queryClient.getQueryData<ArchivedConversationSnapshot>(
+          archivedQueryKey,
+        );
+      const archivedAt = args.archived ? new Date().toISOString() : null;
+      // Match the API: archive also unpins.
+      const viewerMarks = args.archived
+        ? { archivedAt, pinnedAt: null }
+        : { archivedAt };
+      // Snapshot from any loaded feed, including archived-only fixtures that
+      // were never archived through this client session.
+      const archivedSnapshot =
+        buildArchivedConversationSnapshot(previousFeeds, conversationId) ??
+        previousArchivedSnapshot;
+
+      previousFeeds.forEach(([queryKey, feed]) => {
+        if (!feed) return;
+        const conversationExists = feed.conversations.some(
+          (conversation) => conversation.conversationId === conversationId,
+        );
+        const feedStatus = conversationFeedStatus(queryKey);
+        const shouldRestore =
+          !args.archived &&
+          !conversationExists &&
+          Boolean(archivedSnapshot) &&
+          feedStatus !== "archived";
+        const conversations = shouldRestore
+          ? [
+              ...feed.conversations,
+              // The archive cleared the pin, so the restored row is unpinned.
+              {
+                ...archivedSnapshot!.conversation,
+                archivedAt: null,
+                pinnedAt: null,
+              },
+            ].sort((a, b) => b.lastSeenAt.localeCompare(a.lastSeenAt))
+          : feed.conversations.map((conversation) =>
+              conversation.conversationId === conversationId
+                ? { ...conversation, ...viewerMarks }
+                : conversation,
+            );
+        queryClient.setQueryData<ConversationFeed>(queryKey, {
+          ...feed,
+          conversations,
+        });
+      });
+      queryClient.setQueryData<ConversationSnapshot>(
+        detailQueryKey,
+        (detail) =>
+          detail
+            ? { ...detail, ...viewerMarks, detailEtag: undefined }
+            : detail,
+      );
+      if (archivedSnapshot) {
+        queryClient.setQueryData(archivedQueryKey, archivedSnapshot);
+      }
+      return {
+        archivedQueryKey,
+        archivedSnapshot,
+        detailQueryKey,
+        previousArchivedSnapshot,
+        previousDetail,
+        previousFeeds,
+      } satisfies ArchiveConversationMutationContext;
+    },
+    onError: (_error, _args, context) => {
+      context?.previousFeeds.forEach(([queryKey, feed]) => {
+        queryClient.setQueryData(queryKey, feed);
+      });
+      if (context) {
+        queryClient.setQueryData(
+          context.detailQueryKey,
+          context.previousDetail,
+        );
+        if (context.previousArchivedSnapshot) {
+          queryClient.setQueryData(
+            context.archivedQueryKey,
+            context.previousArchivedSnapshot,
+          );
+        } else {
+          queryClient.removeQueries({
+            exact: true,
+            queryKey: context.archivedQueryKey,
+          });
+        }
+      }
+      options?.onError?.();
+    },
+    onSuccess: (result, args) => {
+      queryClient.setQueryData<ConversationSnapshot>(
+        conversationDetailQueryKey(conversationId),
+        (detail) =>
+          detail
+            ? {
+                ...detail,
+                archivedAt: result.archivedAt,
+                detailEtag: undefined,
+              }
+            : detail,
+      );
+      if (!args.archived) {
+        queryClient.removeQueries({
+          exact: true,
+          queryKey: archivedConversationQueryKey(conversationId),
+        });
+      }
+      options?.onSuccess?.(result.archivedAt);
+    },
+    onSettled: async () => {
+      await Promise.all([
+        queryClient.invalidateQueries({
+          queryKey: ["dashboard", "conversations"],
+        }),
+        queryClient.invalidateQueries({
+          queryKey: ["dashboard", "locations"],
+        }),
+        queryClient.invalidateQueries({ queryKey: ["dashboard", "people"] }),
+        queryClient.invalidateQueries({
+          exact: true,
+          queryKey: conversationDetailQueryKey(conversationId),
+        }),
+      ]);
+    },
+  });
+}
+
+function buildArchivedConversationSnapshot(
+  feeds: Array<[readonly unknown[], ConversationFeed | undefined]>,
+  conversationId: string,
+): ArchivedConversationSnapshot | undefined {
+  let conversation: ConversationSummaryReport | undefined;
+  const feedQueryHashes: string[] = [];
+  for (const [queryKey, feed] of feeds) {
+    const feedConversation = feed?.conversations.find(
+      (item) => item.conversationId === conversationId,
+    );
+    if (!feedConversation) continue;
+    conversation ??= feedConversation;
+    feedQueryHashes.push(JSON.stringify(queryKey));
+  }
+  return conversation ? { conversation, feedQueryHashes } : undefined;
+}

package/src/client/conversations/conversationMemory.ts

@@ -3,6 +3,7 @@ import { createContext, useContext } from "react";
 import { z } from "zod";
 
 import { fetchDashboardJson } from "../http";
+import { conversationSideReadQueryKey } from "./queries";
 
 const conversationMemoryListSchema = z
   .object({
@@ -45,7 +46,7 @@ export function useConversationMemories(conversationId: string) {
         `/api/plugins/memory/conversations/${encodeURIComponent(conversationId)}/memories`,
         signal,
       ),
-    queryKey: ["conversation", conversationId, "memories"],
+    queryKey: conversationSideReadQueryKey(conversationId, "memories"),
     retry: false,
   });
 }