@gloom-sh/terminal 0.19.0 → 0.19.1

package/src/cli/pane-functions/freshness.ts

@@ -123,6 +123,8 @@ export interface ReportFreshness {
   ageOnly?: true;
   /** What the newest observation is, said before its time: `newest story Tue 29 Sep 2026 20:17 UTC`. */
   asOfLabel?: string;
+  /** The line says when the report was retrieved after the newest observation's date (`retrieved Wed 28 Oct 2026 19:07 UTC`). */
+  retrievedToo?: true;
   /** What the figures are, said after the status: `funding = current estimate, pays 08:00 UTC`. */
   note?: string;
   /** Shorter forms of `note`, in the order a capture's line too long for it tries them. */
@@ -610,6 +612,7 @@ function resolveFreshness({ declared, signals, observations, now }: FreshnessInp
     ...(oldestAgeMinutes != null ? { oldestAgeMinutes } : {}),
     ...(status === "unreported" && declared.ageOnly ? { ageOnly: true as const } : {}),
     ...(asOfLabel ? { asOfLabel } : {}),
+    ...(asOf && declared.retrievedToo ? { retrievedToo: true as const } : {}),
     ...(note ? { note } : {}),
     ...(noteVariants.length > 0 ? { noteVariants } : {}),
     ...(schedule ? { schedule } : {}),
@@ -1061,8 +1064,11 @@ function statusLineParts(freshness: ReportFreshness, detail: StatusLineDetail =
   const undated = detail.date === "none";
   return [
     ...(freshness.sources?.length ? sourcesAsOfParts(freshness, freshness.sources, undated)
-      : freshness.unreached && !freshness.asOf ? []
+      // Undated, a saved copy is not "retrieved" now: its own part says when it was saved.
+      : (freshness.unreached || freshness.savedAt) && !freshness.asOf ? []
       : [asOfText(freshness, detail.asOf === "short", local, undated)]),
+    // A list dated by its newest filing says when it was read as well.
+    ...(freshness.retrievedToo && freshness.asOf && !freshness.savedAt ? [`retrieved ${timeText(freshness.retrievedAt, local)}`] : []),
     ...(freshness.schedule && detail.schedule !== "none"
       ? [typeof detail.schedule === "number" ? freshness.scheduleVariants?.[detail.schedule] ?? freshness.schedule : freshness.schedule] : []),
     ...(freshness.oldestAgeMinutes != null ? [`oldest ${ageText(freshness.oldestAgeMinutes)}`] : []),

package/src/cli/pane-functions/function-help.ts

@@ -1426,6 +1426,13 @@ export const FUNCTION_HELP: Readonly<Record<string, FunctionHelp>> = {
     data: null,
     bloomberg: [],
   },
+  ROADMAP: {
+    summary: "What is being built, what is planned and what shipped, with each item's votes. Pro members vote on what is building or planned, once per item, and can take the vote back.",
+    usage: ["ROADMAP"],
+    keys: [OPEN, key("v", "ote")],
+    data: null,
+    bloomberg: [],
+  },
   HELP: {
     summary: "Help and the function reference. HELP with a function opens its card, F1 opens the focused pane's, and HELP HELP reaches support.",
     usage: ["HELP", "HELP OMON", "HELP HELP"],

package/src/cli/pane-functions/index.ts

@@ -36,8 +36,8 @@ import {
   ListingArgError, listingFateLoader, listingReadNotes, loadForListing, loadListingQuoteAnswer, quotedListingChoiceNotes, refuseMovedListing,
 } from "../listing-arg";
 import { notATickerStop } from "../company-name-hint";
-import { CLI_ERROR_CODE, failWithError, isCliFailure, SERVICE_UNREACHABLE_CODE } from "../errors";
-import { DATA_SERVICE_UNREACHABLE_MESSAGE } from "../../utils/network-failure";
+import { CLI_ERROR_CODE, failUnreachable, failWithError, isCliFailure, unreachableError } from "../errors";
+import { DATA_SERVICE_UNREACHABLE_MESSAGE, isNetworkFailure } from "../../utils/network-failure";
 import { isTickerLinkPeer } from "../../layout/ticker-navigation";
 import { knownGapMessage, commandPointer, commandPointerLeads, topicPointer } from "../known-gaps";
 import { selectReportTables, type CliReportTables } from "../report-tables";
@@ -264,7 +264,7 @@ export function reportFailure(
   const reasons = [...data.errors ?? [], ...typeof data.reason === "string" ? [data.reason] : []];
   const unreached = reasons.filter((reason) => reason.includes(DATA_SERVICE_UNREACHABLE_MESSAGE));
   if (unreached.length > 0 && (data.empty || data.unavailableSymbols.length > 0)) {
-    return { code: SERVICE_UNREACHABLE_CODE, message: `${asked}: ${unreached.join("; ")}.`.replace(/\.\.$/, "."), retryable: true };
+    return unreachableError(`${asked}: ${unreached.join("; ")}.`.replace(/\.\.$/, "."));
   }
   if (!data.empty && !(noListing && noValues) && !(failsWithoutData && foundNothing(data))) return null;
   const unavailable = data.unavailableSymbols.length > 0 ? `no data for ${data.unavailableSymbols.join(", ")}` : "no data";
@@ -618,6 +618,9 @@ async function runPaneCliCommand(ctx: CliCommandContext, run: () => Promise<void
     // A listing it cannot use says what to type instead; a name that opens nothing, what is close to it.
     if (error instanceof ListingArgError || error instanceof UnknownPaneFunctionError) ctx.fail(error.message, error.details || undefined);
     const message = error instanceof Error ? error.message : String(error);
+    // Nothing answered: said as every command says it, with what to check.
+    if (message.includes(DATA_SERVICE_UNREACHABLE_MESSAGE)) failUnreachable(message);
+    if (isNetworkFailure(error)) failUnreachable();
     // A failure the command already worded keeps its advice line.
     const stated = error instanceof Error ? (error as Error & { details?: unknown }).details : undefined;
     const details = typeof stated === "string" ? stated : undefined;

package/src/cli/quote-answer.ts

@@ -160,7 +160,7 @@ async function answerCompanyName(
     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;

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];
@@ -343,8 +338,12 @@ export function useCommandBarRootRuntime({
         if (shiftedIdx >= 0) return shiftedIdx;
         return clampIndex(current, resultIds.length);
       }
-      // Untouched, the selection follows the best row on offer.
+      // Untouched, the selection follows the best row on offer. 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);
+      if (defaultIdx < 0) return -1;
       return clampIndex(Math.max(rootResultModel.initialIdx, defaultIdx), resultIds.length);
     });
   }, [

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

@@ -1,4 +1,4 @@
-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";
@@ -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,6 +284,13 @@ 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;
@@ -311,7 +326,13 @@ export function useCommandBarSelectionRuntime({
         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.
@@ -396,11 +417,39 @@ export function useCommandBarSelectionRuntime({
     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/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,6 +24,7 @@ import {
 } from "./model";
 
 export {
+  companyDataFooterSegment,
   datesPaneData,
   DELAYED_SEGMENT,
   delayedFooterSegment,
@@ -267,6 +270,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 +295,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 && (

package/src/components/layout/pane/footer/model.ts

@@ -1,5 +1,6 @@
 import type { ContextMenuItem } from "../../../../types/context-menu";
-import { t } from "../../../../i18n";
+import { t, tf } from "../../../../i18n";
+import { type CompanyFrom, companyFromLabel } from "../../../../types/company-from";
 import { clipToDisplayWidth, displayWidth } from "../../../../utils/format";
 import { formatShortDate } from "../../../../utils/datetime-format";
 import { getShortcutHintWidth } from "../../../ui/shortcut-hint";
@@ -44,8 +45,9 @@ export interface PaneFooterSegment {
    */
   quoteStatus?: boolean;
   /**
-   * The segment says what the rows leave out (releases a filter hides), which
-   * a picture of the rows cannot: a `gloom shot` keeps it, as it keeps a
+   * The segment says what the rows leave out (releases a filter hides), or
+   * whose they are (a receipt's company data from its home line), which a
+   * picture of the rows cannot: a `gloom shot` keeps it, as it keeps a
    * warning.
    */
   capture?: boolean;
@@ -117,6 +119,26 @@ export function savedCopyFooterSegment(id: string, savedAt: number, now = Date.n
   };
 }
 
+/**
+ * The footer's one form for company data a pane shows from another listing
+ * of the company: a receipt or a foreign line (SKHY, HY9H in Frankfurt) reads
+ * its home line's news, filings or holders, `company data from 000660 KRX`.
+ * Null when the data is the listing's own.
+ */
+export function companyDataFooterSegment(from: CompanyFrom | null | undefined): PaneFooterSegment | null {
+  if (!from) return null;
+  const listing = companyFromLabel(from);
+  const text = tf("company data from {listing}", { listing });
+  return {
+    id: "company-data",
+    title: from.name ? `${text} (${from.name})` : text,
+    // A capture of the rows keeps it: the picture cannot say whose they are.
+    capture: true,
+    parts: [{ text, tone: "muted" }],
+    variants: [[{ text: tf("from {listing}", { listing }), tone: "muted" }]],
+  };
+}
+
 /** A pane whose market data is all delayed, by no one figure: the clock alone, its tooltip saying so. */
 export const DELAYED_SEGMENT: PaneFooterSegment = delayedFooterSegment({ id: "delayed", detail: "Delayed market data" });
 
@@ -202,6 +224,25 @@ const INFO_FLOOR_CHARS = 10;
 const WARNING_FLOOR_CHARS = 24;
 const HINT_GAP = 1;
 
+/**
+ * What the footer draws between two info segments, muted, as a status draws
+ * between its own parts ("Newest story Mon 14:23 · 12h delayed"): two
+ * segments side by side never read as one sentence ("company data from PBR ·
+ * as of 2026-06-30"). An icon (`⚠[!]`, `◷15m`) is a mark, not a phrase: a
+ * column sets it apart.
+ */
+export const PANE_FOOTER_SEPARATOR = " · ";
+const SEPARATOR_WIDTH = displayWidth(PANE_FOOTER_SEPARATOR);
+
+/** Whether the footer draws {@link PANE_FOOTER_SEPARATOR} between two adjacent segments, else a one-column gap. */
+export function separatesPaneFooterSegments(before: Pick<PaneFooterSegment, "icon">, after: Pick<PaneFooterSegment, "icon">): boolean {
+  return !before.icon && !after.icon;
+}
+
+function segmentGapWidth(before: PaneFooterSegment, after: PaneFooterSegment): number {
+  return separatesPaneFooterSegments(before, after) ? SEPARATOR_WIDTH : 1;
+}
+
 function paneHintWidth(hint: Pick<PaneHint, "key" | "label">, prefix = ""): number {
   return getShortcutHintWidth(hint.key, hint.label, prefix);
 }
@@ -216,15 +257,12 @@ function infoTextWidth(segments: readonly PaneFooterSegment[]): number {
     const text = segment.parts.reduce((sum, part, partIndex) => (
       sum + (partIndex > 0 ? 1 : 0) + displayWidth(part.text)
     ), 0);
-    return total + (index > 0 ? 1 : 0) + text;
+    return total + (index > 0 ? segmentGapWidth(segments[index - 1]!, segment) : 0) + text;
   }, 0);
 }
 
-/**
- * The info segments as they fit `width`: segments with `variants` step down
- * together, one variant at a time, until the row fits or none is left.
- */
-export function fitPaneFooterInfo(info: PaneFooterSegment[], width: number, { besideHints = true }: { besideHints?: boolean } = {}): PaneFooterSegment[] {
+/** Segments with `variants` step down together, one variant at a time, until they fit or none is left. */
+function stepDownTogether(info: PaneFooterSegment[], width: number): PaneFooterSegment[] {
   const stages = Math.max(0, ...info.map((segment) => segment.variants?.length ?? 0));
   let fitted = info;
   for (let stage = 0; stage < stages && infoTextWidth(fitted) > width; stage += 1) {
@@ -237,20 +275,50 @@ export function fitPaneFooterInfo(info: PaneFooterSegment[], width: number, { be
       } : segment;
     });
   }
-  // A trailing status cut mid-word reads as part of the hints beside it ("quote 12h t[x] put"): one that does not
-  // fit ends in an ellipsis a column short of them, or is left out when less than half of it would show. A
-  // warning, an icon or a pressable segment stays as it is, clipped by the row if it must be. With no hints beside it
-  // (a pane picture's footer), the row clips it, so a frame that fits its own status line sees it overflow.
-  while (besideHints && fitted.length > 1 && infoTextWidth(fitted) > width) {
+  return fitted;
+}
+
+/**
+ * A trailing status cut mid-word reads as part of the hints beside it ("quote
+ * 12h t[x] put"): one that does not fit ends in an ellipsis a column short of
+ * them, or is left out when less than half of it would show, until the row
+ * fits or `keep` segments are left. A warning, an icon or a pressable segment
+ * stays as it is, clipped by the row if it must be.
+ */
+function trimTrailing(info: PaneFooterSegment[], width: number, keep: number): PaneFooterSegment[] {
+  let fitted = info;
+  while (fitted.length > keep && infoTextWidth(fitted) > width) {
     const last = fitted.at(-1)!;
     if (last.icon || last.onPress || last.parts.some((part) => part.tone === "warning" || part.tone === "negative")) break;
-    const room = width - infoTextWidth(fitted.slice(0, -1)) - 2;
+    // After the separator, a column short of the hints.
+    const room = width - infoTextWidth(fitted.slice(0, -1)) - segmentGapWidth(fitted.at(-2)!, last) - 1;
     if (room * 2 >= infoTextWidth([last])) return [...fitted.slice(0, -1), clipSegment(last, room)];
     fitted = fitted.slice(0, -1);
   }
   return fitted;
 }
 
+/**
+ * The info segments as they fit `width`: segments with `variants` step down
+ * together, one variant at a time, until the row fits or none is left; beside
+ * the hints, the trailing status that still does not fit is then cut or left
+ * out (trimTrailing). A status after every segment with shorter forms gives
+ * way first, before any of them shortens: a pane puts what goes first last
+ * (an update time after a note that explains the row in hand).
+ *
+ * With no hints beside it (a pane picture's footer), the row clips the rest,
+ * so a frame that fits its own status line sees it overflow.
+ */
+export function fitPaneFooterInfo(info: PaneFooterSegment[], width: number, { besideHints = true }: { besideHints?: boolean } = {}): PaneFooterSegment[] {
+  if (!besideHints) return stepDownTogether(info, width);
+  const lastWithVariants = info.findLastIndex((segment) => (segment.variants?.length ?? 0) > 0);
+  if (lastWithVariants >= 0 && lastWithVariants < info.length - 1 && infoTextWidth(info) > width) {
+    const trimmed = trimTrailing(info, width, lastWithVariants + 1);
+    if (infoTextWidth(trimmed) <= width) return trimmed;
+  }
+  return trimTrailing(stepDownTogether(info, width), width, 1);
+}
+
 /** A segment cut to `width` behind an ellipsis, each part keeping its tone; the full text stays as its title. */
 function clipSegment(segment: PaneFooterSegment, width: number): PaneFooterSegment {
   const full = segment.parts.map((part) => part.text).join(" ");

package/src/components/layout/pane/status-footer.ts

@@ -1,5 +1,7 @@
-import { useMemo } from "react";
-import { usePaneFooter, type PaneFooterSegment, type PaneHint } from "./footer";
+import { useId, useMemo } from "react";
+import { companyDataFooterSegment, usePaneFooter, type PaneFooterSegment, type PaneHint } from "./footer";
+import type { CompanyFrom } from "../../../types/company-from";
+import { useAppLanguage } from "../../../i18n/react";
 import { useExternalLinkFooter } from "../../use-external-link-footer";
 import { loadingErrorFooterInfo } from "../../data-table/table-pane";
 
@@ -28,6 +30,37 @@ function buildPaneStatusInfo({
   return [...info, ...(stale ? [STALE_SEGMENT] : []), ...loadingErrorFooterInfo(loading, error)];
 }
 
+/**
+ * Where the company data note sits: after the warning indicator (-10) and
+ * before the pane's own status (0 and the ticker quote's -1), so it leads what
+ * the pane says about its data and a narrow footer cuts that status first.
+ */
+const COMPANY_DATA_ORDER = -5;
+
+/**
+ * A company pane on a receipt or a foreign line that shows its company's data
+ * from the home line says which: `company data from 000660 KRX · as of
+ * 2026-06-30`, before the pane's own status (after a warning). Nothing when
+ * the data is the listing's own. Every company pane registers it here, so it
+ * reads, looks and sits the same in each.
+ */
+export function useCompanyDataFooter(companyFrom: CompanyFrom | null | undefined, enabled = true) {
+  const language = useAppLanguage();
+  const segment = useMemo(() => companyDataFooterSegment(companyFrom), [
+    language,
+    companyFrom?.symbol,
+    companyFrom?.exchange,
+    companyFrom?.name,
+  ]);
+  // Its own registration, so a view nested in a pane (13D/G under holders) never clears the pane's.
+  const id = useId();
+  usePaneFooter(
+    `company-data:${id}`,
+    () => enabled && segment ? { order: COMPANY_DATA_ORDER, info: [segment] } : null,
+    [enabled, segment],
+  );
+}
+
 export function usePaneStatusFooter({
   registrationId,
   loading = false,

package/src/components/layout/status-widget-space.ts

@@ -53,6 +53,15 @@ export function usePublishStatusWidgetRoom(columns: number): void {
   }, []);
 }
 
+/**
+ * Extra columns the other widgets claim, for a widget that sizes itself to
+ * what they leave rather than run into them.
+ */
+export function useOtherStatusWidgetClaims(id: string): number {
+  const others = () => claimedColumns() - (claims.get(id) ?? 0);
+  return useSyncExternalStore(subscribe, others, others);
+}
+
 /** The columns the widgets can use, as the status bar last published them. */
 export function useStatusWidgetRoom(): number {
   return useSyncExternalStore(subscribe, () => room, () => room);