gloomberb 0.16.3 → 0.16.5

package/src/plugins/builtin/chat/message/header.tsx

@@ -1,6 +1,8 @@
 import { useRef } from "react";
 import { Box, Text, useUiCapabilities, type BoxRenderable } from "../../../../ui";
 import { t } from "../../../../i18n";
+import { displayWidth } from "../../../../utils/format";
+import { chatAuthorName, isDiscordGhost } from "../ghost-user";
 import { Button } from "../../../../components/ui";
 import { MESSAGE_ACTION_WIDTH } from "../layout";
 import type { ChatMessageRenderState } from "./render-state";
@@ -82,7 +84,9 @@ export function ChatMessageHeader({
   /** The terminal sizes the author cell to its label. */
   fitAuthorWidth?: boolean;
 }) {
-  const authorLabel = msg.user.username ?? "anon";
+  const authorLabel = chatAuthorName(msg.user);
+  // A Discord ghost has no Gloom profile to open and no one to message.
+  const hasProfile = !isDiscordGhost(msg.user);
   const { nativeContextMenu } = useUiCapabilities();
   // The card opens beside the name the pointer is on.
   const nameRef = useRef<BoxRenderable | null>(null);
@@ -90,26 +94,31 @@ export function ChatMessageHeader({
     <Box {...rowProps} flexDirection="row" height={1} paddingLeft={1}>
       <Box
         ref={nameRef}
-        width={fitAuthorWidth ? authorLabel.length : undefined}
+        width={fitAuthorWidth ? displayWidth(authorLabel) : undefined}
         height={1}
-        onMouseOver={() => onUserHover(msg.user, nameRef.current)}
-        onMouseMove={() => onUserHover(msg.user, nameRef.current)}
-        onMouseOut={onUserHoverEnd}
-        data-gloom-context-menu-surface="true"
-        onMouseDown={(event: { button?: number; preventDefault?: () => void; stopPropagation?: () => void }) => {
-          event.preventDefault?.();
-          event.stopPropagation?.();
-          // A native menu opens on the right-click's contextmenu event instead.
-          if (event.button === 2 && nativeContextMenu === true) return;
-          onUserActivate?.(msg.user, nameRef.current);
-        }}
-        onContextMenu={(event: { preventDefault?: () => void; stopPropagation?: () => void }) => onUserContextMenu?.(msg.user, event, nameRef.current)}
-        style={{ cursor: "pointer" }}
+        {...(hasProfile
+          ? {
+            onMouseOver: () => onUserHover(msg.user, nameRef.current),
+            onMouseMove: () => onUserHover(msg.user, nameRef.current),
+            onMouseOut: onUserHoverEnd,
+            "data-gloom-context-menu-surface": "true",
+            onMouseDown: (event: { button?: number; preventDefault?: () => void; stopPropagation?: () => void }) => {
+              event.preventDefault?.();
+              event.stopPropagation?.();
+              // A native menu opens on the right-click's contextmenu event instead.
+              if (event.button === 2 && nativeContextMenu === true) return;
+              onUserActivate?.(msg.user, nameRef.current);
+            },
+            onContextMenu: (event: { preventDefault?: () => void; stopPropagation?: () => void }) => onUserContextMenu?.(msg.user, event, nameRef.current),
+            style: { cursor: "pointer" },
+          }
+          : {})}
       >
         <Text fg={state.authorColor} attributes={state.authorAttributes}>
           {authorLabel}
         </Text>
       </Box>
+      {msg.origin === "discord" && <Text fg={state.originTagColor}> Discord</Text>}
       <Text fg={state.headerStatusColor}> {state.headerStatus}</Text>
       {(state.showReplyAction || (state.showRetryAction && actionProps.retryMessage)) && <Text fg={state.headerStatusColor}> </Text>}
       <ChatMessageActions state={state} {...actionProps} />

package/src/plugins/builtin/chat/message/profile-popover.tsx

@@ -5,6 +5,7 @@ import { colors } from "../../../../theme/colors";
 import type { ChatUserSummary, PublicPortfolioAnalytics } from "../../../../api-client";
 import { displayWidth, formatNumber, truncateToDisplayWidth } from "../../../../utils/format";
 import { truncateWithEllipsis } from "../../../../utils/text-wrap";
+import { isDiscordGhost } from "../ghost-user";
 import type { ChatUserAnchor } from "./types";
 
 /**
@@ -24,7 +25,7 @@ function hasPortfolioAnalytics(analytics: PublicPortfolioAnalytics | null | unde
 }
 
 export function hasPublicChatProfileInfo(user: ChatUserSummary): boolean {
-  if (user.profilePublic === false) return false;
+  if (user.profilePublic === false || isDiscordGhost(user)) return false;
   return Boolean(user.bio?.trim() || user.title?.trim() || user.company?.trim() || hasPortfolioAnalytics(user.portfolioAnalytics));
 }
 

package/src/plugins/builtin/chat/message/render-state.ts

@@ -20,6 +20,8 @@ export interface ChatMessageRenderState {
   replyAuthorColor: string;
   headerStatus: string;
   headerStatusColor: string;
+  /** The dim "Discord" tag beside the author of a message that came from Discord. */
+  originTagColor: string;
   authorColor: string;
   authorAttributes: number;
   bodyColor: string;
@@ -82,6 +84,7 @@ export function getChatMessageRenderState({
         : hasFailed
           ? colors.negative
           : colors.textMuted,
+    originTagColor: isSelected ? selectedTextColor : colors.textDim,
     authorColor: isSelected ? selectedTextColor : hasFailed ? colors.negative : colors.positive,
     authorAttributes: (isSending ? TextAttributes.DIM : 0) | TextAttributes.BOLD,
     bodyColor: isSelected ? selectedTextColor : hasFailed ? colors.negative : isSending ? colors.textDim : colors.text,

package/src/plugins/builtin/chat/pane-requests.ts

@@ -0,0 +1,60 @@
+import { useSyncExternalStore } from "react";
+
+/**
+ * Something a Chat pane should do once it has the keyboard, asked for from
+ * outside it: the command bar opens a conversation to write in, or the New DM
+ * dialog. The pane that is focused on that conversation takes it.
+ */
+export type ChatPaneRequest =
+  | { action: "compose"; channelId: string }
+  | { action: "new-dm" };
+
+interface PendingChatPaneRequest {
+  request: ChatPaneRequest;
+  at: number;
+}
+
+/** A request no pane took by then (the pane never opened) must not fire later. */
+const REQUEST_TTL_MS = 10_000;
+
+let pending: PendingChatPaneRequest | null = null;
+const listeners = new Set<() => void>();
+
+function emit(): void {
+  for (const listener of listeners) listener();
+}
+
+export function requestChatPaneAction(request: ChatPaneRequest, now = Date.now()): void {
+  pending = { request, at: now };
+  emit();
+}
+
+/**
+ * Hands the request to the pane on `channelId` and clears it. Null when there
+ * is none for that pane or it went stale.
+ */
+export function takeChatPaneRequest(channelId: string, now = Date.now()): ChatPaneRequest | null {
+  if (!pending) return null;
+  const { request, at } = pending;
+  if (now - at > REQUEST_TTL_MS) {
+    pending = null;
+    emit();
+    return null;
+  }
+  if (request.action === "compose" && request.channelId !== channelId) return null;
+  pending = null;
+  emit();
+  return request;
+}
+
+function subscribe(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+
+/** The request waiting for a pane, so a pane can take it once it has the keyboard. */
+export function usePendingChatPaneRequest(): ChatPaneRequest | null {
+  return useSyncExternalStore(subscribe, () => pending?.request ?? null);
+}

package/src/plugins/builtin/chat/pane-state.ts

@@ -1,6 +1,6 @@
 import { updatePaneInstance } from "../../../pane-settings";
-import { removePane } from "../../../layout/pane-manager";
-import type { AppConfig } from "../../../types/config";
+import { isPaneInLayout, removePane } from "../../../layout/pane-manager";
+import type { AppConfig, LayoutConfig, PaneInstanceConfig } from "../../../types/config";
 import { LAST_VISITED_CHAT_CHANNEL_KEY, normalizeChannelId } from "./channels";
 
 type ChatPaneSettings = Record<string, unknown>;
@@ -32,6 +32,36 @@ export function clearChatPaneTargetMessage(
   return nextSettings;
 }
 
+function paneChannelId(instance: PaneInstanceConfig): string | null {
+  return typeof instance.settings?.channelId === "string" ? normalizeChannelId(instance.settings.channelId) : null;
+}
+
+/**
+ * The Chat pane the command bar shows a conversation in: the one already on
+ * it, else the focused one, else the one in front. Null when none is open, so
+ * the caller opens one.
+ */
+export function pickChatPaneToReuse(
+  layout: LayoutConfig,
+  focusedPaneId: string | null,
+  channelId: string | null,
+): PaneInstanceConfig | null {
+  const chatPanes = layout.instances.filter((instance) => (
+    instance.paneId === "chat" && isPaneInLayout(layout, instance.instanceId)
+  ));
+  if (chatPanes.length === 0) return null;
+  const onChannel = channelId ? chatPanes.find((instance) => paneChannelId(instance) === channelId) : undefined;
+  if (onChannel) return onChannel;
+  const focused = chatPanes.find((instance) => instance.instanceId === focusedPaneId);
+  if (focused) return focused;
+  // A floating pane without a stacking order sits at the default of 50; docked panes sit below every one.
+  const zIndexOf = (instance: PaneInstanceConfig) => {
+    const entry = layout.floating.find((floating) => floating.instanceId === instance.instanceId);
+    return entry ? entry.zIndex ?? 50 : -1;
+  };
+  return [...chatPanes].sort((left, right) => zIndexOf(right) - zIndexOf(left))[0] ?? null;
+}
+
 function setChatPaneJump(
   settings: ChatPaneSettings | undefined,
   channelId: string,

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

@@ -77,6 +77,14 @@ export function ChatPane({ focused, width, height }: PaneProps) {
   }, [dispatch, paneId, stateRef]);
   const [channelId, setLocalChannelId] = useState(initialChannelIdRef.current);
   const pendingChannelIdRef = useRef<string | null>(null);
+  // A channel set from outside the pane (the command bar, the unread list)
+  // usually arrives with focus. Taking it in the same render keeps the pane
+  // from showing the old channel focused for a frame, which marks it read.
+  const [followedChannelId, setFollowedChannelId] = useState(persistedChannelId);
+  if (followedChannelId !== persistedChannelId) {
+    setFollowedChannelId(persistedChannelId);
+    if (!pendingChannelIdRef.current && channelId !== persistedChannelId) setLocalChannelId(persistedChannelId);
+  }
 
   useEffect(() => {
     if (rawPaneChannelId) return;

package/src/plugins/builtin/cloud/askg/controller.ts

@@ -4,22 +4,28 @@ import {
   type ASKGToolResultOutcome,
   type ASKGTransport,
 } from "../../../../api-client/askg";
-import type { ASKGToolExecutor } from "./executor";
+import { toolCallRemainingMs, type ASKGToolExecutor, type ASKGToolPreview } from "./executor";
 import {
   activeTurn,
   askgReducer,
+  canRateTurn,
   EMPTY_ASKG_CONVERSATION,
   isTurnRunning,
+  NOT_APPROVED_IN_TIME_NOTE,
   requiresLocalConfirmation,
   type ASKGAction,
   type ASKGConversationState,
   type ASKGErrorState,
+  type ASKGTurnFeedback,
 } from "./model";
 import {
   ASKG_CLIENT_CAPABILITIES,
   ASKG_PROTOCOL_VERSION,
   type ASKGCapabilities,
   type ASKGClientDescriptor,
+  type ASKGFeedbackRating,
+  type ASKGFeedbackReason,
+  type ASKGFeedbackRequest,
   type ASKGSessionContext,
   type ASKGSessionStartResponse,
   type ASKGSseEvent,
@@ -37,6 +43,18 @@ const MAX_HISTORY_TURNS = 8;
 const DEFAULT_TURN_WALL_CLOCK_MS = 120_000;
 /** Sessions are renegotiated a little before they expire. */
 const SESSION_EXPIRY_GRACE_MS = 5_000;
+/**
+ * A confirmation prompt closes this long before the server stops waiting for
+ * its call, so an approval still leaves time for the write and its result.
+ */
+export const CONFIRMATION_CLOSE_MARGIN_MS = 2_000;
+
+/**
+ * How a confirmation prompt ended. `expired` is this app's own deadline for
+ * the call; `abandoned` is the turn giving up on it (the call timed out on the
+ * server, the turn ended, was cancelled or lost its stream).
+ */
+type ConfirmationAnswer = "approved" | "declined" | "expired" | "abandoned";
 
 export interface ASKGControllerManifest {
   tools: ClientToolManifest[];
@@ -104,6 +122,16 @@ function turnCapabilities(session: ASKGSessionStartResponse): ASKGCapabilities |
   return session.capabilities?.scripts === 1 ? { scripts: 1 } : null;
 }
 
+/**
+ * Refusals that say ratings cannot work from here at all: signed out, no plan
+ * that reaches Ask Gloom, or a protocol this build does not speak. The control
+ * goes away rather than failing on every click.
+ */
+function feedbackUnavailable(error: unknown): boolean {
+  return error instanceof ASKGTransportError
+    && (error.code === "unauthorized" || error.code === "tier_required" || error.code === "protocol");
+}
+
 function errorState(error: unknown): ASKGErrorState {
   if (error instanceof ASKGTransportError) {
     return {
@@ -131,11 +159,13 @@ export class ASKGSessionController {
   private session: ASKGSessionStartResponse | null = null;
   private sessionRequest: Promise<ASKGSessionStartResponse> | null = null;
   private manifest: ASKGControllerManifest | null = null;
-  private readonly confirmations = new Map<string, (approved: boolean) => void>();
-  /** Calls whose turn ended while they were still waiting to be approved. */
-  private readonly abandonedCalls = new Set<string>();
+  private readonly confirmations = new Map<string, (answer: ConfirmationAnswer) => void>();
   private readonly toolTasks = new Set<Promise<void>>();
   private turnAbort: AbortController | null = null;
+  /** Ratings of one answer go out in the order they were made. */
+  private readonly feedbackQueues = new Map<string, Promise<void>>();
+  /** The latest rating request per answer; an older answer never wins. */
+  private readonly feedbackVersions = new Map<string, number>();
   private disposed = false;
   private readonly now: () => number;
   private readonly createId: () => string;
@@ -188,6 +218,7 @@ export class ASKGSessionController {
         model: session.model,
         limits: session.limits,
         acceptedTools: session.acceptedTools,
+        feedback: session.capabilities?.feedback === 1,
       });
       return session;
     })();
@@ -266,6 +297,8 @@ export class ASKGSessionController {
         signal: abort.signal,
         onEvent: (event) => this.handleEvent(event),
       });
+      // The stream is over, so no approval can reach this turn any more.
+      this.abandonPendingConfirmations();
       // Tool calls delivered late in the stream may still be running.
       await Promise.allSettled([...this.toolTasks]);
     } catch (error) {
@@ -311,14 +344,14 @@ export class ASKGSessionController {
   }
 
   /**
-   * Asks a failed question again. The failed turn is dropped rather than kept
-   * above the retry, so a transcript reads as the conversation the user had
-   * rather than as a list of attempts.
+   * Asks a failed or stopped question again. The attempt is dropped rather
+   * than kept above the retry, so a transcript reads as the conversation the
+   * user had rather than as a list of attempts.
    */
   async retryTurn(turnId: string): Promise<void> {
     if (this.disposed || isTurnRunning(this.state)) return;
     const turn = this.state.turns.find((entry) => entry.id === turnId);
-    if (!turn || turn.status !== "error") return;
+    if (!turn || (turn.status !== "error" && turn.status !== "cancelled")) return;
     this.dispatch({ type: "drop-turn", turnId });
     await this.ask(turn.prompt);
   }
@@ -330,6 +363,13 @@ export class ASKGSessionController {
       this.abandonPendingConfirmations();
       return;
     }
+    // The server reports a delegated call it gave up on (timed out, or its
+    // script ended) like one it got a result for. A prompt still open for it
+    // closes: an approval could no longer reach the turn.
+    if (event.type === "tool-executed") {
+      this.settleConfirmation(event.toolCallId, "abandoned");
+      return;
+    }
     if (event.type !== "tool-call") return;
     const task = this.runToolCall(event).finally(() => {
       this.toolTasks.delete(task);
@@ -364,12 +404,43 @@ export class ASKGSessionController {
 
     try {
       let confirmed = false;
+      let confirmedChange: string | undefined;
       if (requiresLocalConfirmation(call)) {
-        this.dispatch({ type: "tool-awaiting-confirmation", toolCallId: call.toolCallId });
-        confirmed = await new Promise<boolean>((resolve) => {
-          this.confirmations.set(call.toolCallId, resolve);
-        });
-        if (this.abandonedCalls.delete(call.toolCallId)) return;
+        const preview = await this.previewCall(call, signal);
+        // The turn ended or moved on while the app looked.
+        if (signal?.aborted || this.toolRowStatus(call.toolCallId) !== "pending") return;
+        if (preview?.kind === "refusal") {
+          await this.deliver(failure(preview.message));
+          return;
+        }
+        if (preview?.kind === "change") confirmedChange = preview.confirmKey;
+        // Nothing to approve: the operation re-checks and asks in the app itself if that changed.
+        if (preview?.kind === "no-change") {
+          confirmed = true;
+        } else {
+          this.dispatch({
+            type: "tool-awaiting-confirmation",
+            toolCallId: call.toolCallId,
+            ...(preview?.kind === "change" ? { preview: preview.summary } : {}),
+          });
+          const answer = await this.awaitConfirmation(
+            call.toolCallId,
+            startedAt + toolCallRemainingMs(call, startedAt),
+          );
+          if (answer === "abandoned") return;
+          if (answer === "expired") {
+            await this.deliver({
+              turnId: call.turnId,
+              toolCallId: call.toolCallId,
+              status: "timeout",
+              truncated: false,
+              elapsedMs: Math.max(0, this.now() - startedAt),
+              note: NOT_APPROVED_IN_TIME_NOTE,
+            });
+            return;
+          }
+          confirmed = answer === "approved";
+        }
         if (!confirmed) {
           await this.deliver({
             turnId: call.turnId,
@@ -393,6 +464,7 @@ export class ASKGSessionController {
       }
       const payload = await executor.execute(call, {
         confirmed: confirmed || !requiresLocalConfirmation(call),
+        ...(confirmedChange ? { confirmedChange } : {}),
         ...(signal ? { signal } : {}),
       });
       await this.deliver(payload);
@@ -405,6 +477,28 @@ export class ASKGSessionController {
     }
   }
 
+  /**
+   * The operation's own account of a call that needs approval, when it has
+   * one. Null keeps the server's description.
+   */
+  private async previewCall(call: ASKGToolCallEvent, signal?: AbortSignal): Promise<ASKGToolPreview | null> {
+    try {
+      const manifest = this.manifest ?? await this.options.loadManifest();
+      this.manifest = manifest;
+      return await this.options.getExecutor(manifest)?.preview?.(call, signal) ?? null;
+    } catch {
+      return null;
+    }
+  }
+
+  private toolRowStatus(toolCallId: string): string | undefined {
+    for (const turn of this.state.turns) {
+      const row = turn.tools.find((entry) => entry.toolCallId === toolCallId);
+      if (row) return row.status;
+    }
+    return undefined;
+  }
+
   /** Records a tool result locally, then posts it to the turn loop. */
   private async deliver(payload: ToolResultPayload): Promise<void> {
     this.dispatch({ type: "tool-result", payload });
@@ -424,25 +518,131 @@ export class ASKGSessionController {
     }
   }
 
-  /** Answers a `user-data` or `broker` confirmation prompt. */
-  resolveConfirmation(toolCallId: string, approved: boolean): void {
+  /**
+   * Waits for the person's answer to one call. The prompt closes on its own
+   * a little before the server stops waiting (`deadlineAt`, by this clock),
+   * so an approval always has time to land; an older server that waits less
+   * than the call declared says so in the frame, and is honoured the same way.
+   */
+  private awaitConfirmation(toolCallId: string, deadlineAt: number): Promise<ConfirmationAnswer> {
+    return new Promise<ConfirmationAnswer>((resolve) => {
+      const timer = setTimeout(
+        () => this.settleConfirmation(toolCallId, "expired"),
+        Math.max(0, deadlineAt - CONFIRMATION_CLOSE_MARGIN_MS - this.now()),
+      );
+      this.confirmations.set(toolCallId, (answer) => {
+        clearTimeout(timer);
+        resolve(answer);
+      });
+    });
+  }
+
+  /** Ends one prompt. Only the first answer counts; a later one does nothing. */
+  private settleConfirmation(toolCallId: string, answer: ConfirmationAnswer): void {
     const resolve = this.confirmations.get(toolCallId);
     if (!resolve) return;
     this.confirmations.delete(toolCallId);
-    resolve(approved);
+    resolve(answer);
   }
 
-  private rejectPendingConfirmations(): void {
-    for (const [toolCallId, resolve] of [...this.confirmations]) {
-      this.confirmations.delete(toolCallId);
-      resolve(false);
-    }
+  /** Answers a `user-data` or `broker` confirmation prompt. */
+  resolveConfirmation(toolCallId: string, approved: boolean): void {
+    this.settleConfirmation(toolCallId, approved ? "approved" : "declined");
   }
 
   /** Drops confirmations whose answer can no longer reach the turn. */
   private abandonPendingConfirmations(): void {
-    for (const toolCallId of this.confirmations.keys()) this.abandonedCalls.add(toolCallId);
-    this.rejectPendingConfirmations();
+    for (const toolCallId of [...this.confirmations.keys()]) {
+      this.settleConfirmation(toolCallId, "abandoned");
+    }
+  }
+
+  /**
+   * Rates one answer. The control shows the choice at once; a refusal puts the
+   * previous one back without a word, because a rating is not worth an error.
+   * A thumbs down keeps the reason it already had, a thumbs up drops it.
+   */
+  rateAnswer(turnId: string, rating: ASKGFeedbackRating): Promise<void> {
+    const current = this.state.turns.find((turn) => turn.id === turnId)?.feedback;
+    const reason = rating === "down" && current?.rating === "down" ? current.reason : null;
+    return this.sendFeedback(turnId, { rating, reason }, {
+      rating,
+      reason,
+      shared: current?.shared ?? false,
+      pending: "rating",
+    });
+  }
+
+  /** Says why an answer got a thumbs down. */
+  chooseFeedbackReason(turnId: string, reason: ASKGFeedbackReason): Promise<void> {
+    const current = this.state.turns.find((turn) => turn.id === turnId)?.feedback;
+    return this.sendFeedback(turnId, { rating: "down", reason }, {
+      rating: "down",
+      reason,
+      shared: current?.shared ?? false,
+      pending: "rating",
+    });
+  }
+
+  /**
+   * Sends one answer to Gloom with its rating. Only the consent travels: the
+   * platform copies the question, the answer and which tools ran from its own
+   * transcript, so nothing else on this machine can go with it.
+   */
+  shareAnswer(turnId: string): Promise<void> {
+    const current = this.state.turns.find((turn) => turn.id === turnId)?.feedback;
+    if (!current?.rating || current.shared) return Promise.resolve();
+    return this.sendFeedback(
+      turnId,
+      { rating: current.rating, reason: current.reason, share: true },
+      { rating: current.rating, reason: current.reason, shared: false, pending: "share" },
+    );
+  }
+
+  private sendFeedback(
+    turnId: string,
+    request: ASKGFeedbackRequest,
+    optimistic: ASKGTurnFeedback,
+  ): Promise<void> {
+    const turn = this.state.turns.find((entry) => entry.id === turnId);
+    if (this.disposed || !turn || !canRateTurn(this.state, turn) || !turn.remoteTurnId) {
+      return Promise.resolve();
+    }
+    const remoteTurnId = turn.remoteTurnId;
+    const previous = turn.feedback ? { ...turn.feedback, pending: null } : null;
+    const version = (this.feedbackVersions.get(turnId) ?? 0) + 1;
+    this.feedbackVersions.set(turnId, version);
+    this.dispatch({ type: "feedback", turnId, feedback: optimistic });
+
+    const send = async () => {
+      const latest = () => this.feedbackVersions.get(turnId) === version;
+      try {
+        const stored = await this.options.transport.sendFeedback(remoteTurnId, request);
+        if (!latest()) return;
+        if (!stored) {
+          // No answer of this person's under that id: nothing here can rate it.
+          this.dispatch({ type: "feedback", turnId, feedback: previous });
+          this.dispatch({ type: "feedback-unavailable" });
+          return;
+        }
+        this.dispatch({
+          type: "feedback",
+          turnId,
+          feedback: {
+            ...stored,
+            pending: null,
+            ...(request.share && !stored.shared ? { shareFailed: true } : {}),
+          },
+        });
+      } catch (error) {
+        if (!latest()) return;
+        this.dispatch({ type: "feedback", turnId, feedback: previous });
+        if (feedbackUnavailable(error)) this.dispatch({ type: "feedback-unavailable" });
+      }
+    };
+    const queued = (this.feedbackQueues.get(turnId) ?? Promise.resolve()).then(send);
+    this.feedbackQueues.set(turnId, queued);
+    return queued;
   }
 
   setExpanded(toolCallId: string, expanded: boolean): void {

package/src/plugins/builtin/cloud/askg/conversation-store.ts

@@ -46,6 +46,7 @@ export class ASKGConversationListStore {
   private persistence: PluginPersistence | null = null;
   private transport: ASKGTransport | null = null;
   private inFlight: Promise<void> | null = null;
+  private openConversationId: string | null = null;
 
   getSnapshot(): ASKGConversationListSnapshot {
     return this.snapshot;
@@ -126,6 +127,7 @@ export class ASKGConversationListStore {
   async delete(id: string): Promise<void> {
     const transport = this.transport;
     if (!transport) return;
+    if (this.openConversationId === id) this.openConversationId = null;
     const previous = this.snapshot.conversations;
     this.remove(id);
     try {
@@ -178,11 +180,30 @@ export class ASKGConversationListStore {
     this.persistence?.setState(WIDTH_STATE_KEY, width);
   }
 
+  /**
+   * The conversation an Ask Gloom pane last showed. Closing the pane (Esc Esc
+   * is two keys) must not lose the answer on screen, so the next pane this
+   * app session opens picks it up again. Kept in memory only: a fresh launch
+   * starts a fresh conversation, and every older one is in the list.
+   */
+  rememberOpen(id: string | null): void {
+    this.openConversationId = id;
+  }
+
+  rememberedOpen(): string | null {
+    const id = this.openConversationId;
+    if (!id) return null;
+    // A conversation deleted since is not brought back.
+    if (this.snapshot.loaded && !this.snapshot.conversations.some((conversation) => conversation.id === id)) return null;
+    return id;
+  }
+
   /** Test hook: drops the persisted handle, the transport and the rows. */
   reset(): void {
     this.persistence = null;
     this.transport = null;
     this.inFlight = null;
+    this.openConversationId = null;
     this.snapshot = EMPTY;
   }