gloomberb 0.16.4 → 0.16.6

package/src/plugins/builtin/chat/controller/index.ts

@@ -1,3 +1,4 @@
+import { registerAccountSession } from "../../../../account/session";
 import type {
   AppNotificationDelivery,
   AppNotificationRequest,
@@ -10,8 +11,11 @@ import {
   type ChatChannel,
   type ChatChannelState,
   type ChatMessage,
+  type ChatReaction,
+  type ChatReactionsUpdate,
   type PersistedAuthUser,
 } from "../../../../api-client";
+import { withOwnReaction } from "../reactions";
 import { normalizeSessionUser } from "./persistence";
 import { debugLog } from "../../../../utils/debug-log";
 import {
@@ -32,7 +36,8 @@ import {
   updateChatChannelDraft,
   updateChatChannelNotifications,
 } from "./channel-actions";
-import { retryChatMessageInChannel, sendChatMessageToChannel } from "./send";
+import { postImageMessageToChannel, retryChatMessageInChannel, sendChatMessageToChannel } from "./send";
+import { describeChatImageError } from "../attachments/model";
 import {
   addDraftAttachments,
   discardDraftAttachments,
@@ -143,6 +148,7 @@ export class ChatController {
     emit: (channelId) => this.emit(channelId),
     mergeMessages: (channelId, messages, options) => this.mergeMessages(channelId, messages, options),
     persistChannelState: (channelId) => this.storage.persistChannelState(channelId),
+    getReaderId: () => this.session.user?.id ?? null,
   });
   private readonly realtime = new ChatControllerRealtime({
     getAppActive: () => this.appActive,
@@ -150,6 +156,7 @@ export class ChatController {
     getUser: () => this.session.user,
     refreshSession: () => this.refreshSession(),
     handleNotification: (notification) => this.handleChatNotification(notification),
+    handleReactions: (update) => this.applyReactionsUpdate(update),
     setOnlineCount: (onlineCount) => {
       this.channelCatalog.setOnlineCount(onlineCount);
     },
@@ -171,6 +178,30 @@ export class ChatController {
     this.openMessageFn = openMessage;
   }
 
+  /**
+   * Mark all read in the Unread list: each unread channel is read through its
+   * newest message the way opening it in Chat reads it, and a channel with
+   * nothing on this device yet once its latest messages load. A failed load
+   * leaves that channel unread.
+   */
+  markAllChannelsRead(): void {
+    let changed = false;
+    for (const [channelId, channel] of this.storage.channelStates) {
+      if (channel.unreadCount <= 0) continue;
+      if (channel.messages.length > 0) {
+        changed = this.markViewedThroughLatestMessage(channelId) || changed;
+        continue;
+      }
+      void this.refreshChannelMessages(channelId)
+        .then(() => {
+          if (this.ensureChannelState(channelId).messages.length === 0) return;
+          if (this.markViewedThroughLatestMessage(channelId)) this.emit(channelId);
+        })
+        .catch(() => {});
+    }
+    if (changed) this.emit();
+  }
+
   hydrate(): void {
     hydrateChatControllerSession({
       session: this.session,
@@ -569,6 +600,47 @@ export class ChatController {
     };
   }
 
+  /**
+   * Posts one picture with an optional caption as the user's own message, as
+   * Share to Chat does: uploads it, then sends it, leaving the channel's
+   * draft alone. Rejects with a sentence that says what went wrong.
+   */
+  async postImage(
+    channelId: string,
+    upload: ChatAttachmentUpload & { previewUrl?: string | null },
+    caption: string,
+    options: { signal?: AbortSignal; onProgress?: (fraction: number) => void } = {},
+  ): Promise<ChatMessage> {
+    const normalizedChannelId = normalizeChannelId(channelId);
+    const user = this.session.user;
+    if (!user?.emailVerified) throw new Error("Verify your email to post in chat.");
+    let attachment;
+    try {
+      attachment = await this.uploadAttachment(normalizedChannelId, upload, {
+        signal: options.signal ?? new AbortController().signal,
+        onProgress: options.onProgress ?? (() => {}),
+      });
+    } catch (error) {
+      throw new Error(describeChatImageError(error));
+    }
+    const channel = this.ensureChannelState(normalizedChannelId);
+    return postImageMessageToChannel({
+      channelId: normalizedChannelId,
+      channel,
+      content: caption,
+      attachment,
+      previewUrl: upload.previewUrl ?? null,
+      user,
+      getVisibleMessages: () => this.getVisibleMessages(normalizedChannelId),
+      nextPendingMessageId: () => `local:${Date.now()}:${this.pendingMessageSeq += 1}`,
+      emit: () => this.emit(normalizedChannelId),
+      mergeMessages: (messages) => this.mergeMessages(normalizedChannelId, messages),
+      send: (content, clientMessageId, attachmentIds) => (
+        apiClient.sendMessage(normalizedChannelId, content, undefined, clientMessageId, attachmentIds)
+      ),
+    });
+  }
+
   /** Sends a failed message again with the same images and idempotency key. */
   retryChannelMessage(channelId: string, messageId: string): boolean {
     const normalizedChannelId = normalizeChannelId(channelId);
@@ -625,6 +697,55 @@ export class ChatController {
     }
   }
 
+  /**
+   * Adds or takes back your reaction with one emoji. The chip moves at once;
+   * the server's answer settles it, and a refusal puts it back and says why.
+   */
+  async toggleChannelReaction(channelId: string, messageId: string, emoji: string): Promise<boolean> {
+    const normalizedChannelId = normalizeChannelId(channelId);
+    const channel = this.ensureChannelState(normalizedChannelId);
+    const user = this.session.user;
+    if (!user?.emailVerified) return false;
+    const message = channel.messages.find((entry) => entry.id === messageId);
+    if (!message) return false;
+    const reacted = !(message.reactions ?? []).some((reaction) => reaction.emoji === emoji && reaction.me);
+    const self = { id: user.id, username: user.username, displayName: user.username };
+    this.replaceMessageReactions(normalizedChannelId, messageId, (current) => withOwnReaction(current, emoji, reacted, self));
+    try {
+      const update = await apiClient.setChatReaction(normalizedChannelId, messageId, emoji, reacted);
+      this.replaceMessageReactions(normalizedChannelId, messageId, () => update.reactions);
+      return true;
+    } catch (error) {
+      // Only this change is undone; what others did meanwhile stays.
+      this.replaceMessageReactions(normalizedChannelId, messageId, (current) => withOwnReaction(current, emoji, !reacted, self));
+      const body = error instanceof Error && error.message ? error.message : "Failed to react.";
+      this.notifyFn({ body, type: "error" });
+      return false;
+    }
+  }
+
+  /** A message's reactions as everyone reading the channel just got them. */
+  applyReactionsUpdate(update: ChatReactionsUpdate): void {
+    this.replaceMessageReactions(normalizeChannelId(update.channelId), update.messageId, () => update.reactions);
+  }
+
+  private replaceMessageReactions(
+    channelId: string,
+    messageId: string,
+    next: (current: ChatReaction[]) => ChatReaction[],
+  ): void {
+    const channel = this.storage.channelStates.get(channelId);
+    if (!channel) return;
+    const index = channel.messages.findIndex((entry) => entry.id === messageId);
+    if (index < 0) return;
+    const message = channel.messages[index]!;
+    channel.messages = channel.messages.map((entry, entryIndex) => (
+      entryIndex === index ? { ...message, reactions: next(message.reactions ?? []) } : entry
+    ));
+    this.storage.persistTranscript(channelId);
+    this.emit(channelId);
+  }
+
   ensureConnection(channelId = DEFAULT_CHAT_CHANNEL_ID): void {
     const normalizedChannelId = normalizeChannelId(channelId);
     const channel = this.ensureChannelState(normalizedChannelId);
@@ -757,3 +878,4 @@ export class ChatController {
 }
 
 export const chatController = new ChatController();
+registerAccountSession(chatController);

package/src/plugins/builtin/chat/controller/message-loading.ts

@@ -15,6 +15,8 @@ interface ChatControllerMessageLoadingOptions {
   emit: (channelId?: string) => void;
   mergeMessages: (channelId: string, messages: ChatMessage[], options?: MergeMessagesOptions) => void;
   persistChannelState: (channelId: string) => void;
+  /** The signed-in account's id, or null. */
+  getReaderId?: () => string | null;
 }
 
 export class ChatControllerMessageLoading {
@@ -45,6 +47,7 @@ export class ChatControllerMessageLoading {
       persistChannelState: (nextChannelId) => {
         this.options.persistChannelState(nextChannelId);
       },
+      readerId: () => this.options.getReaderId?.() ?? null,
     })
       .catch((error: unknown) => {
         channel.messagesError = error instanceof Error && error.message.trim()

package/src/plugins/builtin/chat/controller/messages.ts

@@ -49,10 +49,15 @@ function mergeStoredMessages(channel: ChannelRuntimeState, messages: ChatMessage
   const incoming = new Map<string, ChatMessage>();
   for (const message of channel.messages) merged.set(message.id, message);
   for (const message of messages) {
-    if (!merged.has(message.id)) {
+    const current = merged.get(message.id);
+    if (!current) {
       incoming.set(message.id, message);
     }
-    merged.set(message.id, message);
+    // A live copy (an edit) leaves reactions out; the ones held stay.
+    merged.set(
+      message.id,
+      current?.reactions && message.reactions === undefined ? { ...message, reactions: current.reactions } : message,
+    );
   }
   for (const message of messages) {
     for (const [id, current] of merged) {

package/src/plugins/builtin/chat/controller/realtime.ts

@@ -1,4 +1,4 @@
-import { apiClient, type ChatNotification } from "../../../../api-client";
+import { apiClient, type ChatNotification, type ChatReactionsUpdate } from "../../../../api-client";
 import {
   SAFETY_REFRESH_MS,
   SESSION_RETRY_MS,
@@ -11,6 +11,7 @@ interface ChatControllerRealtimeOptions {
   getUser: () => { emailVerified?: boolean } | null;
   refreshSession: () => Promise<void>;
   handleNotification: (notification: ChatNotification) => void;
+  handleReactions: (update: ChatReactionsUpdate) => void;
   setOnlineCount: (onlineCount: number) => void;
   emit: () => void;
   getSafetyRefreshChannelIds: () => string[];
@@ -23,6 +24,7 @@ export class ChatControllerRealtime {
   private safetyRefreshTimer: ReturnType<typeof setInterval> | null = null;
   private chatNotificationUnsubscribe: (() => void) | null = null;
   private chatPresenceUnsubscribe: (() => void) | null = null;
+  private chatReactionsUnsubscribe: (() => void) | null = null;
 
   constructor(private readonly options: ChatControllerRealtimeOptions) {}
 
@@ -65,6 +67,11 @@ export class ChatControllerRealtime {
         this.options.handleNotification(notification);
       });
     }
+    if (!this.chatReactionsUnsubscribe) {
+      this.chatReactionsUnsubscribe = apiClient.subscribeChatReactions((update) => {
+        this.options.handleReactions(update);
+      });
+    }
     if (!this.chatPresenceUnsubscribe) {
       this.chatPresenceUnsubscribe = apiClient.subscribeChatPresence((onlineCount) => {
         this.options.setOnlineCount(onlineCount);
@@ -78,6 +85,8 @@ export class ChatControllerRealtime {
     this.chatNotificationUnsubscribe = null;
     this.chatPresenceUnsubscribe?.();
     this.chatPresenceUnsubscribe = null;
+    this.chatReactionsUnsubscribe?.();
+    this.chatReactionsUnsubscribe = null;
   }
 
   stopVerificationPolling(): void {

package/src/plugins/builtin/chat/controller/send.ts

@@ -1,5 +1,5 @@
 import type { AppNotificationRequest } from "../../../../types/plugin";
-import type { ChatMessage } from "../../../../api-client";
+import type { ChatAttachment, ChatMessage } from "../../../../api-client";
 import { describeChatSendError } from "../attachments/model";
 import { readyDraftAttachments } from "./attachments";
 import {
@@ -147,6 +147,66 @@ export function sendChatMessageToChannel({
   return true;
 }
 
+/**
+ * Posts a message that carries an image uploaded for it (a pane shared to
+ * chat), without touching the channel's draft. It shows as sending at once,
+ * like a typed message; a failed send stays in the channel to retry, and the
+ * returned promise rejects with the reason.
+ */
+export async function postImageMessageToChannel({
+  channelId,
+  channel,
+  content,
+  attachment,
+  previewUrl,
+  user,
+  getVisibleMessages,
+  nextPendingMessageId,
+  emit,
+  mergeMessages,
+  send,
+}: {
+  channelId: string;
+  channel: ChannelRuntimeState;
+  content: string;
+  attachment: ChatAttachment;
+  /** The local copy to show until the server's answer arrives. */
+  previewUrl: string | null;
+  user: ChatSessionUser;
+  getVisibleMessages: () => ChatMessage[];
+  nextPendingMessageId: () => string;
+  emit: () => void;
+  mergeMessages: (messages: ChatMessage[]) => void;
+  send: (content: string, clientMessageId: string, attachmentIds: string[]) => Promise<ChatMessage>;
+}): Promise<ChatMessage> {
+  const pendingMessage = createPendingMessage({
+    channelId,
+    content: content.trim(),
+    pendingId: nextPendingMessageId(),
+    user,
+    visibleMessages: getVisibleMessages(),
+    attachments: [{ ...attachment, url: previewUrl ?? attachment.url }],
+    clientMessageId: createClientMessageId(),
+  });
+  channel.pendingMessages = [...channel.pendingMessages, pendingMessage];
+  emit();
+  try {
+    const message = await send(pendingMessage.content, pendingMessage.clientMessageId!, [attachment.id]);
+    channel.pendingMessages = channel.pendingMessages.filter((entry) => entry.id !== pendingMessage.id);
+    mergeMessages([message]);
+    return message;
+  } catch (error) {
+    const errorMessage = describeChatSendError(error);
+    channel.pendingMessages = channel.pendingMessages.map((entry) => (
+      entry.id === pendingMessage.id
+        ? { ...entry, clientStatus: "failed", clientError: errorMessage }
+        : entry
+    ));
+    emit();
+    throw new Error(errorMessage);
+  }
+}
+
 /**
  * Sends a failed message again: same text, same images (not uploaded again)
  * and the same idempotency key, so a send that did reach the server is not

package/src/plugins/builtin/chat/controller/state.ts

@@ -92,6 +92,13 @@ export interface ChannelRuntimeState {
    * never be requested again; one uncursored fetch per session repairs it.
    */
   backfilled: boolean;
+  /**
+   * The account that backfill read the channel as (null signed out). Each
+   * message comes back with that reader's own reactions, so a different
+   * reader (a pane that mounted before the session was restored, a sign-in)
+   * reads the latest page again.
+   */
+  backfilledAs: string | null;
   messages: ChatMessage[];
   pendingMessages: ChatMessage[];
   draft: string;
@@ -129,6 +136,7 @@ export function createEmptyChannelState(): ChannelRuntimeState {
     loadOlderMessagesPromise: null,
     reachedOldestMessage: false,
     backfilled: false,
+    backfilledAs: null,
     messages: [],
     pendingMessages: [],
     draft: "",

package/src/plugins/builtin/chat/ghost-user.ts

@@ -8,6 +8,26 @@ export function isDiscordGhost(user: Pick<ChatUserSummary, "accountType"> | null
   return user?.accountType === "discord";
 }
 
+/**
+ * A managed assistant (Gloombot, Gloom Wire, the AI desk personas): an account
+ * Gloom runs, not a person. Wherever it signs a message it carries an AI badge.
+ */
+export function isManagedBot(user: Pick<ChatUserSummary, "accountType"> | null | undefined): boolean {
+  return user?.accountType === "managed_llm";
+}
+
+/**
+ * A reply quotes its author by name only, so whether that author is a managed
+ * assistant comes from the users the pane has seen.
+ */
+export function isQuotedAuthorManagedBot(
+  quoted: { user: { username?: string | null } },
+  userByUsername: ReadonlyMap<string, ChatUserSummary>,
+): boolean {
+  const username = quoted.user.username?.toLowerCase();
+  return !!username && isManagedBot(userByUsername.get(username));
+}
+
 /** The name a message is signed with: the username, or for a ghost that has none the Discord name it carries. */
 export function chatAuthorName(user: Pick<ChatUserSummary, "username" | "displayName" | "accountType">): string {
   return user.username ?? ((isDiscordGhost(user) && user.displayName?.trim()) || "anon");

package/src/plugins/builtin/chat/index.tsx

@@ -3,6 +3,7 @@ import { teamChannelId } from "../cloud/team/model";
 import { teamStore } from "../cloud/team/store";
 import { formatChatPaneTitle } from "./channel-labels";
 import {
+  DEFAULT_CHAT_CHANNEL_ID,
   buildDmCommandResults,
   getPreferredChatOpenChannelId,
   hasOnlyDmUsernameArgs,
@@ -18,6 +19,7 @@ import { ChatPane } from "./pane";
 import { chatSidebarStore } from "./sidebar-store";
 import { ChatStatusWidget } from "./status-widget";
 import { UnreadInboxPane } from "./unread-inbox-pane";
+import { installPaneChatSharing } from "./share/flow";
 import { UNREAD_INBOX_PANE_ID, UNREAD_INBOX_TEMPLATE_ID } from "./unread-inbox";
 
 /**
@@ -37,6 +39,15 @@ async function resolveTypedChannelId(rawArg: string): Promise<string> {
   }
 }
 
+/** A DM, a group or a team channel: what only its members read. */
+function isPrivateConversation(channelId: unknown): boolean {
+  const id = typeof channelId === "string" && channelId.trim() ? channelId.trim() : DEFAULT_CHAT_CHANNEL_ID;
+  const kind = chatController.getChannels().find((channel) => channel.id === id)?.kind;
+  return kind ? kind !== "public" : /^(dm|grp|group|team):/.test(id);
+}
+
+let disposePaneChatSharing: (() => void) | undefined;
+
 export const chatModule: PluginModule = {
   panes: [{
     id: "chat",
@@ -46,18 +57,21 @@ export const chatModule: PluginModule = {
     defaultPosition: "right",
     defaultMode: "floating",
     defaultFloatingSize: { width: 80, height: 30 },
+    personalData: (context) => (isPrivateConversation(context.settings.channelId) ? "messages" : null),
     portableShare: {
       private: { title: true, params: true, settings: true, state: true },
     },
   }, {
     id: UNREAD_INBOX_PANE_ID,
-    reportFreshness: { status: "not-a-feed", basis: "chat messages" },
+    reportFreshness: { status: "not-a-feed", basis: "chat messages and missed alerts" },
     name: "Unread",
+    // Mentions and replies from every conversation, DMs included.
+    personalData: "messages",
     icon: "U",
     component: UnreadInboxPane,
     defaultPosition: "right",
     defaultMode: "floating",
-    defaultFloatingSize: { width: 60, height: 16 },
+    defaultFloatingSize: { width: 88, height: 16 },
   }],
   paneTemplates: [{
     id: "new-chat-pane",
@@ -117,9 +131,9 @@ export const chatModule: PluginModule = {
   }, {
     id: UNREAD_INBOX_TEMPLATE_ID,
     paneId: UNREAD_INBOX_PANE_ID,
-    label: "Unread Chat",
-    description: "Open unread chat messages",
-    keywords: ["unread", "chat", "inbox", "mentions"],
+    label: "Unread",
+    description: "Unread chat, then price alerts, catalysts and team notices you missed",
+    keywords: ["unread", "chat", "inbox", "mentions", "missed", "notifications", "alerts"],
     createInstance: () => ({
       placement: "floating",
       instanceId: "unread-inbox",
@@ -131,6 +145,8 @@ export const chatModule: PluginModule = {
   },
   setup(ctx) {
     ctx.registerCommandBarSearchProvider(createChatSearchProvider(ctx));
+    disposePaneChatSharing?.();
+    disposePaneChatSharing = installPaneChatSharing(ctx);
     chatController.attachPersistence(ctx.persistence, ctx.resume);
     chatSidebarStore.attach(ctx.persistence);
     chatController.setNotifier(ctx.notify, (channelId, messageId) => {
@@ -160,6 +176,8 @@ export const chatModule: PluginModule = {
     });
   },
   dispose() {
+    disposePaneChatSharing?.();
+    disposePaneChatSharing = undefined;
     chatController.dispose();
   },
 };

package/src/plugins/builtin/chat/layout.ts

@@ -9,10 +9,11 @@ import {
   type TickerBadgeStatus,
 } from "../../../components/ticker/badge/format";
 import type { InlineTickerCatalogEntry } from "../../../state/hooks/inline-tickers";
+import { STICKY_BOTTOM_THRESHOLD_PX } from "../../../ui/sticky-scroll";
+import { terminalReactionRows } from "./reactions";
 
 const MESSAGE_GROUP_THRESHOLD_MS = 5 * 60 * 1000;
 const MESSAGE_SELECTION_BOTTOM_INSET = 1;
-const SCROLL_BOTTOM_THRESHOLD_PX = 2;
 
 export const CHAT_COMPOSER_MAX_ROWS = 5;
 export const MESSAGE_ACTION_WIDTH = 9;
@@ -277,7 +278,8 @@ export function estimateMessageHeight(
       ? getMessageBodyTokenLines(message.content, contentLineWidth, catalog).length
       : getMessageBodyLines(message, width, catalog).length;
   const reviewNoteHeight = message.attachmentReview ? 1 : 0;
-  return headerHeight + (message.replyTo ? 1 : 0) + bodyLineCount + imageCount + reviewNoteHeight;
+  const reactionRows = message.reactions?.length ? terminalReactionRows(message.reactions, contentLineWidth).length : 0;
+  return headerHeight + (message.replyTo ? 1 : 0) + bodyLineCount + imageCount + reviewNoteHeight + reactionRows;
 }
 
 export function estimateComposerHeight(text: string, width: number) {
@@ -336,7 +338,7 @@ export function isScrolledToBottom(scrollBox: ScrollBoxRenderable | null, prefer
   const exactPixels = preferPixels && hasPixelScrollMetrics(scrollBox);
   const scrollTop = getScrollTop(scrollBox, exactPixels);
   const maxScrollTop = Math.max(0, getScrollHeight(scrollBox, exactPixels) - getViewportHeight(scrollBox, exactPixels));
-  const threshold = exactPixels ? SCROLL_BOTTOM_THRESHOLD_PX : 0;
+  const threshold = exactPixels ? STICKY_BOTTOM_THRESHOLD_PX : 0;
   return maxScrollTop - scrollTop <= threshold;
 }
 
@@ -354,21 +356,31 @@ function getScrollTopForElementIntoView({
   elementTop,
   elementHeight,
   bottomInset = 0,
+  center = false,
 }: {
   scrollTop: number;
   viewportHeight: number;
   elementTop: number;
   elementHeight: number;
   bottomInset?: number;
+  /** An element out of view is brought to the middle of it, not to the nearest edge. */
+  center?: boolean;
 }) {
   const visibleHeight = Math.max(viewportHeight - bottomInset, 1);
   const elementBottom = elementTop + elementHeight;
-  if (elementTop < scrollTop || elementHeight >= visibleHeight) return elementTop;
+  if (elementHeight >= visibleHeight) return elementTop;
+  const outOfView = elementTop < scrollTop || elementBottom > scrollTop + visibleHeight;
+  if (center && outOfView) return Math.max(0, elementTop - (visibleHeight - elementHeight) / 2);
+  if (elementTop < scrollTop) return elementTop;
   if (elementBottom > scrollTop + visibleHeight) return elementBottom - visibleHeight;
   return scrollTop;
 }
 
-export function scrollElementIntoScrollBoxView(scrollBox: ScrollBoxRenderable | null, node: unknown) {
+export function scrollElementIntoScrollBoxView(
+  scrollBox: ScrollBoxRenderable | null,
+  node: unknown,
+  options: { center?: boolean } = {},
+) {
   const nodeRect = (node as { getBoundingClientRect?: () => { x?: number; y?: number; top?: number; width?: number; height?: number } } | null)
     ?.getBoundingClientRect?.();
   const scrollRect = scrollBox?.getBoundingClientRect?.() as { x?: number; y?: number; top?: number; width?: number; height?: number } | undefined;
@@ -388,6 +400,7 @@ export function scrollElementIntoScrollBoxView(scrollBox: ScrollBoxRenderable |
       viewportHeight: scrollBox.viewportPx.height,
       elementTop,
       elementHeight: Math.max(nodeRect.height ?? 0, 1),
+      center: options.center,
     });
     if (nextScrollTop !== scrollBox.scrollTopPx) {
       scrollBox.scrollToPixels(nextScrollTop);
@@ -401,6 +414,66 @@ export function scrollElementIntoScrollBoxView(scrollBox: ScrollBoxRenderable |
   return true;
 }
 
+/** Where a reader is in the list: at the bottom, or which message is at the top of the view and how far down. */
+export interface ScrollPlace {
+  atBottom: boolean;
+  anchorId: string | null;
+  /** In px from the top of the view to the top of the anchor message. */
+  anchorOffsetPx: number;
+}
+
+function messageRect(node: unknown): { y: number; height: number } | null {
+  const rect = (node as { getBoundingClientRect?: () => { y?: number; top?: number; height?: number } } | null)
+    ?.getBoundingClientRect?.();
+  if (!rect) return null;
+  return { y: rect.y ?? rect.top ?? 0, height: rect.height ?? 0 };
+}
+
+/**
+ * The reader's place in a pixel-scrolled list, to put them back after the list is
+ * rebuilt. Null where the list has no pixel layout.
+ */
+export function readScrollPlace(
+  scrollBox: ScrollBoxRenderable | null,
+  messages: ChatMessage[],
+  elements: Map<string, unknown>,
+): ScrollPlace | null {
+  const view = scrollBox?.getBoundingClientRect?.();
+  if (!scrollBox || !view || !hasPixelScrollMetrics(scrollBox)) return null;
+  if (isScrolledToBottom(scrollBox, true)) return { atBottom: true, anchorId: null, anchorOffsetPx: 0 };
+  // Rows run down the page in order, so the first with any part in view is found by halving.
+  let low = 0;
+  let high = messages.length - 1;
+  let found: { id: string; y: number } | null = null;
+  while (low <= high) {
+    const middle = (low + high) >> 1;
+    const message = messages[middle]!;
+    const rect = messageRect(elements.get(message.id));
+    if (!rect) return null;
+    if (rect.y + rect.height > view.y + 1) {
+      found = { id: message.id, y: rect.y };
+      high = middle - 1;
+    } else {
+      low = middle + 1;
+    }
+  }
+  return found ? { atBottom: false, anchorId: found.id, anchorOffsetPx: found.y - view.y } : null;
+}
+
+export function restoreScrollPlace(
+  scrollBox: ScrollBoxRenderable | null,
+  place: ScrollPlace,
+  elements: Map<string, unknown>,
+) {
+  const view = scrollBox?.getBoundingClientRect?.();
+  const rect = place.anchorId ? messageRect(elements.get(place.anchorId)) : null;
+  if (!scrollBox || !view || place.atBottom || !rect || typeof scrollBox.scrollTopPx !== "number") {
+    scrollToBottom(scrollBox, true);
+    return;
+  }
+  scrollToPosition(scrollBox, scrollBox.scrollTopPx + (rect.y - view.y) - place.anchorOffsetPx, true);
+}
+
 export function getSelectedMessageScrollTop({
   scrollTop,
   viewportHeight,

package/src/plugins/builtin/chat/message/ai-badge.tsx

@@ -0,0 +1,18 @@
+import { Badge } from "../../../../components/ui";
+import { Box } from "../../../../ui";
+
+/** What the badge takes of a terminal line: the cell before it, then "AI" with a cell of padding either side. */
+export const CHAT_AI_BADGE_WIDTH = 5;
+
+/**
+ * "AI" and a cell of space before it, beside the name of a managed assistant.
+ * The neutral badge is the quietest the kit has; a selected row passes its own
+ * text color so the chip stays legible on the selection.
+ */
+export function ChatAiBadge({ selectedColor }: { selectedColor?: string }) {
+  return (
+    <Box flexShrink={0} paddingLeft={1} data-gloom-role="chat-ai-badge">
+      <Badge label="AI" color={selectedColor} />
+    </Box>
+  );
+}