gloomberb 0.19.0 → 0.19.2

package/src/cli/quote-answer.ts

@@ -21,6 +21,8 @@ import {
   notTradedMessage,
   oneWordCompanyName,
   quoteBareListing,
+  serviceNamedCompany,
+  type ListingArg,
   requireCliListing,
   resolveCliListing,
   tradingBoardNote,
@@ -64,7 +66,9 @@ export interface QuoteAnswer {
 /**
  * One symbol's row of `quote` and `compare`. A listing on an exchange its symbol
  * is not listed on says so. A bare symbol the data service read on its home
- * listing abroad names that venue (SXR8 -> XETRA). One no source quotes is
+ * listing abroad names that venue (SXR8 -> XETRA). One no source quotes that
+ * the service marks as another listing's company name is that company
+ * (`serviceNamedCompany`: "siemens" is SIE:XETRA); else it is
  * quoted on its listings (`quoteBareListing`), else names them, or asks for an
  * exchange when several companies list it (2222); a bare index root (VIX) also
  * names its index (^VIX), and a futures board code a security keeps (GC) its
@@ -98,6 +102,10 @@ export async function answerQuote(
   const notTraded = await notTradedMessage(listing, market);
   if (notTraded) return { result, listing, failure: { message: notTraded, oneLine: notTraded }, notes: [] };
   if (!isNoProviderError(result.error)) return { result, listing, notes: [] };
+  // A word the service marks as a company's name is that company, before the symbol is read on its listings abroad.
+  const named = !listing.exchange && listing.typed ? await serviceNamedCompany(listing.typed, market) : null;
+  const meant = named ? await answerNamedListing(named, market, request, refresh, datesChangeBasis) : null;
+  if (meant) return meant;
   const other = await quoteBareListing(listing, market, request, { refresh, datesChangeBasis });
   if (other?.kind === "quoted") {
     return {
@@ -155,17 +163,32 @@ async function answerCompanyName(
   const named = await oneWordCompanyName(listing.typed, market);
   // A real ticker a source failed to quote is not a company's name, even when the company carries the word.
   if (!named || (unsettled && named.symbol.toUpperCase() === listing.symbol.toUpperCase())) return null;
-  // A listing on a venue the app cannot read is no answer: the word keeps its own "Not a ticker".
+  const answer = await answerNamedListing(named, market, request, refresh, datesChangeBasis);
+  if (answer) return answer;
+  if (!unsettled) return null;
+  const sentence = await notATickerWords(listing.typed, market);
+  return { result: { ...result, error: new Error(sentence) }, listing, notes: [] };
+}
+
+/**
+ * The row of the listing a company's name was read as (`named`), saying so;
+ * null when the app cannot read its venue or it has no quote.
+ */
+async function answerNamedListing(
+  named: ListingArg,
+  market: MarketContext,
+  request: ListingDataRequest,
+  refresh: boolean,
+  datesChangeBasis: boolean,
+): Promise<QuoteAnswer | null> {
+  // A listing on a venue the app cannot read is no answer: the word keeps its own.
   const resolved = await resolveCliListing(named.key, null, market).catch((error: unknown) => {
     if (error instanceof ListingArgError) return null;
     throw error;
   });
-  const found = resolved ? { ...resolved, readAs: named.readAs, ...named.meant ? { meant: named.meant } : {} } : null;
+  const found = resolved ? { ...resolved, readAs: named.readAs, ...named.meant ? { meant: named.meant } : {}, ...named.readFromName ? { readFromName: named.readFromName } : {} } : null;
   const [quoted] = found ? await market.dataProvider.getQuotesBatch([found.request], { forceRefresh: refresh, revalidate: true, datesChangeBasis }) : [];
-  if (found && quoted?.quote) return answerQuote(quoted, found, market, request, refresh, null, { datesChangeBasis });
-  if (!unsettled) return null;
-  const sentence = await notATickerWords(listing.typed, market);
-  return { result: { ...result, error: new Error(sentence) }, listing, notes: [] };
+  return found && quoted?.quote ? answerQuote(quoted, found, market, request, refresh, null, { datesChangeBasis }) : null;
 }
 
 /** A listing a command found a quote for, with what `quote` says beside it. */

package/src/cli/saved-copy-persistence.ts

@@ -0,0 +1,88 @@
+import type { AppResourceStorePort } from "../core/app-service-ports";
+import type { JsonValue } from "../data/sqlite/json";
+import type { PersistedResourceValue } from "../types/persistence";
+import type { PluginPersistence } from "../types/plugin";
+import { logFailure } from "../utils/log-failure";
+
+type SetResourceOptions = Parameters<PluginPersistence["setResource"]>[3];
+
+/**
+ * A plugin's persistence in a command: what the command fetches through a
+ * plugin's cache is saved in the profile, under the namespace the app keeps
+ * it in (`plugin:<state id>`), so a later run whose refresh fails answers
+ * from that saved copy as the app does. Only a read that may take an expired
+ * copy (`allowExpired`, what a cache falls back to when its refresh fails)
+ * reaches the saved copies; any other read sees only what this run fetched,
+ * so a command still asks for current data rather than answering from the
+ * app's cache. Plugin state is not read or kept. With no resource store,
+ * nothing outlives the run.
+ *
+ * The profile's store closes when the command ends, while a plugin may keep
+ * the persistence it was set up with: `release()` leaves the store alone from
+ * then on, and a store that fails (closed, full) costs the saved copy only,
+ * never the command.
+ */
+export function createCommandPluginPersistence(
+  resources: AppResourceStorePort | null | undefined,
+  namespace: string,
+): PluginPersistence & { release(): void } {
+  const fetched = new Map<string, PersistedResourceValue<unknown>>();
+  const keyOf = (kind: string, key: string) => `${kind}:${key}`;
+  let store = resources ?? null;
+  const saved = <T>(operation: string, run: (store: AppResourceStorePort) => T, fallback: T): T => {
+    if (!store) return fallback;
+    try {
+      return run(store);
+    } catch (error) {
+      return logFailure("cli.saved-copies", `${operation} a saved copy failed`, fallback)(error);
+    }
+  };
+  return {
+    release: () => { store = null; },
+    getState: () => null,
+    setState: () => {},
+    deleteState: () => {},
+    getResource: <T = unknown>(kind: string, key: string, options?: { sourceKey?: string; schemaVersion?: number; allowExpired?: boolean }) => {
+      const own = fetched.get(keyOf(kind, key)) as PersistedResourceValue<T> | undefined;
+      if (own || !options?.allowExpired) return own ?? null;
+      const record = saved("Reading", (resources) => resources.get<T>(
+        { namespace, kind, entityKey: key, sourceKey: options.sourceKey },
+        { schemaVersion: options.schemaVersion, allowExpired: true },
+      ), null);
+      return record && {
+        value: record.value,
+        fetchedAt: record.fetchedAt,
+        staleAt: record.staleAt,
+        expiresAt: record.expiresAt,
+        sourceKey: record.sourceKey,
+        schemaVersion: record.schemaVersion,
+        provenance: record.provenance,
+        stale: record.stale,
+        expired: record.expired,
+      };
+    },
+    setResource: <T = unknown>(kind: string, key: string, value: T, options: SetResourceOptions) => {
+      const fetchedAt = Date.now();
+      const entry: PersistedResourceValue<T> = {
+        value,
+        fetchedAt,
+        staleAt: fetchedAt + options.cachePolicy.staleMs,
+        expiresAt: fetchedAt + options.cachePolicy.expireMs,
+        sourceKey: options.sourceKey ?? "",
+        schemaVersion: options.schemaVersion ?? 1,
+        provenance: options.provenance ?? null,
+      };
+      fetched.set(keyOf(kind, key), entry);
+      saved("Writing", (resources) => resources.set<T>({ namespace, kind, entityKey: key, sourceKey: options.sourceKey }, value, {
+        cachePolicy: options.cachePolicy,
+        schemaVersion: options.schemaVersion,
+        provenance: options.provenance as JsonValue | null | undefined,
+      }), undefined);
+      return entry;
+    },
+    deleteResource: (kind: string, key: string, options?: { sourceKey?: string }) => {
+      fetched.delete(keyOf(kind, key));
+      saved("Deleting", (resources) => resources.delete({ namespace, kind, entityKey: key, sourceKey: options?.sourceKey }), undefined);
+    },
+  };
+}

package/src/components/command-bar/list/model.ts

@@ -73,6 +73,11 @@ export interface ResultItem {
   action: () => void | Promise<void>;
 }
 
+/** A row plain Enter can run, so the untouched selection may rest on it. */
+export function isDefaultSelectable(item: ResultItem): boolean {
+  return item.disabled !== true && item.defaultSelectable !== false;
+}
+
 type ListScreenKind = "root" | "mode" | "picker";
 
 export interface ListScreenState {

package/src/components/command-bar/routes/root/runtime.ts

@@ -7,7 +7,7 @@ import type { TickerRecord } from "../../../../types/ticker";
 import { listingChoiceQuery, symbolSearchQuery, type TickerSearchCandidate } from "../../../../tickers/search";
 import type { AssistRowHandlers } from "../../assist/model";
 import { matchPrefix, type Command } from "../../commands/registry";
-import type { ResultItem } from "../../list/model";
+import { isDefaultSelectable, type ResultItem } from "../../list/model";
 import type { CommandBarCategoryPriorities } from "../../view-model";
 import type { CommandBarRoute } from "../../workflow/types";
 import { normalizeCommandTickerSearchText, readRootTickerQuery } from "../ticker-search/results";
@@ -20,11 +20,6 @@ import { buildRootShortcutFeedback } from "./shortcut-feedback";
 import type { ShortcutIntent } from "./shortcuts";
 import { clampIndex } from "../../../../utils/math";
 
-/** A row plain Enter can run, so the untouched selection may rest on it. */
-function isDefaultSelectable(item: ResultItem): boolean {
-  return item.disabled !== true && item.defaultSelectable !== false;
-}
-
 interface UseCommandBarRootRuntimeOptions {
   activeCollectionId: string | null;
   activePortfolio?: AppState["config"]["portfolios"][number];
@@ -159,6 +154,13 @@ export function useCommandBarRootRuntime({
 } {
   const previousRootSelectionContextRef = useRef<{ query: string; mode: string } | null>(null);
   const previousRootResultIdsRef = useRef<string[]>([]);
+  /**
+   * The row the untouched highlight rests on once the query's answer is in,
+   * and the answer it was on. A later answer that reorders the rows (a
+   * fresher search over a cached one, a broker's) moves the highlight with
+   * its row, so Enter opens the row that was highlighted.
+   */
+  const pinnedRootRowRef = useRef<{ id: string; answer: string | null } | null>(null);
   const activeMatch = matchPrefix(rootQuery, availableCommands);
 
   const tickerSearchRouteQuery = currentRoute?.kind === "mode" && currentRoute.screen === "ticker-search"
@@ -331,6 +333,7 @@ export function useCommandBarRootRuntime({
     previousRootSelectionContextRef.current = { query: rootQuery, mode: rootModeKind };
     if (selectionContextChanged) {
       rootSelectionNavigatedRef.current = false;
+      pinnedRootRowRef.current = null;
     }
 
     setRootSelectedIdx((current) => {
@@ -343,11 +346,23 @@ export function useCommandBarRootRuntime({
         if (shiftedIdx >= 0) return shiftedIdx;
         return clampIndex(current, resultIds.length);
       }
-      // Untouched, the selection follows the best row on offer.
+      const pinnedIdx = pinnedRootRowRef.current ? resultIds.indexOf(pinnedRootRowRef.current.id) : -1;
+      if (pinnedIdx >= 0) return pinnedIdx;
+      // Untouched, the selection follows the best row on offer until the
+      // answer is in. When every row is an offer or a placeholder, none of
+      // them is the answer and none is selected: Enter must not take one of
+      // them for the ticker still being searched.
       const defaultIdx = orderedRootResults.findIndex(isDefaultSelectable);
-      return clampIndex(Math.max(rootResultModel.initialIdx, defaultIdx), resultIds.length);
+      if (defaultIdx < 0) return -1;
+      const selected = clampIndex(Math.max(rootResultModel.initialIdx, defaultIdx), resultIds.length);
+      pinnedRootRowRef.current = rootResultsCurrent && resultIds[selected]
+        ? { id: resultIds[selected]!, answer: activeRootProviderResultsKey }
+        : null;
+      return selected;
     });
   }, [
+    activeRootProviderResultsKey,
+    rootResultsCurrent,
     activeMatch?.command.id,
     currentRoute,
     orderedRootResults,
@@ -361,7 +376,13 @@ export function useCommandBarRootRuntime({
 
   useEffect(() => {
     if (!activeRootProviderResultsKey) return;
+    // A later answer that only reorders the rows leaves the highlight on its row.
+    const pinned = pinnedRootRowRef.current;
+    if (pinned && pinned.answer !== activeRootProviderResultsKey
+      && orderedRootResults.some((item) => item.id === pinned.id)) return;
     setRootSelectedIdx(0);
+    const top = orderedRootResults[0];
+    pinnedRootRowRef.current = top ? { id: top.id, answer: activeRootProviderResultsKey } : null;
     setRootHoveredIdx(null);
     nativeListScrollRef.current?.scrollTo(0);
   }, [activeRootProviderResultsKey, nativeListScrollRef, setRootHoveredIdx, setRootSelectedIdx]);

package/src/components/command-bar/selection-runtime.ts

@@ -1,9 +1,9 @@
-import { useCallback, type MutableRefObject } from "react";
+import { useCallback, useEffect, useRef, type MutableRefObject } from "react";
 import type { AppState } from "../../state/app/context";
 import type { TickerRecord } from "../../types/ticker";
 import { t } from "../../i18n";
-import { findExactTickerSearchMatch, listingChoiceQuery } from "../../tickers/search";
-import { isKnownExchangeCode, parsePublicTickerKey } from "../../utils/exchanges";
+import { listingChoiceQuery } from "../../tickers/search";
+import { isKnownExchangeCode } from "../../utils/exchanges";
 import type { PluginRegistry } from "../../plugins/registry";
 import type { Command } from "./commands/registry";
 import type {
@@ -12,7 +12,7 @@ import type {
   PaneTemplateDef,
 } from "../../types/plugin";
 import { resolveCommandBarMode, type CommandBarMode } from "./view-model";
-import type { ListScreenState, ResultItem } from "./list/model";
+import { isDefaultSelectable, type ListScreenState, type ResultItem } from "./list/model";
 import type { CommandBarRoute } from "./workflow/types";
 import type { CollectionCommandId } from "./helpers";
 import type { CommandBarCollectionWorkflowActions } from "./workflow/collection-actions";
@@ -67,6 +67,7 @@ interface UseCommandBarSelectionRuntimeOptions {
   rootModeKindRef: MutableRefObject<CommandBarMode>;
   rootQuery: string;
   rootQueryRef: MutableRefObject<string>;
+  rootSelectedIdx: number;
   rootSelectionNavigatedRef: MutableRefObject<boolean>;
   rootShortcutIntent: ShortcutIntent;
   rootThemeBaseIdRef: MutableRefObject<string | null>;
@@ -78,6 +79,11 @@ interface UseCommandBarSelectionRuntimeOptions {
    */
   runRootRow?: RunRootRow;
   runSecurityDescriptionShortcut: (query?: string, options?: { forceNewPane?: boolean }) => void | Promise<void>;
+  /**
+   * The search that decides the best row is still out, so the list on screen
+   * is a stand-in for the answer.
+   */
+  searchPending: boolean;
   setRootQuery: (query: string) => void;
   stateConfigLayout: AppState["config"]["layout"];
   stateRef: MutableRefObject<AppState>;
@@ -108,12 +114,14 @@ export function useCommandBarSelectionRuntime({
   rootModeKindRef,
   rootQuery,
   rootQueryRef,
+  rootSelectedIdx,
   rootSelectionNavigatedRef,
   rootShortcutIntent,
   rootThemeBaseIdRef,
   runDirectCommand,
   runRootRow,
   runSecurityDescriptionShortcut,
+  searchPending,
   setRootQuery,
   stateConfigLayout,
   stateRef,
@@ -276,42 +284,39 @@ export function useCommandBarSelectionRuntime({
     updateTopRoute,
   ]);
 
+  /**
+   * An Enter pressed with no row to run while the search is still out. It
+   * waits for the answer instead of running whatever else the list shows, and
+   * is dropped when the user types, moves the selection or leaves the root.
+   */
+  const pendingEnterRef = useRef<{ query: string; secondary: boolean } | null>(null);
+
   const activateListSelection = useCallback((options?: { secondary?: boolean; item?: ResultItem }) => {
     const listState = visibleListStateRef.current;
     if (!listState) return;
-    // Enter submits the typed command until a row is deliberately chosen.
-    // Search ranks suggestions by relevance; its first namesake must not
-    // replace the listing the shared ticker resolver would open.
+    // Enter opens exactly the highlighted row. The typed command runs as typed
+    // only while no listing for it is highlighted: before its search answers
+    // (`DES HFC` then opens the listing `quote HFC` reads), or while the rows
+    // on screen are an earlier query's.
     const queryChanged = rootQueryRef.current !== rootQuery;
     const tickerArgument = rootShortcutIntent.kind !== "none" && rootShortcutIntent.argKind === "ticker"
       ? rootShortcutIntent.argText : null;
     const listingQuery = listingChoiceQuery(tickerArgument ?? rootQueryRef.current);
     const choosingVenue = listingQuery && !isKnownExchangeCode(listingQuery.suffix);
-    const submitTyped = !options?.item && !currentRoute
+    const highlighted = listState.results[listState.selectedIdx];
+    const listingHighlighted = !queryChanged && (highlighted?.kind === "ticker" || highlighted?.kind === "search");
+    const submitTyped = !options?.item && !currentRoute && !listingHighlighted
       && (queryChanged || (!rootSelectionNavigatedRef.current && !choosingVenue));
-    let typed = submitTyped && (queryChanged || tickerArgument !== null)
+    const typed = submitTyped && (queryChanged || tickerArgument !== null)
       ? resolveImmediateRootSelection(rootQueryRef.current) : null;
-    const first = listState.results[listState.selectedIdx];
-    if (typed && !queryChanged && rootShortcutIntent.kind !== "none" && rootShortcutIntent.argKind === "ticker"
-      && first && (first.kind === "ticker" || first.kind === "search")) {
-      const argument = rootShortcutIntent.argText;
-      // Company names and partial symbols still accept the suggested match.
-      // An exact symbol or named venue goes through listing resolution.
-      if (!parsePublicTickerKey(argument).exchange && !findExactTickerSearchMatch(
-        listState.results.filter((item) => item.kind === "ticker" || item.kind === "search"), argument,
-      )) typed = null;
-    }
-    // A plain symbol follows the same path once it is the default ticker row.
-    // Commands and company-name searches keep their own default actions.
-    const plainSymbol = submitTyped && !typed && first && (first.kind === "ticker" || first.kind === "search")
-      && findExactTickerSearchMatch([first], rootQueryRef.current);
-    if (plainSymbol && first) {
-      const symbol = rootQueryRef.current;
-      typed = { ...first, action: () => runSecurityDescriptionShortcut(symbol),
-        secondaryAction: () => runSecurityDescriptionShortcut(symbol, { forceNewPane: true }) };
-    }
     const selected = options?.item ?? typed ?? listState.results[listState.selectedIdx];
-    if (!selected || selected.disabled) return;
+    if (!selected) {
+      if (searchPending && !currentRoute && !options?.item && !rootSelectionNavigatedRef.current) {
+        pendingEnterRef.current = { query: rootQueryRef.current, secondary: options?.secondary === true };
+      }
+      return;
+    }
+    if (selected.disabled) return;
 
     // Opened from an add row: a venue picked from the colon list joins that
     // collection. Any other text or screen runs as usual.
@@ -378,8 +383,8 @@ export function useCommandBarSelectionRuntime({
       item: selected,
       query,
       rank: selected === typed ? 0 : Math.max(0, listState.results.indexOf(selected)),
-      // A plain symbol stays a ticker choice; a submitted command is the shortcut itself.
-      isShortcut: () => !plainSymbol && (selected === typed || resolveImmediateRootSelection(query)?.id === selected.id),
+      // A listing row stays a ticker choice; a submitted command is the shortcut itself.
+      isShortcut: () => !listingHighlighted && (selected === typed || resolveImmediateRootSelection(query)?.id === selected.id),
     }, run);
   }, [
     closeAll,
@@ -395,12 +400,39 @@ export function useCommandBarSelectionRuntime({
     rootSelectionNavigatedRef,
     rootShortcutIntent,
     runRootRow,
-    runSecurityDescriptionShortcut,
+    searchPending,
     stateConfigLayout,
     stateRef,
     visibleListStateRef,
   ]);
 
+  useEffect(() => {
+    const pending = pendingEnterRef.current;
+    if (!pending) return;
+    if (currentRoute || rootQueryRef.current !== pending.query || rootSelectionNavigatedRef.current) {
+      pendingEnterRef.current = null;
+      return;
+    }
+    const listState = visibleListStateRef.current;
+    if (!listState?.results.some(isDefaultSelectable)) {
+      // Still searching: the answer may bring a row. Answered with none: there is nothing to run.
+      if (!searchPending) pendingEnterRef.current = null;
+      return;
+    }
+    // The selection follows the rows in the render after they land.
+    if (!listState.results[listState.selectedIdx]) return;
+    pendingEnterRef.current = null;
+    activateListSelection({ secondary: pending.secondary });
+  }, [
+    activateListSelection,
+    currentRoute,
+    rootQueryRef,
+    rootSelectedIdx,
+    rootSelectionNavigatedRef,
+    searchPending,
+    visibleListStateRef,
+  ]);
+
   return {
     acceptRootShortcutTab,
     acceptSelectedShortcutTab,

package/src/components/command-bar/surface/index.tsx

@@ -532,12 +532,14 @@ export function CommandBar({
     rootModeKindRef,
     rootQuery,
     rootQueryRef,
+    rootSelectedIdx,
     rootSelectionNavigatedRef,
     rootShortcutIntent,
     rootThemeBaseIdRef,
     runDirectCommand,
     runRootRow,
     runSecurityDescriptionShortcut,
+    searchPending: rootSearching || !rootResultsCurrent,
     setRootQuery,
     stateConfigLayout: state.config.layout,
     stateRef,

package/src/components/layout/detached-pane-shell.tsx

@@ -170,9 +170,9 @@ export function DetachedPaneShell({ pluginRegistry, desktopWindowBridge }: Detac
     fireAndForget(desktopWindowBridge.closeDetachedPane?.(desktopWindowBridge.paneId), "desktop.closeDetachedPane");
   }, [desktopWindowBridge, locked, pluginRegistry]);
 
-  const startWindowDrag = useCallback(() => {
+  const startWindowDrag = useCallback((press?: { detail?: number }) => {
     focusPane();
-    if (nativeWindowChrome) void rendererHost.startWindowDrag?.();
+    if (nativeWindowChrome) void rendererHost.startWindowDrag?.(press);
   }, [focusPane, nativeWindowChrome, rendererHost]);
 
   const sharePane = useCallback(() => {

package/src/components/layout/header.tsx

@@ -870,9 +870,9 @@ export function Header({
   // bar itself wears the prompt's fill and reads as a single strip.
   const headerBg = nativePaneChrome ? colors.header : headerSurface(colors);
 
-  const startWindowDrag = useCallback(() => {
+  const startWindowDrag = useCallback((press?: { detail?: number }) => {
     if (!titleBarOverlay || !nativeWindowChrome) return;
-    void rendererHost.startWindowDrag?.();
+    void rendererHost.startWindowDrag?.(press);
   }, [nativeWindowChrome, rendererHost, titleBarOverlay]);
 
   const openCommandBar = useCallback((event?: HeaderActionEvent) => {

package/src/components/layout/pane/capture-stamp.ts

@@ -28,10 +28,10 @@ export function usePaneCaptureStamp(paneId: string): string | null {
 
 export function captureStampFooter(footer: CombinedPaneFooter, text: string | null): CombinedPaneFooter {
   if (!text) return footer;
-  // Set apart from what the pane says about its data, which may itself be a time.
+  // The footer sets it apart from what the pane says about its data, which may itself be a time.
   const segment: PaneFooterSegment = {
     id: "capture-stamp",
-    parts: [...(footer.info.length > 0 ? [{ text: "· ", tone: "muted" as const }] : []), { text, tone: "label" }],
+    parts: [{ text, tone: "label" }],
   };
   return {
     ...footer,

package/src/components/layout/pane/footer/index.tsx

@@ -11,7 +11,9 @@ import { useOptionalDialog, type PromptContext } from "../../../../ui/dialog";
 import { nativePaneFooterRows } from "../sizing";
 import {
   EMPTY_FOOTER,
+  PANE_FOOTER_SEPARATOR,
   fitPaneFooterInfo,
+  separatesPaneFooterSegments,
   hasPaneFooterContent,
   layoutPaneFooterHintRow,
   totalHintsWidth,
@@ -22,10 +24,12 @@ import {
 } from "./model";
 
 export {
+  companyDataFooterSegment,
   datesPaneData,
   DELAYED_SEGMENT,
   delayedFooterSegment,
   hasPaneFooterContent,
+  savedCopyFooterInfo,
   savedCopyFooterSegment,
   splitDelayedStatus,
   type CombinedPaneFooter,
@@ -267,6 +271,7 @@ function FooterContent({
   // A segment with shorter forms takes the longest that fits beside the hints, gaps and terminal keys included.
   const keysWidth = nativePaneChrome ? 0 : footer.info.reduce((total, segment) => total + terminalSegmentKey(segment, focused).length, 0);
   const info = infoWidth != null ? fitPaneFooterInfo(footer.info, infoWidth - keysWidth, { besideHints: hasHints }) : footer.info;
+  const lastTextIndex = info.findLastIndex((segment) => !segment.icon);
 
   if (!hasInfo && !hasHints) {
     return <Box flexGrow={1} height={1} />;
@@ -291,12 +296,24 @@ function FooterContent({
           flexShrink={1}
           {...(infoWidth != null ? { width: infoWidth } : {})}
         >
-          {info.map((segment, index) => (
-            // An icon is a few cells that mean nothing cut: the text beside it gives way first.
-            <Box key={segment.id} flexDirection="row" flexShrink={segment.icon ? 0 : undefined} marginRight={index === info.length - 1 ? 0 : 1}>
-              <SegmentView segment={segment} focused={focused} />
-            </Box>
-          ))}
+          {info.map((segment, index) => {
+            // Every pane's segments are set apart the same way, so two never read as one sentence.
+            const separated = index > 0 && separatesPaneFooterSegments(info[index - 1]!, segment);
+            return (
+              <Box
+                key={segment.id}
+                flexDirection="row"
+                overflow="hidden"
+                // A row too narrow cuts from its end: the last text segment gives way, then the row clips the
+                // one before it. An icon is a few cells that mean nothing cut, and earlier text says more.
+                flexShrink={!segment.icon && index === lastTextIndex ? 1 : 0}
+                marginLeft={index > 0 && !separated ? 1 : 0}
+              >
+                {separated && <Box flexShrink={0}><Text fg={colors.textMuted}>{PANE_FOOTER_SEPARATOR}</Text></Box>}
+                <SegmentView segment={segment} focused={focused} />
+              </Box>
+            );
+          })}
         </Box>
       )}
       {hasHints && (