gloomberb 0.18.3 → 0.18.5

package/src/plugins/builtin/chart-composer/use-series-catalog.ts

@@ -1,11 +1,13 @@
-import { useEffect, useMemo, useState, useSyncExternalStore } from "react";
+import { useAsyncResource } from "../../../react/async-resource";
+import { logFailure } from "../../../utils/log-failure";
+import { useCallback, useEffect, useMemo, useState, useSyncExternalStore } from "react";
 import {
   buildTickerSearchCandidates,
   searchTickerCandidates,
 } from "../../../tickers/search";
 import { useOptionalAppSelector } from "../../../state/app/context";
 import type { TickerRecord } from "../../../types/ticker";
-import { searchChartSeriesCapabilities } from "../../../capabilities";
+import { searchChartSeriesCatalogs } from "../../../capabilities/chart-series";
 import { SERIES_CATALOG_CAPABILITY_ID } from "../../../series/capability";
 import type { SeriesCatalogEntry } from "../../../series/types";
 import { getSharedRegistry } from "../../registry";
@@ -83,7 +85,7 @@ function candidateToInstrument(candidate: {
  * folder) are asked for once and listed after the rest; elsewhere, sources
  * that change while the app runs catch up when the catalog opens.
  */
-export function useRegisteredSeries(): readonly SeriesCatalogEntry[] {
+export function useRegisteredSeries() {
   const registry = getSharedRegistry();
   const series = registry?.series;
   const version = useSyncExternalStore(
@@ -92,31 +94,32 @@ export function useRegisteredSeries(): readonly SeriesCatalogEntry[] {
     () => 0,
   );
   const disabledPlugins = useOptionalAppSelector((state) => state.config.disabledPlugins, EMPTY_PLUGINS);
-  const [remote, setRemote] = useState<readonly SeriesCatalogEntry[] | null>(null);
+  const remoteLoader = useMemo(() => registry?.usesRemoteCapabilities && series ? async () => {
+    try {
+      const result = await registry.invokeCapability<{ entries: SeriesCatalogEntry[] }>(SERIES_CATALOG_CAPABILITY_ID, "list", {});
+      if (!Array.isArray(result?.entries)) throw new Error("Invalid series catalog response");
+      return result.entries;
+    } catch (error) {
+      logFailure("chart-composer.use-series-catalog", "Load remote chart series catalog failed")(error);
+      throw new Error("Series catalog unavailable.");
+    }
+  } : null, [registry, series]);
+  const remote = useAsyncResource(remoteLoader);
 
   useEffect(() => {
-    if (!registry || !series) return;
-    if (!registry.usesRemoteCapabilities) {
-      void series.refresh();
-      return;
-    }
-    let cancelled = false;
-    void registry.invokeCapability<{ entries: SeriesCatalogEntry[] }>(SERIES_CATALOG_CAPABILITY_ID, "list", {})
-      .then((result) => {
-        if (!cancelled && Array.isArray(result?.entries)) setRemote(result.entries);
-      })
-      .catch(() => {
-        // The view's own series still list; only the Bun process's extras are missing.
-      });
-    return () => { cancelled = true; };
+    if (registry && series && !registry.usesRemoteCapabilities) void series.refresh();
   }, [registry, series]);
+  const retry = useCallback(async () => {
+    if (remoteLoader) await remote.reload();
+    else await series?.refresh();
+  }, [remoteLoader, remote.reload, series]);
 
-  return useMemo(() => {
+  const entries = useMemo(() => {
     const local = series?.catalog() ?? EMPTY_ENTRIES;
     let entries = local;
-    if (remote?.length) {
+    if (remote.data?.length) {
       const known = new Set(local.map((entry) => entry.id));
-      const extra = remote.filter((entry) => !known.has(entry.id));
+      const extra = remote.data.filter((entry) => !known.has(entry.id));
       if (extra.length) entries = [...local, ...extra];
     }
     if (disabledPlugins.length === 0) return entries;
@@ -124,7 +127,8 @@ export function useRegisteredSeries(): readonly SeriesCatalogEntry[] {
     return entries.some((entry) => disabled.has(entry.pluginId))
       ? entries.filter((entry) => !disabled.has(entry.pluginId))
       : entries;
-  }, [disabledPlugins, remote, series, version]);
+  }, [disabledPlugins, remote.data, series, version]);
+  return { entries, loading: remote.loading, error: remote.error, retry };
 }
 
 export function useCatalogUniverse(query: string): {
@@ -231,6 +235,7 @@ export interface SeriesCatalogSearchResult {
   loading: boolean;
   /** Set when a lookup failed, so an outage is never reported as zero matches. */
   error: string | null;
+  retry: () => Promise<void>;
 }
 
 function searchFailureMessage(error: unknown): string {
@@ -249,6 +254,11 @@ export function useSeriesCatalogSuggestions({
 }): SeriesCatalogSearchResult {
   const tickers = useOptionalAppSelector((state) => state.tickers, EMPTY_TICKERS);
   const registered = useRegisteredSeries();
+  const [attempt, setAttempt] = useState(0);
+  const retry = useCallback(async () => {
+    setAttempt((value) => value + 1);
+    await registered.retry();
+  }, [registered.retry]);
   const analysis = useMemo(() => analyzeSeriesSearchQuery(query), [query]);
   const [providerSearch, setProviderSearch] = useState<{
     query: string;
@@ -274,12 +284,12 @@ export function useSeriesCatalogSuggestions({
     const controller = new AbortController();
     setProviderSearch({ query: normalizedQuery, suggestions: [], loading: true, error: null });
     const timer = setTimeout(() => {
-      void searchChartSeriesCapabilities(registry, normalizedQuery, MAX_SERIES_SUGGESTIONS, controller.signal).then((items) => {
+      void searchChartSeriesCatalogs(registry, normalizedQuery, MAX_SERIES_SUGGESTIONS, controller.signal).then(({ items, errors }) => {
         if (!cancelled) setProviderSearch({
           query: normalizedQuery,
           suggestions: buildCapabilitySeriesSuggestions(items),
           loading: false,
-          error: null,
+          error: errors.join(" ") || null,
         });
       }).catch((error: unknown) => {
         if (controller.signal.aborted || cancelled) return;
@@ -296,7 +306,7 @@ export function useSeriesCatalogSuggestions({
       controller.abort();
       clearTimeout(timer);
     };
-  }, [enabled, query]);
+  }, [attempt, enabled, query]);
 
   useEffect(() => {
     const instrumentQuery = analysis.instrumentQuery.trim();
@@ -345,7 +355,7 @@ export function useSeriesCatalogSuggestions({
       cancelled = true;
       clearTimeout(timer);
     };
-  }, [analysis.directInstrument, analysis.instrumentQuery, enabled, tickers]);
+  }, [analysis.directInstrument, analysis.instrumentQuery, attempt, enabled, tickers]);
 
   const instruments = search.query === analysis.instrumentQuery
     ? search.instruments
@@ -354,18 +364,21 @@ export function useSeriesCatalogSuggestions({
   // and they arrive well before plugin catalogs (which can take seconds), so
   // late plugin results append below instead of pushing the list around.
   const suggestions = useMemo(() => {
-    const builtIn = buildSeriesCatalogSuggestions(query, defaultInstrument, instruments, MAX_SERIES_SUGGESTIONS, registered);
+    const builtIn = buildSeriesCatalogSuggestions(query, defaultInstrument, instruments, MAX_SERIES_SUGGESTIONS, registered.entries);
     const provider = providerSearch.query === query.trim() ? providerSearch.suggestions : [];
     return [...builtIn, ...provider.filter((entry) => !builtIn.some((candidate) => candidate.id === entry.id))]
       .slice(0, MAX_SERIES_SUGGESTIONS);
-  }, [defaultInstrument, instruments, providerSearch, query, registered]);
+  }, [defaultInstrument, instruments, providerSearch, query, registered.entries]);
 
   return {
     suggestions,
     instruments,
-    loading: (search.loading && search.query === analysis.instrumentQuery)
+    retry,
+    loading: registered.loading || (search.loading && search.query === analysis.instrumentQuery)
       || (providerSearch.loading && providerSearch.query === query.trim()),
-    error: (search.query === analysis.instrumentQuery ? search.error : null)
-      ?? (providerSearch.query === query.trim() ? providerSearch.error : null),
+    error: [registered.error,
+      search.query === analysis.instrumentQuery ? search.error : null,
+      providerSearch.query === query.trim() ? providerSearch.error : null,
+    ].filter(Boolean).join(" ") || null,
   };
 }

package/src/plugins/builtin/chart-composer/viewport-labels.ts

@@ -1,6 +1,7 @@
 import type { ChartResolution } from "../../../components/chart/core/types";
+import { chartBarSizeParts, isManualChartResolution, type ManualChartResolution } from "../../../time-series/resolution";
 
-const RESOLUTION_LABELS: Record<ChartResolution, string> = {
+const RESOLUTION_LABELS: Record<ManualChartResolution | "auto", string> = {
   auto: "Auto",
   "1m": "1m",
   "5m": "5m",
@@ -13,7 +14,7 @@ const RESOLUTION_LABELS: Record<ChartResolution, string> = {
   "1mo": "M",
 };
 
-const RESOLUTION_NAMES: Record<Exclude<ChartResolution, "auto">, string> = {
+const RESOLUTION_NAMES: Record<ManualChartResolution, string> = {
   "1m": "1-minute",
   "5m": "5-minute",
   "15m": "15-minute",
@@ -25,19 +26,27 @@ const RESOLUTION_NAMES: Record<Exclude<ChartResolution, "auto">, string> = {
   "1mo": "monthly",
 };
 
+// Months take MO beyond one (3MO), as 3M and 6M are ranges in the same bar.
+const BUILT_UNIT_LABELS = { m: "m", h: "h", d: "D", wk: "W", mo: "MO" } as const;
+const BUILT_UNIT_NAMES = { m: "minute", h: "hour", d: "day", wk: "week", mo: "month" } as const;
+
 /**
  * The one way chart intervals are labelled. Intraday reads in lowercase units
- * (1m, 1h) and daily and longer as D W M, so an interval never collides with
- * a range such as 1M (one month) in the same bar.
+ * (1m, 1h, 4h) and daily and longer as D W M, with a count when there are
+ * several (2D, 2W), so an interval never collides with a range such as 1M
+ * (one month) in the same bar.
  */
 export function formatChartResolution(resolution: ChartResolution): string {
-  return RESOLUTION_LABELS[resolution] ?? resolution;
+  if (resolution === "auto" || isManualChartResolution(resolution)) return RESOLUTION_LABELS[resolution];
+  const parts = chartBarSizeParts(resolution);
+  return parts ? `${parts.count}${BUILT_UNIT_LABELS[parts.unit]}` : resolution;
 }
 
 export function describeChartResolution(resolution: ChartResolution): string {
-  return resolution === "auto"
-    ? "Choose an interval automatically for the active range."
-    : `Use ${RESOLUTION_NAMES[resolution] ?? resolution} observations.`;
+  if (resolution === "auto") return "Choose an interval automatically for the active range.";
+  if (isManualChartResolution(resolution)) return `Use ${RESOLUTION_NAMES[resolution]} observations.`;
+  const parts = chartBarSizeParts(resolution);
+  return parts ? `Use ${parts.count}-${BUILT_UNIT_NAMES[parts.unit]} observations.` : `Use ${resolution} observations.`;
 }
 
 function calendarParts(date: Date, timeZone: string): { key: string; year: number; label: string } {
@@ -72,6 +81,7 @@ export function formatChartDateWindow(
   try {
     new Intl.DateTimeFormat("en-US", { timeZone: zone });
   } catch {
+    // Intentional ignore: unsupported exchange time zones use UTC so the date label remains readable.
     zone = "UTC";
   }
   const first = calendarParts(start, zone);

package/src/plugins/builtin/chat/attachments/model.ts

@@ -1,6 +1,7 @@
 import { ApiRequestError } from "../../../../api-client/errors";
 import type { ChatAttachment, ChatMessage } from "../../../../api-client";
 import { chatPlainText } from "../markdown";
+import { isNetworkFailure } from "../../../../utils/network-failure";
 
 /** What the server takes: four images a message, each up to 5 MB, as PNG, JPEG, WebP or GIF. */
 export const MAX_CHAT_IMAGES = 4;
@@ -152,7 +153,8 @@ export function describeChatImageError(error: unknown, fallback = "The image cou
     if (error.status === 429) return UPLOAD_ERROR_SENTENCES.upload_rate_limited!;
     return fallback;
   }
-  if (error instanceof TypeError) return `${fallback.replace(/\.$/, "")}. Check your connection and try again.`;
+  // No answer at all: a browser's TypeError, or the Cloud client's own word for it.
+  if (error instanceof TypeError || isNetworkFailure(error)) return `${fallback.replace(/\.$/, "")}. Check your connection and try again.`;
   if (error instanceof Error && error.message.trim()) return error.message.trim();
   return fallback;
 }

package/src/plugins/builtin/chat/content/command-suggestions.ts

@@ -0,0 +1,92 @@
+import type { ChatFunction } from "../pane-links/commands";
+
+/** A function offered after a backtick: its code and what it is called. */
+export interface ChatCommandSuggestion {
+  code: string;
+  name: string;
+  takesArg: boolean;
+}
+
+interface ChatCommandTrigger {
+  /** Where the opening backtick is. */
+  start: number;
+  end: number;
+  query: string;
+}
+
+// An opening backtick after a space or punctuation (not inside a word, not a
+// second tick of a fence), then the start of a code.
+const COMMAND_TRIGGER_RE = /(^|[\s([{<,.;:!?"'])`([A-Za-z][A-Za-z0-9+-]{0,11})$/;
+const FENCE_RE = /^\s{0,3}```/;
+const MAX_COMMAND_SUGGESTIONS = 5;
+
+/**
+ * The code being typed after an opening backtick, up to the cursor. A
+ * backtick that closes a span already open on the line, or one inside a
+ * fenced code block, starts no code.
+ */
+export function detectChatCommandTrigger(draft: string, cursorOffset: number): ChatCommandTrigger | null {
+  const cursor = Math.max(0, Math.min(cursorOffset, draft.length));
+  const beforeCursor = draft.slice(0, cursor);
+  const match = beforeCursor.match(COMMAND_TRIGGER_RE);
+  if (!match) return null;
+  const query = match[2]!;
+  const start = cursor - query.length - 1;
+  const lines = draft.slice(0, start).split("\n");
+  const line = lines[lines.length - 1]!;
+  if ((line.match(/`/g)?.length ?? 0) % 2 === 1) return null;
+  if (lines.slice(0, -1).filter((previous) => FENCE_RE.test(previous)).length % 2 === 1) return null;
+  return { start, end: cursor, query };
+}
+
+/**
+ * The functions whose code starts with the query, the exact one and the
+ * shortest first, then those with a word of their name that does, as people
+ * are found by their handle or their name.
+ */
+export function filterCommandSuggestions(
+  functions: ReadonlyMap<string, ChatFunction>,
+  query: string,
+  limit = MAX_COMMAND_SUGGESTIONS,
+): ChatCommandSuggestion[] {
+  const upper = query.trim().toUpperCase();
+  if (!upper) return [];
+  const lower = upper.toLowerCase();
+  const byCode: ChatFunction[] = [];
+  const byName: ChatFunction[] = [];
+  for (const fn of new Set(functions.values())) {
+    if (fn.code.startsWith(upper) || fn.aliases.includes(upper)) byCode.push(fn);
+    else if (fn.name.toLowerCase().split(/[\s/&()-]+/).some((word) => word.startsWith(lower))) byName.push(fn);
+  }
+  const rank = (fn: ChatFunction) => (fn.code === upper || fn.aliases.includes(upper) ? 0 : 1);
+  byCode.sort((a, b) => rank(a) - rank(b) || a.code.length - b.code.length || a.code.localeCompare(b.code));
+  byName.sort((a, b) => a.code.localeCompare(b.code));
+  return [...byCode, ...byName].slice(0, Math.min(limit, MAX_COMMAND_SUGGESTIONS))
+    .map(({ code, name, arg }) => ({ code, name, takesArg: arg !== "none" }));
+}
+
+/**
+ * The code in place of what was typed, with the closing backtick. A function
+ * that takes an argument leaves the cursor before it, after a space, for the
+ * ticker or topic; any other leaves it after the span and a space.
+ */
+export function applyCommandSuggestion(
+  draft: string,
+  trigger: ChatCommandTrigger,
+  suggestion: ChatCommandSuggestion,
+): { draft: string; cursorOffset: number } {
+  const before = draft.slice(0, trigger.start);
+  let after = draft.slice(trigger.end);
+  // A closing backtick already there is the one this span ends with.
+  if (after.startsWith("`")) after = after.slice(1);
+  const code = `\`${suggestion.code}`;
+  if (suggestion.takesArg) {
+    return { draft: `${before}${code} \`${after}`, cursorOffset: before.length + code.length + 1 };
+  }
+  // A space to go on writing after, unless the text there already goes on.
+  const suffix = /^[\s.,;:!?)\]]/.test(after) ? "" : " ";
+  return {
+    draft: `${before}${code}\`${suffix}${after}`,
+    cursorOffset: before.length + code.length + 1 + suffix.length,
+  };
+}

package/src/plugins/builtin/chat/content/composer.tsx

@@ -10,7 +10,6 @@ import { Button, ListView } from "../../../../components/ui";
 import { COMPOSER_ACTION_WIDTH } from "../layout";
 import { isManagedBot } from "../ghost-user";
 import { ChatBotIcon } from "../message/person-icons";
-import type { ChatMentionSuggestion } from "./mentions";
 import type { ChatDraftAttachment } from "../controller/attachments";
 import { DesktopChatAttachButton, DesktopChatAttachmentStrip } from "../attachments/desktop";
 import { TerminalChatAttachmentRows } from "../attachments/terminal";
@@ -48,7 +47,8 @@ interface ChatComposerAreaProps {
   replyPreview: string;
   replyTo: ChatMessage | null;
   sendMessage: () => void;
-  mentionSuggestions: ChatMentionSuggestion[];
+  /** People after @, or functions after a backtick: one list at a time. */
+  suggestions: ChatComposerSuggestion[];
   mentionSelectedIndex: number;
   onMentionCursorChange: () => void;
   onMentionSelect: (index?: number) => boolean;
@@ -69,6 +69,13 @@ interface ChatComposerAreaProps {
   attachPickerRef: { current: (() => void) | null };
 }
 
+/** A row of the list over the composer: a handle, or a function's code with its name at the end. */
+interface ChatComposerSuggestion {
+  id: string;
+  label: string;
+  detail?: string;
+}
+
 function ChatMentionSuggestions({
   contentWidth,
   onSelect,
@@ -78,14 +85,14 @@ function ChatMentionSuggestions({
   contentWidth: number;
   onSelect: (index?: number) => boolean;
   selectedIndex: number;
-  suggestions: ChatMentionSuggestion[];
+  suggestions: ChatComposerSuggestion[];
 }) {
   if (suggestions.length === 0) return null;
   const width = Math.max(18, Math.min(contentWidth, 44));
   return (
     <Box width={width}>
       <ListView
-        items={suggestions.map((suggestion) => ({ id: suggestion.username, label: `@${suggestion.username}` }))}
+        items={suggestions}
         selectedIndex={selectedIndex}
         height={suggestions.length}
         rowGap={0}
@@ -119,7 +126,7 @@ export function ChatComposerArea({
   replyPreview,
   replyTo,
   sendMessage,
-  mentionSuggestions,
+  suggestions,
   mentionSelectedIndex,
   onMentionCursorChange,
   onMentionSelect,
@@ -211,7 +218,7 @@ export function ChatComposerArea({
         contentWidth={contentWidth}
         onSelect={onMentionSelect}
         selectedIndex={mentionSelectedIndex}
-        suggestions={mentionSuggestions}
+        suggestions={suggestions}
       />
 
       {!editingMessage && draftAttachments.length > 0 && (nativePaneChrome ? (

package/src/plugins/builtin/chat/content/footer.tsx

@@ -9,6 +9,7 @@ import { useOptionalDialog, type PromptContext } from "../../../../ui/dialog";
 import { chatAuthorName, isDiscordGhost } from "../ghost-user";
 import { chatMessageOpenTargets, type ChatOpenTarget } from "./open-targets";
 import { chatMessagePaneLinks, type ChatMessagePaneLink } from "../pane-links/model";
+import { useChatFunctions } from "../pane-links/commands";
 import { openChatImageViewer } from "../attachments/desktop";
 import { canReactToMessage } from "../reactions";
 
@@ -102,11 +103,13 @@ export function useChatFooter({
   const rendererHost = useRendererHost();
   const { links: paneLinks, content } = chatMessagePaneLinks(selectedMessage);
   const attachments = selectedMessage?.attachments;
+  const { nativePaneChrome } = useUiCapabilities();
+  const functions = useChatFunctions();
+  // The desktop and the web draw functions written in a message as chips, so Open offers them too.
   const openTargets = useMemo(
-    () => chatMessageOpenTargets(content, catalog, attachments, paneLinks),
-    [attachments, catalog, content, paneLinks],
+    () => chatMessageOpenTargets(content, catalog, attachments, paneLinks, nativePaneChrome ? functions : undefined),
+    [attachments, catalog, content, functions, nativePaneChrome, paneLinks],
   );
-  const { nativePaneChrome } = useUiCapabilities();
 
   const openTarget = useCallback((target: ChatOpenTarget) => {
     if (target.kind === "pane") {

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

@@ -57,6 +57,7 @@ import type { ContextMenuItem } from "../../../../types/context-menu";
 import { usePluginAppActions } from "../../../runtime";
 import { openTeamPane } from "../../../../team/pane-request";
 import { openChatPaneLink } from "../pane-links/open";
+import { runChatCommand, useChatFunctions } from "../pane-links/commands";
 import type { ChatMessagePaneLink } from "../pane-links/model";
 import { splitComposerDraft, type ComposerShareLink } from "../pane-links/composer";
 import { teamStore } from "../../../../team/store";
@@ -71,6 +72,7 @@ import {
   detectChatMentionTrigger,
   filterMentionSuggestions,
 } from "./mentions";
+import { applyCommandSuggestion, detectChatCommandTrigger, filterCommandSuggestions } from "./command-suggestions";
 import { getComposerCursorOffset } from "./composer-cursor";
 import { ChatHandlePrompt, chatHandlePromptRows, handleSavedMessage, useChatHandlePrompt } from "./handle-prompt";
 
@@ -321,12 +323,31 @@ export function ChatContent({
     if (!mentionTrigger || mentionTriggerKey === dismissedMentionKey) return [];
     return filterMentionSuggestions(recentMentionSuggestions, mentionTrigger.query);
   }, [dismissedMentionKey, mentionTrigger, mentionTriggerKey, recentMentionSuggestions]);
-  const mentionSelectedIndexSafe = mentionSuggestions.length > 0
-    ? Math.min(mentionSelectedIndex, mentionSuggestions.length - 1)
+  // Desktop and web: after a backtick the same list offers functions, which a message draws as chips there.
+  const commandTrigger = useMemo(() => (
+    nativePaneChrome && !mentionTrigger ? detectChatCommandTrigger(composerDraft, composerCursorOffset) : null
+  ), [composerCursorOffset, composerDraft, mentionTrigger, nativePaneChrome]);
+  const commandTriggerKey = commandTrigger
+    ? `${channelId}:code:${commandTrigger.start}:${commandTrigger.end}:${commandTrigger.query}`
+    : null;
+  const functions = useChatFunctions();
+  const commandSuggestions = useMemo(() => {
+    if (!commandTrigger || commandTriggerKey === dismissedMentionKey) return [];
+    return filterCommandSuggestions(functions, commandTrigger.query);
+  }, [commandTrigger, commandTriggerKey, dismissedMentionKey, functions]);
+  // One list at a time: people after @, functions after a backtick.
+  const suggestionTriggerKey = mentionTriggerKey ?? commandTriggerKey;
+  const suggestionCount = mentionSuggestions.length + commandSuggestions.length;
+  const composerSuggestions = useMemo(() => mentionSuggestions.length > 0
+    ? mentionSuggestions.map((suggestion) => ({ id: suggestion.username, label: `@${suggestion.username}` }))
+    : commandSuggestions.map((suggestion) => ({ id: suggestion.code, label: suggestion.code, detail: suggestion.name })),
+  [commandSuggestions, mentionSuggestions]);
+  const mentionSelectedIndexSafe = suggestionCount > 0
+    ? Math.min(mentionSelectedIndex, suggestionCount - 1)
     : 0;
   useEffect(() => {
     setMentionSelectedIndex(0);
-  }, [mentionTriggerKey]);
+  }, [suggestionTriggerKey]);
   const {
     composerHeight,
     messageAreaHeight,
@@ -335,7 +356,7 @@ export function ChatContent({
     composerRows,
     editingMessage,
     height,
-    mentionSuggestionCount: mentionSuggestions.length,
+    mentionSuggestionCount: suggestionCount,
     nativePaneChrome,
     replyTo,
     stackHeader: stackedNav && !channelListOpen,
@@ -568,17 +589,18 @@ export function ChatContent({
     if (controller.attachToChannel(channelIdRef.current, files.map(uploadFromTransferFile)) > 0) focusInput();
   }, [canAttach, controller, focusInput, imagesAvailable, notify]);
 
-  // A chip under a message: the shared pane, or the story or calendar a Wire post names.
+  // A chip: the shared pane, the story or calendar a Wire post names, or a function written in a message.
   const openPaneLink = useCallback((link: ChatMessagePaneLink) => {
     openChatPaneLink(link, {
       createPaneFromTemplate,
       notify,
       openExternal: (url) => { void rendererHost.openExternal(url); },
+      runCommand: runChatCommand,
     });
   }, [createPaneFromTemplate, notify, rendererHost]);
 
   const handleDiscordCommand = useCallback((command: DiscordComposerCommand) => {
-    void runDiscordCommand(command, { openUrl: (url) => rendererHost.openExternal(url) }).then(notify);
+    void runDiscordCommand(command, { openUrl: async (url) => { await rendererHost.openExternal(url); } }).then(notify);
   }, [notify, rendererHost]);
 
   // The terminal: a pasted or dropped path to an image file attaches the file
@@ -821,41 +843,48 @@ export function ChatContent({
   }, [directMessageContext, messageUser, selectedMessageAuthor]);
 
   const moveMentionSelection = useCallback((direction: "up" | "down") => {
-    if (mentionSuggestions.length === 0) return false;
+    if (suggestionCount === 0) return false;
     setMentionSelectedIndex((current) => {
-      const safeCurrent = Math.max(0, Math.min(current, mentionSuggestions.length - 1));
+      const safeCurrent = Math.max(0, Math.min(current, suggestionCount - 1));
       if (direction === "up") {
-        return safeCurrent <= 0 ? mentionSuggestions.length - 1 : safeCurrent - 1;
+        return safeCurrent <= 0 ? suggestionCount - 1 : safeCurrent - 1;
       }
-      return safeCurrent >= mentionSuggestions.length - 1 ? 0 : safeCurrent + 1;
+      return safeCurrent >= suggestionCount - 1 ? 0 : safeCurrent + 1;
     });
     return true;
-  }, [mentionSuggestions.length]);
+  }, [suggestionCount]);
 
   const dismissMentionSuggestions = useCallback(() => {
-    if (!mentionTriggerKey || mentionSuggestions.length === 0) return false;
-    setDismissedMentionKey(mentionTriggerKey);
+    if (!suggestionTriggerKey || suggestionCount === 0) return false;
+    setDismissedMentionKey(suggestionTriggerKey);
     return true;
-  }, [mentionSuggestions.length, mentionTriggerKey]);
+  }, [suggestionCount, suggestionTriggerKey]);
 
   const commitMentionSelection = useCallback((index = mentionSelectedIndexSafe) => {
-    if (!mentionTrigger || mentionSuggestions.length === 0) return false;
-    const suggestion = mentionSuggestions[index] ?? mentionSuggestions[0];
-    if (!suggestion) return false;
-    const replacement = applyMentionSuggestion(composerDraft, mentionTrigger, suggestion);
+    let replacement: { draft: string; cursorOffset: number } | null = null;
+    if (mentionTrigger && mentionSuggestions.length > 0) {
+      const suggestion = mentionSuggestions[index] ?? mentionSuggestions[0]!;
+      replacement = applyMentionSuggestion(composerDraft, mentionTrigger, suggestion);
+    } else if (commandTrigger && commandSuggestions.length > 0) {
+      const suggestion = commandSuggestions[index] ?? commandSuggestions[0]!;
+      replacement = applyCommandSuggestion(composerDraft, commandTrigger, suggestion);
+    }
+    if (!replacement) return false;
     replaceComposerDraft(replacement.draft, replacement.cursorOffset);
     setMentionSelectedIndex(0);
-    setDismissedMentionKey(mentionTriggerKey);
+    setDismissedMentionKey(suggestionTriggerKey);
     queueMicrotask(() => focusInput());
     return true;
   }, [
+    commandSuggestions,
+    commandTrigger,
     composerDraft,
     focusInput,
     mentionSelectedIndexSafe,
     mentionSuggestions,
     mentionTrigger,
-    mentionTriggerKey,
     replaceComposerDraft,
+    suggestionTriggerKey,
   ]);
 
   const {
@@ -941,7 +970,7 @@ export function ChatContent({
     inputValueRef,
     loadingOlderMessages,
     messages,
-    mentionMenuOpen: mentionSuggestions.length > 0,
+    mentionMenuOpen: suggestionCount > 0,
     moveMentionSelection,
     dismissMentionSuggestions,
     commitMentionSelection,
@@ -1193,7 +1222,7 @@ export function ChatContent({
         replyPreview={replyPreview}
         replyTo={replyTo}
         sendMessage={sendMessage}
-        mentionSuggestions={mentionSuggestions}
+        suggestions={composerSuggestions}
         mentionSelectedIndex={mentionSelectedIndexSafe}
         onMentionCursorChange={syncComposerCursor}
         onMentionSelect={commitMentionSelection}

package/src/plugins/builtin/chat/content/open-targets.ts

@@ -4,6 +4,7 @@ import { chatMessageTokens } from "../markdown";
 import { chatImageLabel } from "../attachments/model";
 import { wirePaneTarget, type ChatMessagePaneLink } from "../pane-links/model";
 import { chatPaneLinkPane, peekSharePreview } from "../pane-links/previews";
+import { resolveChatCommand, type ChatFunction } from "../pane-links/commands";
 
 export type ChatOpenTarget =
   | { kind: "pane"; link: ChatMessagePaneLink; label: string }
@@ -11,8 +12,9 @@ export type ChatOpenTarget =
   | { kind: "link"; url: string; label: string }
   | { kind: "image"; index: number; url: string; label: string };
 
-/** What the Open list calls a chip: the share's title once read, else its link; a Wire post's pane. */
+/** What the Open list calls a chip: the share's title once read, else its link; a Wire post's pane; a function as written. */
 function paneLinkLabel(link: ChatMessagePaneLink): string {
+  if (link.kind === "command") return link.query;
   if (link.kind === "share") {
     const preview = peekSharePreview(link.id);
     return preview.status === "ready" ? preview.title : link.url;
@@ -27,13 +29,16 @@ function paneLinkLabel(link: ChatMessagePaneLink): string {
  * share links and Wire link open), the ticker badges its text draws (a symbol
  * the catalog does not know stays plain text), its links, then its images.
  * `content` is the text the message draws, without the links its chips stand
- * for. Code is text, so nothing in it is offered.
+ * for. Code is text, so nothing in it is offered, except where `functions` is
+ * given (the desktop and the web): there a function written in backticks is a
+ * chip, offered where the text names it.
  */
 export function chatMessageOpenTargets(
   content: string,
   catalog: Record<string, InlineTickerCatalogEntry>,
   attachments: readonly ChatAttachment[] = [],
   paneLinks: readonly ChatMessagePaneLink[] = [],
+  functions?: ReadonlyMap<string, ChatFunction>,
 ): ChatOpenTarget[] {
   const targets: ChatOpenTarget[] = paneLinks.map((link) => ({ kind: "pane", link, label: paneLinkLabel(link) }));
   const seen = new Set<string>();
@@ -45,7 +50,13 @@ export function chatMessageOpenTargets(
       continue;
     }
     open = null;
-    if (token.kind === "ticker") {
+    const command = functions && token.kind === "text" && token.style?.code ? resolveChatCommand(token.value, functions) : null;
+    if (command) {
+      if (seen.has(`command:${command.query}`)) continue;
+      seen.add(`command:${command.query}`);
+      const link = { kind: "command", query: command.query, name: command.fn.name } as const;
+      targets.push({ kind: "pane", link, label: paneLinkLabel(link) });
+    } else if (token.kind === "ticker") {
       const entry = catalog[token.symbol];
       if (!entry || entry.status === "missing" || seen.has(`ticker:${token.symbol}`)) continue;
       seen.add(`ticker:${token.symbol}`);

package/src/plugins/builtin/chat/controller/session-runtime.ts

@@ -121,7 +121,7 @@ export async function refreshChatControllerSession({
   stopVerificationPolling,
   syncVerificationPolling,
 }: RefreshChatControllerSessionOptions): Promise<void> {
-  session.sessionToken = apiClient.getSessionToken();
+  const cachedToken = session.sessionToken;
   const apiSession = await apiClient.getSession(isCurrent);
   if (!isCurrent()) return;
   if (!apiSession) {
@@ -133,7 +133,9 @@ export async function refreshChatControllerSession({
     // startup from signing the user out.
     if (persistedToken) {
       session.sessionToken = persistedToken;
-      session.user = session.user ?? normalizeSessionUser(apiClient.getCurrentUser());
+      // A failed sign-in can install another token before its user arrives.
+      // Only the credential stored with a cached user can restore that user.
+      session.user = (cachedToken === persistedToken ? session.user : null) ?? normalizeSessionUser(apiClient.getCurrentUser());
       // getSession() clears the API client's cached user when the endpoint
       // answers null. Keep both session views aligned while the protected
       // request validates the preserved native credential.