@sentry/junior-dashboard 0.276.0 → 0.277.0

package/src/client/conversations/queries.ts

@@ -1,9 +1,9 @@
 import { useDeferredValue, useEffect, useMemo, useRef } from "react";
 import {
+  type QueryClient,
   queryOptions,
   useInfiniteQuery,
   useMutation,
-  useMutationState,
   useQuery,
   useQueryClient,
 } from "@tanstack/react-query";
@@ -12,13 +12,11 @@ import type {
   ConversationEventPage,
   ConversationFeed,
   ConversationPendingMessagesReport,
-  ConversationSummaryReport,
   InputImage,
 } from "@sentry/junior/api/schema";
 import {
   acceptedConversationMessageSchema,
   webMessageId,
-  archiveConversationResponseSchema,
   cancelConversationPendingMessagesResponseSchema,
   conversationDetailReportSchema,
   conversationEventPageSchema,
@@ -28,11 +26,11 @@ import {
   stopConversationTurnResponseSchema,
 } from "@sentry/junior/api/schema";
 
+import { REVIEW_ITEMS_QUERY_KEY } from "../review-desk/queries";
 import {
   DashboardApiError,
   del,
   fetchDashboardJson,
-  patch,
   post,
   readDashboardResponse,
 } from "../http";
@@ -66,78 +64,13 @@ export function conversationDetailQueryKey(conversationId: string | undefined) {
   return ["conversation", conversationId, "detail"] as const;
 }
 
-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;
-    },
-  });
-}
-
 // Right after a send, Junior usually reads the message within a few seconds.
 // Poll fast for that window only, then fall back to the normal live interval.
 const FAST_POLL_INTERVAL_MS = 500;
 const FAST_POLL_WINDOW_MS = 6_000;
 
-type ConversationSnapshot = ConversationDetailReport & {
+/** The cached detail report with its mailbox and revalidation ETag. */
+export type ConversationSnapshot = ConversationDetailReport & {
   mailbox?: ConversationPendingMessagesReport;
   detailEtag?: string;
 };
@@ -153,6 +86,32 @@ async function readConversationSnapshot(
   return { ...detail, mailbox };
 }
 
+const CONVERSATION_SIDE_READS = ["agents", "memories", "watches"] as const;
+
+/**
+ * Key a read that shows beside the detail report, such as in the details
+ * panel. A detail change refreshes it.
+ */
+export function conversationSideReadQueryKey(
+  conversationId: string,
+  read: (typeof CONVERSATION_SIDE_READS)[number],
+) {
+  return ["conversation", conversationId, read] as const;
+}
+
+/** Refresh the side reads and Review items. Only mounted reads refetch. */
+function refreshConversationSideReads(
+  client: QueryClient,
+  conversationId: string,
+) {
+  for (const read of CONVERSATION_SIDE_READS) {
+    void client.invalidateQueries({
+      queryKey: conversationSideReadQueryKey(conversationId, read),
+    });
+  }
+  void client.invalidateQueries({ queryKey: REVIEW_ITEMS_QUERY_KEY });
+}
+
 /** Refresh history and mailbox as one visible snapshot, including idle input. */
 export function conversationDetailQueryOptions(
   conversationId: string | undefined,
@@ -165,14 +124,26 @@ export function conversationDetailQueryOptions(
   return queryOptions({
     enabled: Boolean(conversationId),
     queryKey: conversationDetailQueryKey(conversationId),
-    queryFn: ({ signal, client }) =>
-      readConversationSnapshot(
+    queryFn: async ({ signal, client }) => {
+      const previous = client.getQueryData<ConversationSnapshot>(
+        conversationDetailQueryKey(conversationId),
+      );
+      const next = await readConversationSnapshot(
         conversationId!,
         signal,
-        client.getQueryData<ConversationSnapshot>(
-          conversationDetailQueryKey(conversationId),
-        ),
-      ),
+        previous,
+      );
+      // Side reads do not poll. A new ETag means the Conversation changed,
+      // so the details panel may be stale too.
+      if (
+        previous?.detailEtag &&
+        next.detailEtag &&
+        previous.detailEtag !== next.detailEtag
+      ) {
+        refreshConversationSideReads(client, conversationId!);
+      }
+      return next;
+    },
     structuralSharing: (previous, next) => {
       if (!next || typeof next !== "object") return next;
       if (!previous || typeof previous !== "object") return next;
@@ -510,167 +481,6 @@ export function useStopConversationTurn(conversationId: string) {
   });
 }
 
-/** 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;
-      // 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,
-              { ...archivedSnapshot!.conversation, archivedAt: null },
-            ].sort((a, b) => b.lastSeenAt.localeCompare(a.lastSeenAt))
-          : feed.conversations.map((conversation) =>
-              conversation.conversationId === conversationId
-                ? { ...conversation, archivedAt }
-                : conversation,
-            );
-        queryClient.setQueryData<ConversationFeed>(queryKey, {
-          ...feed,
-          conversations,
-        });
-      });
-      queryClient.setQueryData<ConversationSnapshot>(
-        detailQueryKey,
-        (detail) =>
-          detail ? { ...detail, archivedAt, 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;
-}
-
 /** Fetch a bounded conversation snapshot and older pages on demand. */
 export function useConversationData(conversationId: string | undefined) {
   const queryClient = useQueryClient();

package/src/client/conversations/usePinConversation.ts

@@ -0,0 +1,88 @@
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import type {
+  ConversationDetailReport,
+  ConversationFeed,
+} from "@sentry/junior/api/schema";
+import { pinConversationResponseSchema } from "@sentry/junior/api/schema";
+
+import { patch } from "../http";
+import { conversationDetailQueryKey } from "./queries";
+
+type DetailCache = ConversationDetailReport & { detailEtag?: string };
+
+/**
+ * Pin or unpin one conversation for the viewer. The feed and detail caches
+ * change at once, so the row moves to or from the Pinned section before the
+ * request returns. A failed request puts the old caches back.
+ */
+export function usePinConversation(
+  conversationId: string,
+  options?: { onError?(pinned: boolean): void; onSuccess?(): void },
+) {
+  const queryClient = useQueryClient();
+  const feeds = { queryKey: ["dashboard", "conversations"] };
+  const detailQueryKey = conversationDetailQueryKey(conversationId);
+  const setPinnedAt = (pinnedAt: string | null) => {
+    // Match the API: a pin also restores an archived conversation.
+    const viewerMarks = pinnedAt
+      ? { archivedAt: null, pinnedAt }
+      : { pinnedAt };
+    queryClient.setQueriesData<ConversationFeed>(feeds, (feed) =>
+      feed
+        ? {
+            ...feed,
+            conversations: feed.conversations.map((conversation) =>
+              conversation.conversationId === conversationId
+                ? { ...conversation, ...viewerMarks }
+                : conversation,
+            ),
+          }
+        : feed,
+    );
+    // Clear the etag so the next read gets a full body, not a 304 that keeps
+    // this local value.
+    queryClient.setQueryData<DetailCache>(detailQueryKey, (detail) =>
+      detail ? { ...detail, ...viewerMarks, detailEtag: undefined } : detail,
+    );
+  };
+  return useMutation({
+    mutationFn: (pinned: boolean) =>
+      patch(
+        pinConversationResponseSchema,
+        `/api/conversations/${encodeURIComponent(conversationId)}/pin`,
+        { pinned },
+      ),
+    onMutate: async (pinned) => {
+      await Promise.all([
+        queryClient.cancelQueries(feeds),
+        queryClient.cancelQueries({ queryKey: detailQueryKey }),
+      ]);
+      const previous = {
+        detail: queryClient.getQueryData<DetailCache>(detailQueryKey),
+        feeds: queryClient.getQueriesData<ConversationFeed>(feeds),
+      };
+      setPinnedAt(pinned ? new Date().toISOString() : null);
+      return previous;
+    },
+    onError: (_error, pinned, previous) => {
+      previous?.feeds.forEach(([queryKey, feed]) => {
+        queryClient.setQueryData(queryKey, feed);
+      });
+      queryClient.setQueryData(detailQueryKey, previous?.detail);
+      options?.onError?.(pinned);
+    },
+    onSuccess: (result) => {
+      setPinnedAt(result.pinnedAt);
+      options?.onSuccess?.();
+    },
+    // A reader's first pin adds the conversation to their feed.
+    onSettled: () =>
+      Promise.all([
+        queryClient.invalidateQueries(feeds),
+        queryClient.invalidateQueries({
+          exact: true,
+          queryKey: detailQueryKey,
+        }),
+      ]),
+  });
+}

package/src/client/display-text/DisplayText.tsx

@@ -2,7 +2,8 @@ import { memo } from "react";
 import type { ActorIdentity } from "@sentry/junior/api/schema";
 
 import { HighlightedCode } from "../code";
-import { parseMarkdownBlocks } from "../format";
+import { CopyButton } from "../components/CopyButton";
+import { parseMarkdownBlocks } from "./codeBlocks";
 import { MarkdownText } from "./markdown";
 import { MentionPeopleProvider } from "./mentions";
 
@@ -56,10 +57,14 @@ function DisplayTextBlocks(props: { chat?: boolean; text: string }) {
 
         return (
           <div
-            className="min-w-0 overflow-hidden rounded-md border border-dashboard-border-subtle bg-dashboard-surface-panel px-3 py-2.5"
+            className="group/code relative min-w-0 overflow-hidden rounded-md border border-dashboard-border-subtle bg-dashboard-surface-panel py-2.5 pl-3 pr-10"
             key={index}
           >
             <HighlightedCode code={block.code} language={block.language} />
+            {/* Touch screens cannot hover, so keep the button visible there. */}
+            <div className="absolute right-0.5 top-0.5 transition-opacity [@media(hover:hover)_and_(pointer:fine)]:opacity-0 [@media(hover:hover)_and_(pointer:fine)]:group-hover/code:opacity-100 [@media(hover:hover)_and_(pointer:fine)]:group-focus-within/code:opacity-100">
+              <CopyButton getText={() => block.code} label="Copy code" />
+            </div>
           </div>
         );
       })}

package/src/client/display-text/codeBlocks.ts

@@ -0,0 +1,92 @@
+import type { BundledLanguage } from "shiki/bundle/web";
+
+import { dashboardCodeLanguages } from "../code-languages";
+import { detectOutputLanguage, prettyJsonData } from "../format";
+import type { CodeBlock } from "../types";
+
+// Shiki has no language detection, and agents often leave fences untagged.
+// Only clear signals select a language, so prose in a fence stays plain.
+const SCRIPT_PATTERN =
+  /^javascript:|=>|\b(?:const|let|var)\s+[\w$]+\s*=|\bfunction\b\s*[\w$]*\s*\(|^\s*(?:import\s.+\sfrom\s|export\s+(?:(?:async|class|const|default|enum|function|interface|let|type|var)\s|[{*]))/m;
+const PYTHON_PATTERN =
+  /^\s*(?:(?:async\s+)?def\s+\w+\s*\(.*\)\s*(?:->.*)?:|class\s+\w+(?:\([^)]*\))?\s*:|from\s+[\w.]+\s+import\s|import\s+[\w.]+\s*$)/m;
+const SHELL_PATTERN =
+  /^\s*(?:\$\s|(?:bun|brew|cargo|cat|cd|cp|curl|docker|echo|export|gh|git|go|grep|kubectl|ls|make|mkdir|mv|npm|npx|pip|pnpm|rm|ssh|sudo|uv|wget|yarn)\s)/;
+
+const LANGUAGE_ALIASES: Record<string, BundledLanguage> = {
+  console: "shellscript",
+  htm: "html",
+  js: "javascript",
+  jsonl: "json",
+  md: "markdown",
+  ndjson: "json",
+  sh: "shellscript",
+  text: "markdown",
+  txt: "markdown",
+  xml: "xml",
+  yml: "yaml",
+};
+
+/** Parse transcript prose as Markdown or JSON while preserving fenced code. */
+export function parseMarkdownBlocks(text: string): CodeBlock[] {
+  const blocks: CodeBlock[] = [];
+  // The info string can hold more than the language, such as `c++` or
+  // `js title="x"`. Only its first word names the language.
+  const fence = /^([ \t]*)```([^\n`]*)\n([\s\S]*?)```/gm;
+  let cursor = 0;
+  let match: RegExpExecArray | null;
+  while ((match = fence.exec(text))) {
+    const prose = text.slice(cursor, match.index).trim();
+    if (prose) blocks.push(proseBlock(prose));
+    const tag = match[2]?.trim().split(/\s+/)[0];
+    const code = stripFenceIndent(match[3] ?? "", match[1]?.length ?? 0);
+    const language = tag ? normalizeLanguage(tag) : guessLanguage(code);
+    blocks.push({
+      code: formatCodeBlock(code, language),
+      fenced: true,
+      language,
+    });
+    cursor = match.index + match[0].length;
+  }
+  const rest = text.slice(cursor).trim();
+  if (rest) blocks.push(proseBlock(rest));
+  return blocks.length > 0 ? blocks : [proseBlock(text)];
+}
+
+function proseBlock(text: string): CodeBlock {
+  const language = detectOutputLanguage(text);
+  return { code: formatCodeBlock(text, language), fenced: false, language };
+}
+
+function normalizeLanguage(tag: string): BundledLanguage {
+  const normalized = tag.toLowerCase();
+  const candidate = LANGUAGE_ALIASES[normalized] ?? normalized;
+  return Object.hasOwn(dashboardCodeLanguages, candidate)
+    ? (candidate as BundledLanguage)
+    : "markdown";
+}
+
+function guessLanguage(code: string): BundledLanguage {
+  if (detectOutputLanguage(code) === "json") return "json";
+  if (SCRIPT_PATTERN.test(code)) return "tsx";
+  if (PYTHON_PATTERN.test(code)) return "python";
+  if (SHELL_PATTERN.test(code)) return "shellscript";
+  return "markdown";
+}
+
+// A fence in a list item is indented, and so are its code lines. Remove that
+// indent, as CommonMark does.
+function stripFenceIndent(code: string, indent: number): string {
+  if (indent === 0) return code;
+  return code
+    .split("\n")
+    .map((line) => {
+      const lead = line.length - line.trimStart().length;
+      return line.slice(Math.min(indent, lead));
+    })
+    .join("\n");
+}
+
+function formatCodeBlock(code: string, language: BundledLanguage): string {
+  return language === "json" ? (prettyJsonData(code) ?? code) : code;
+}

package/src/client/format.ts

@@ -1,5 +1,4 @@
 import type { BundledLanguage } from "shiki/bundle/web";
-import { dashboardCodeLanguages } from "./code-languages";
 import type {
   ActorIdentity,
   ConversationAuxiliaryCosts,
@@ -8,7 +7,6 @@ import type {
   ConversationUsage,
 } from "@sentry/junior/api/schema";
 import type {
-  CodeBlock,
   Conversation,
   ConversationTranscript,
   TranscriptViewMessage,
@@ -815,28 +813,6 @@ export function automationPath(
   return tab === "overview" ? base : `${base}/${tab}`;
 }
 
-function normalizeLanguage(language: string | undefined): BundledLanguage {
-  const normalized = language?.trim().toLowerCase();
-  if (!normalized) return "markdown";
-  const aliases: Record<string, BundledLanguage> = {
-    console: "shellscript",
-    htm: "html",
-    js: "javascript",
-    jsonl: "json",
-    md: "markdown",
-    ndjson: "json",
-    sh: "shellscript",
-    text: "markdown",
-    txt: "markdown",
-    xml: "xml",
-    yml: "yaml",
-  };
-  const candidate = aliases[normalized] ?? normalized;
-  return Object.hasOwn(dashboardCodeLanguages, candidate)
-    ? (candidate as BundledLanguage)
-    : "markdown";
-}
-
 function prettyJson(text: string): string | undefined {
   const trimmed = text.trim();
   if (!trimmed) return undefined;
@@ -863,14 +839,11 @@ function prettyJsonl(text: string): string | undefined {
   return formatted.join("\n");
 }
 
-function prettyJsonData(text: string): string | undefined {
+/** Pretty-print JSON or JSONL text, or return undefined for other text. */
+export function prettyJsonData(text: string): string | undefined {
   return prettyJson(text) ?? prettyJsonl(text);
 }
 
-function formatCodeBlock(code: string, language: BundledLanguage): string {
-  return language === "json" ? (prettyJsonData(code) ?? code) : code;
-}
-
 /**
  * Detect the language for LLM text output prose: json if the text is valid
  * JSON or JSONL, markdown otherwise. Never auto-detects XML, HTML, TypeScript,
@@ -889,44 +862,6 @@ export function detectOutputLanguage(text: string): BundledLanguage {
   return "markdown";
 }
 
-/** Parse transcript prose as Markdown or JSON while preserving fenced code. */
-export function parseMarkdownBlocks(text: string): CodeBlock[] {
-  const blocks: CodeBlock[] = [];
-  const fence = /```([A-Za-z0-9_-]+)?\n([\s\S]*?)```/g;
-  let cursor = 0;
-  let match: RegExpExecArray | null;
-  while ((match = fence.exec(text))) {
-    const prose = text.slice(cursor, match.index).trim();
-    if (prose) {
-      const language = detectOutputLanguage(prose);
-      blocks.push({
-        code: formatCodeBlock(prose, language),
-        fenced: false,
-        language,
-      });
-    }
-    const language = normalizeLanguage(match[1]);
-    blocks.push({
-      code: formatCodeBlock(match[2] ?? "", language),
-      fenced: true,
-      language,
-    });
-    cursor = match.index + match[0].length;
-  }
-  const rest = text.slice(cursor).trim();
-  if (rest) {
-    const language = detectOutputLanguage(rest);
-    blocks.push({
-      code: formatCodeBlock(rest, language),
-      fenced: false,
-      language,
-    });
-  }
-  if (blocks.length > 0) return blocks;
-  const language = detectOutputLanguage(text);
-  return [{ code: formatCodeBlock(text, language), fenced: false, language }];
-}
-
 /** Convert SQL conversation summaries into dashboard rows. */
 export function buildConversations(
   summaries: ConversationSummaryReport[],
@@ -937,6 +872,7 @@ export function buildConversations(
       annotations: summary.annotations,
       sidebarAnnotations: summary.sidebarAnnotations,
       archivedAt: summary.archivedAt,
+      pinnedAt: summary.pinnedAt,
       auxiliaryCosts: summary.auxiliaryCosts,
       channel: summary.channel,
       channelName: summary.channelName,

package/src/client/pages/code/RepositoryTabs.tsx

@@ -16,7 +16,7 @@ import {
 } from "../../components/controls/TimeRangeSelector";
 import { Card } from "../../components/layout/Card";
 import { ConversationHomeList } from "../../conversations/ConversationHomeList";
-import { attentionFirst } from "../../conversations/conversationSections";
+import { pinnedAndAttentionFirst } from "../../conversations/conversationSections";
 import { buildConversations, getDashboardTimeZone } from "../../format";
 import { useDebouncedValue } from "../../debouncedValue";
 import { useWaitingConversationIds } from "../../review-desk/queries";
@@ -54,7 +54,7 @@ export function RepositoryConversationsTab(props: { repositoryId: string }) {
       ) : (
         <ConversationHomeList
           conversations={pageItems(
-            attentionFirst(conversations, waitingConversationIds),
+            pinnedAndAttentionFirst(conversations, waitingConversationIds),
             page,
             PAGE_SIZE,
           )}