gloomberb 0.18.0 → 0.18.2

package/src/plugins/builtin/notes/quick-notes-pane.tsx

@@ -59,6 +59,9 @@ export function createQuickNotesPane(registry: NotesStoreRegistry) {
     const lastSavedTextRef = useRef<Map<string, string>>(new Map());
     const loadedTabIdRef = useRef<string | null>(null);
     const loadedRef = useRef(false);
+    // Owners whose index exists but could not be read: nothing is saved over it.
+    const unreadableIndexRef = useRef(new Set<string>());
+    const [indexError, setIndexError] = useState<{ message: string; owners: NoteOwner[] } | null>(null);
     const activeTab = tabs.find((tab) => tab.id === activeTabId);
 
     const saveQuickNotesIndex = useCallback((entries: OwnedQuickNote[]) => {
@@ -73,7 +76,7 @@ export function createQuickNotesPane(registry: NotesStoreRegistry) {
       for (const owner of owners) {
         const bucket = byOwner.get(noteOwnerKey(owner));
         const store = storeFor(owner);
-        if (store.readOnly) continue;
+        if (store.readOnly || unreadableIndexRef.current.has(noteOwnerKey(owner))) continue;
         store.saveQuickNotesIndex(bucket?.entries ?? []).catch((error) => {
           notesLog.error("Failed to save notes index", { error: error instanceof Error ? error.message : String(error) });
           notify({ body: error instanceof Error ? error.message : "Failed to save notes index.", type: "error" });
@@ -143,17 +146,24 @@ export function createQuickNotesPane(registry: NotesStoreRegistry) {
     useEffect(() => {
       // Mine first, then each team's notes; reloads when the team list changes.
       let cancelled = false;
+      const unreadable = new Map<string, { owner: NoteOwner; message: string }>();
       void Promise.all(owners.map(async (owner) => {
         try {
-          return (await storeFor(owner).loadQuickNotesIndex()).map((entry) => ({ ...entry, owner }));
+          return (await storeFor(owner).loadQuickNotesIndex({ strict: true })).map((entry) => ({ ...entry, owner }));
         } catch (error) {
+          unreadable.set(noteOwnerKey(owner), { owner, message: error instanceof Error ? error.message : String(error) });
           return logFailure("notes.quick-notes", "Load a quick notes index failed", [] as OwnedQuickNote[])(error);
         }
       })).then((lists) => {
         if (cancelled) return;
+        unreadableIndexRef.current = new Set(unreadable.keys());
+        const failed = [...unreadable.values()];
+        setIndexError(failed.length > 0 ? { message: failed[0]!.message, owners: failed.map((entry) => entry.owner) } : null);
         const entries = lists.flat();
         if (entries.length === 0) {
-          if (loadedRef.current) return;
+          // Only a first run, with no index yet, gets a first tab; an index
+          // that failed to load must not have a fresh one saved over it.
+          if (loadedRef.current || unreadable.size > 0) return;
           const id = generateNoteId();
           const initial: OwnedQuickNote[] = [{ id, title: "New", owner: { kind: "user" } }];
           lastSavedTextRef.current.set(id, "");
@@ -224,6 +234,10 @@ export function createQuickNotesPane(registry: NotesStoreRegistry) {
         notify({ body: `${ownerLabel(owner, teams)} notes are read-only right now.`, type: "info" });
         return;
       }
+      if (unreadableIndexRef.current.has(noteOwnerKey(owner))) {
+        notify({ body: `${ownerLabel(owner, teams)} quick notes could not be read, so a new one is not added yet.`, type: "info" });
+        return;
+      }
       const id = generateNoteId();
       const entry: OwnedQuickNote = { id, title: "New", owner };
       lastSavedTextRef.current.set(id, "");
@@ -243,6 +257,14 @@ export function createQuickNotesPane(registry: NotesStoreRegistry) {
       const owner = tabOwner(id, tabsRef.current);
       setTabs((prev) => {
         const next = prev.filter((t) => t.id !== id);
+        // With my index unreadable, a fresh tab of mine could not be saved in it.
+        if (next.length === 0 && unreadableIndexRef.current.has(noteOwnerKey({ kind: "user" }))) {
+          saveQuickNotesIndex(next);
+          setActiveTabId(null);
+          setNoteText("");
+          prevTabRef.current = null;
+          return next;
+        }
         if (next.length === 0) {
           const newId = generateNoteId();
           const fresh: OwnedQuickNote[] = [{ id: newId, title: "New", owner: { kind: "user" } }];
@@ -332,6 +354,13 @@ export function createQuickNotesPane(registry: NotesStoreRegistry) {
       if (activeTabId) void requestRemoveTab(activeTabId);
     }, [activeTabId, requestRemoveTab]);
 
+    // With no tab to show, an index that failed to load is the pane's state;
+    // beside other owners' tabs it is a footer warning.
+    const indexUnreadable = tabs.length === 0 && !!indexError;
+    const readError = loadError ?? (indexUnreadable ? indexError!.message : null);
+    const footerWarning = readError
+      ?? (indexError ? `${indexError.owners.map((owner) => ownerLabel(owner, teams)).join(", ")} quick notes could not be read` : null);
+
     // n, t and d are footer hints, which bind them without modifiers, so the
     // shell's Ctrl+W or Cmd+N never adds or deletes a note.
     useShortcut((event) => {
@@ -351,7 +380,7 @@ export function createQuickNotesPane(registry: NotesStoreRegistry) {
       }
 
       // A note that failed to load stays read-only, as it does for a click.
-      if (isPlainKey(event, "enter", "return") && !editing && !loadError) {
+      if (isPlainKey(event, "enter", "return") && !editing && !readError) {
         event.preventDefault();
         setEditing(true);
         return;
@@ -375,11 +404,11 @@ export function createQuickNotesPane(registry: NotesStoreRegistry) {
 
     // Deleting the only note when it is empty just swaps in another empty one,
     // and a note that failed to load reads as empty, so it would go unconfirmed.
-    const canDelete = !!activeTabId && !loadError && (tabs.length > 1 || noteText.trim().length > 0);
+    const canDelete = !!activeTabId && !readError && (tabs.length > 1 || noteText.trim().length > 0);
 
     usePaneFooter("quick-notes", () => ({
-      info: loadError
-        ? [{ id: "load-error", parts: [{ text: loadError, tone: "warning" as const }] }]
+      info: footerWarning
+        ? [{ id: "load-error", parts: [{ text: footerWarning, tone: "warning" as const }] }]
         : [
             { id: "edited", parts: [{ text: editing || renaming ? "editing" : formatLastEdited(activeTab?.updatedAt), tone: "muted" as const }] },
           ],
@@ -391,7 +420,7 @@ export function createQuickNotesPane(registry: NotesStoreRegistry) {
             { id: "title", key: "t", label: "itle", title: "Rename Note", onPress: startRename, disabled: !activeTabId },
             { id: "delete", key: "d", label: "elete", title: "Delete Note", onPress: deleteActiveNote, disabled: !canDelete },
           ],
-    }), [activeTab, activeTabId, addTab, canDelete, deleteActiveNote, editing, loadError, renaming, startRename]);
+    }), [activeTab, activeTabId, addTab, canDelete, deleteActiveNote, editing, footerWarning, renaming, startRename]);
 
     const noteTabs = tabs.map((tab) => ({
       label: tab.owner.kind === "team" ? `${ownerLabel(tab.owner, teams)} ${tab.title}` : tab.title,
@@ -437,13 +466,19 @@ export function createQuickNotesPane(registry: NotesStoreRegistry) {
             />
           </Box>
         )}
-        <Box flexGrow={1} minHeight={0} paddingX={1} onMouseDown={() => { if (!editing && !renaming && !loadError) setEditing(true); }}>
+        <Box flexGrow={1} minHeight={0} paddingX={1} onMouseDown={() => { if (!editing && !renaming && !readError) setEditing(true); }}>
           {loadError ? (
             <EmptyState
               title="This note could not be read."
               message={loadError}
               hint="Editing is disabled so the saved note is not overwritten. Fix the file, then reopen the pane."
             />
+          ) : indexUnreadable ? (
+            <EmptyState
+              title="Quick notes could not be read."
+              message={indexError!.message}
+              hint="Nothing is saved over them until they load. Reopen the pane to try again."
+            />
           ) : editing && !renaming ? (
             <MarkdownEditor
               textareaKey="editing"
@@ -458,7 +493,7 @@ export function createQuickNotesPane(registry: NotesStoreRegistry) {
               text={noteText}
               width={width}
               placeholder="Write notes..."
-              onActivate={() => { if (!renaming && !loadError) setEditing(true); }}
+              onActivate={() => { if (!renaming && !readError) setEditing(true); }}
             />
           )}
         </Box>

package/src/plugins/builtin/notes/store.ts

@@ -7,7 +7,7 @@ import {
   type NoteKind,
 } from "../../../api-client";
 import type { PluginPersistence } from "../../../types/plugin";
-import type { NoteFileEntry, QuickNoteEntry } from "./files";
+import type { NoteFileEntry, NotesListOptions, QuickNoteEntry } from "./files";
 
 export { NoteConflictError };
 
@@ -27,8 +27,18 @@ export interface NotesStore {
   load(key: string): Promise<string>;
   save(key: string, text: string, options?: { title?: string | null }): Promise<void>;
   delete(key: string): Promise<void>;
-  list(): Promise<NoteFileEntry[]>;
-  loadQuickNotesIndex(): Promise<QuickNoteEntry[]>;
+  /**
+   * Every note, newest first. A note that cannot be read is left out and
+   * handed to `skipped`; with `strict`, notes that cannot be listed at all
+   * reject instead of coming back as none.
+   */
+  list(options?: NotesListOptions): Promise<NoteFileEntry[]>;
+  /**
+   * The quick notes' ids and titles. With `strict`, an index that exists but
+   * cannot be read rejects instead of reading as empty, for a caller that
+   * would otherwise save a replacement over it.
+   */
+  loadQuickNotesIndex(options?: { strict?: boolean }): Promise<QuickNoteEntry[]>;
   saveQuickNotesIndex(entries: QuickNoteEntry[]): Promise<void>;
   quickNoteKey(id: string): string;
   /** Called after a server-side change so the next load sees it. */

package/src/plugins/builtin/options/footer.ts

@@ -1,5 +1,6 @@
 import { useMemo } from "react";
 import type { PaneFooterSegment, PaneHint } from "../../../components";
+import { delayedFooterSegment } from "../../../components/layout/pane/footer/model";
 import { t, tf } from "../../../i18n";
 import type { OptionsChain } from "../../../types/financials";
 import { formatRelativeTime } from "../../../utils/datetime-format";
@@ -9,18 +10,18 @@ import { CLOUD_QUOTE_DELAY_MINUTES } from "../../../api-client/plan-access";
 import type { OptionQuoteCoverage, OptionQuoteCoverageStatus } from "./live-quotes";
 import { formatOptionPrice, optionSpread, type OptionMarketReference } from "./market-reference";
 
-interface OptionsCoverageState {
-  text: string;
-  tone: "muted" | "positive" | "warning";
-}
-
-/** Stream coverage the pane reports once the account is entitled to real-time options. */
-function resolveOptionsCoverageState(status: OptionQuoteCoverageStatus): OptionsCoverageState | null {
-  if (status === "live") return { text: t("real-time options"), tone: "positive" };
-  if (status === "mixed") return { text: t("mixed real-time and delayed options"), tone: "warning" };
+/**
+ * Stream coverage the pane reports once the account is entitled to real-time
+ * options. Delayed quotes, all or some, are the footer's clock, its detail on
+ * hover.
+ */
+export function optionsCoverageSegment(status: OptionQuoteCoverageStatus, delayLabel?: string): PaneFooterSegment | null {
+  const id = "options-access";
+  if (status === "live") return { id, parts: [{ text: t("real-time options"), tone: "positive" }] };
+  if (status === "mixed") return delayedFooterSegment({ id, detail: t("mixed real-time and delayed options") });
   // The stream connects in the background; nothing to report until it answers.
   if (status === "connecting") return null;
-  return { text: t("options delayed fallback"), tone: "warning" };
+  return delayedFooterSegment({ id, detail: t("Delayed options quotes, real-time stream unavailable"), delay: delayLabel });
 }
 
 /**
@@ -82,6 +83,7 @@ export function resolveOptionsDelayLabel(chain: OptionsChain | null | undefined)
 }
 
 export function useOptionsAccessFooter({
+  broker = false,
   chain,
   error,
   focused,
@@ -91,6 +93,8 @@ export function useOptionsAccessFooter({
   reference,
   spreadColumnVisible,
 }: {
+  /** The chain is a broker profile's, quoted by that broker: it has no Gloom Cloud delay to report or upgrade from. */
+  broker?: boolean;
   chain: OptionsChain | null | undefined;
   error?: string | null;
   focused: boolean;
@@ -102,24 +106,25 @@ export function useOptionsAccessFooter({
   /** Set while the chain prints a SPRD column, so the status bar stops repeating it. */
   spreadColumnVisible?: boolean;
 }): void {
+  const delayLabel = resolveOptionsDelayLabel(chain);
   const { access, hint: upgradeHint, segment } = useCloudAccessFooter({
-    delayLabel: resolveOptionsDelayLabel(chain),
+    delayLabel,
+    degraded: !broker,
     focused,
     segmentId: "options-access",
     placement: "omon-footer",
     shortcutScope: "options:upgrade",
   });
-  // Trial accounts stream real-time too, but the countdown is the status worth the row.
-  const coverage = access.hasProAccess && !access.isTrialActive
-    ? resolveOptionsCoverageState(quoteCoverage.status)
-    : null;
-
+  // Trial accounts stream real-time too, but the countdown is the status worth the row. A broker's
+  // chain streams from the broker whatever the plan, so its coverage is the status, and its delay
+  // is the chain's own, not Gloom Cloud's.
+  const proCoverage = broker || (access.hasProAccess && !access.isTrialActive);
+  const coverageDelay = broker && !(chain?.delayMinutes && chain.delayMinutes > 0) ? undefined : delayLabel;
   const accessInfo = useMemo<PaneFooterSegment[]>(() => {
-    if (coverage) {
-      return [{ id: "options-access", parts: [{ text: coverage.text, tone: coverage.tone }] }];
-    }
+    const coverage = proCoverage ? optionsCoverageSegment(quoteCoverage.status, coverageDelay) : null;
+    if (coverage) return [coverage];
     return segment ? [segment] : [];
-  }, [coverage?.text, coverage?.tone, segment]);
+  }, [coverageDelay, proCoverage, quoteCoverage.status, segment]);
 
   // Rebuilt every render so the quote and trade ages keep counting with the
   // stream; the registration compares by value, so only a changed label

package/src/plugins/builtin/options/live-quotes.ts

@@ -1,6 +1,6 @@
 import type { QuoteSubscriptionTarget } from "../../../types/data-provider";
 import type { OptionContract, OptionsChain, Quote } from "../../../types/financials";
-import { buildQuoteKey, resolveEntryData } from "../../../market-data/selectors";
+import { buildQuoteKey, instrumentFromQuoteTarget, resolveEntryData } from "../../../market-data/selectors";
 import type { QueryEntry } from "../../../market-data/result-types";
 import type { OptionTableRow } from "./types";
 import { isFiniteNumber } from "../../../utils/guards";
@@ -75,9 +75,20 @@ function normalizeVisibleRange(
   return { start, end };
 }
 
+/**
+ * The broker profile a chain came from. Its contracts' quotes are asked of the
+ * same profile, so a broker that streams options (and no cloud stream) keeps
+ * the chain it served current, rather than leaving it to a slower source.
+ */
+export interface OptionQuoteBroker {
+  brokerId?: string;
+  brokerInstanceId?: string;
+}
+
 export function buildOptionQuoteTargets(
   rows: readonly OptionTableRow[],
   window: OptionQuoteTargetWindow,
+  broker?: OptionQuoteBroker,
 ): QuoteSubscriptionTarget[] {
   if (rows.length === 0) return [];
   const visibleRange = normalizeVisibleRange(rows.length, window);
@@ -101,6 +112,7 @@ export function buildOptionQuoteTargets(
       targets.set(symbol, {
         symbol,
         exchange: OPTIONS_QUOTE_EXCHANGE,
+        ...(broker ? { context: { brokerId: broker.brokerId, brokerInstanceId: broker.brokerInstanceId } } : {}),
         surface: "options",
         visible,
         selected,
@@ -119,10 +131,12 @@ export function buildOptionQuoteTargets(
   return [...targets.values()];
 }
 
-export function buildOptionQuoteKey(contractSymbol: string): string {
+export function buildOptionQuoteKey(contractSymbol: string, broker?: OptionQuoteBroker): string {
   return buildQuoteKey({
     symbol: contractSymbol,
     exchange: OPTIONS_QUOTE_EXCHANGE,
+    brokerId: broker?.brokerId,
+    brokerInstanceId: broker?.brokerInstanceId,
   });
 }
 
@@ -179,17 +193,20 @@ export interface LiveOptionsChain {
 }
 
 const EMPTY_STRIKES: ReadonlySet<number> = new Set();
-const contractKeyIndexes = new WeakMap<readonly OptionContract[], Map<string, number[]>>();
+const contractKeyIndexes = new WeakMap<readonly OptionContract[], Map<string, Map<string, number[]>>>();
 
-function contractKeyIndex(contracts: readonly OptionContract[]): Map<string, number[]> {
-  let index = contractKeyIndexes.get(contracts);
+function contractKeyIndex(contracts: readonly OptionContract[], broker?: OptionQuoteBroker): Map<string, number[]> {
+  const byBroker = contractKeyIndexes.get(contracts) ?? new Map<string, Map<string, number[]>>();
+  contractKeyIndexes.set(contracts, byBroker);
+  const brokerKey = `${broker?.brokerId ?? ""}|${broker?.brokerInstanceId ?? ""}`;
+  let index = byBroker.get(brokerKey);
   if (!index) {
     index = new Map();
     contracts.forEach((contract, position) => {
-      const key = buildOptionQuoteKey(contract.contractSymbol);
+      const key = buildOptionQuoteKey(contract.contractSymbol, broker);
       index!.set(key, [...(index!.get(key) ?? []), position]);
     });
-    contractKeyIndexes.set(contracts, index);
+    byBroker.set(brokerKey, index);
   }
   return index;
 }
@@ -204,12 +221,13 @@ export function overlayOptionChainQuotes(
   chain: OptionsChain,
   quoteEntries: ReadonlyMap<string, QueryEntry<Quote>>,
   freshness: OptionsQuoteFreshness,
+  broker?: OptionQuoteBroker,
 ): LiveOptionsChain {
   if (quoteEntries.size === 0) return { chain, streamedStrikes: EMPTY_STRIKES, quotedAt: null };
   const streamedStrikes = new Set<number>();
   let quotedAt: number | null = null;
   const overlay = (contracts: OptionContract[]): OptionContract[] => {
-    const index = contractKeyIndex(contracts);
+    const index = contractKeyIndex(contracts, broker);
     let next: OptionContract[] | null = null;
     for (const [key, entry] of quoteEntries) {
       const positions = index.get(key);
@@ -242,19 +260,16 @@ export function resolveOptionQuoteCoverage(
   quoteEntries: ReadonlyMap<string, QueryEntry<Quote>>,
   freshness: OptionsQuoteFreshness,
 ): OptionQuoteCoverage {
-  const visibleSymbols = new Set(
+  // Each target's own key: a chain's broker profile is part of it.
+  const visibleKeys = new Set(
     targets
-      .filter((target) => target.visible === true)
-      .map((target) => target.symbol.trim().toUpperCase())
-      .filter(Boolean),
+      .filter((target) => target.visible === true && target.symbol.trim())
+      .map((target) => buildQuoteKey(instrumentFromQuoteTarget(target))),
   );
   let liveCount = 0;
   let fallbackCount = 0;
-  for (const symbol of visibleSymbols) {
-    const quote = freshOptionQuote(
-      quoteEntries.get(buildOptionQuoteKey(symbol)),
-      freshness,
-    );
+  for (const key of visibleKeys) {
+    const quote = freshOptionQuote(quoteEntries.get(key), freshness);
     if (
       quote?.dataSource === "live"
       && quote.delivery === "stream"
@@ -266,7 +281,7 @@ export function resolveOptionQuoteCoverage(
     }
   }
 
-  const totalCount = visibleSymbols.size;
+  const totalCount = visibleKeys.size;
   const status: OptionQuoteCoverageStatus = totalCount > 0 && liveCount === totalCount
     ? "live"
     : liveCount > 0

package/src/plugins/builtin/options/view.tsx

@@ -1,11 +1,11 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { Box, Text, useUiCapabilities } from "../../../ui";
-import { usePaneSettingValue, usePaneTicker, useUpdatePaneSettings } from "../../../state/app/context";
+import { usePaneAppConfig, usePaneSettingValue, usePaneTicker, useUpdatePaneSettings } from "../../../state/app/context";
 import { colors, priceColor } from "../../../theme/colors";
 import { isPlainKey } from "../../../utils/keyboard";
 import { formatCompact, formatPercentRaw } from "../../../utils/format";
 import { formatMarketPrice, formatSignedMarketPrice, liveQuoteFormatOptions } from "../../../market-data/market/format";
-import { formatExpDate, resolveOptionsTarget } from "../../../utils/options";
+import { chainOptionContract, formatExpDate, optionContractName, resolveOptionsTarget } from "../../../utils/options";
 import {
   expiryIsoDate, findListedExpiry, formatDaysToExpiry, daysToExpiry, missingExpiryMessage, missingExpiryText, readOptionExpiration,
 } from "../../../utils/option-expiry";
@@ -34,7 +34,9 @@ import { useLiveQuoteEntries, useQuoteUpdates } from "../../../state/hooks/quote
 import { buildChartKey } from "../../../market-data/selectors";
 import type { ChartRequest } from "../../../market-data/request-types";
 import { quoteSubscriptionTargetFromTicker } from "../../../market-data/request-types";
-import { usePluginAppActions } from "../../runtime";
+import { usePluginAppActions, usePluginBrokerActions, usePluginTickerActions } from "../../runtime";
+import { brokerCanTrade, openTradeTicket } from "../broker-trading/command";
+import type { OptionContract } from "../../../types/financials";
 import { OPTIONS_CALCULATOR_TEMPLATE_ID } from "../options-calculator/model";
 import { buildChainCalcParams, resolveCalcSide } from "./calc-seed";
 import { useOptionsCatalogue } from "./expiry-catalogue";
@@ -66,7 +68,7 @@ import { signedPositionDirection } from "../../../portfolio/position-metrics";
 import { optionMarketReference } from "./market-reference";
 import { useOptionsEnrichment } from "./enrichment";
 import type { OptionsEnrichmentSnapshot } from "./enrichment-model";
-import { optionMid, type OptionSide } from "../shared/volatility";
+import { daysToExpiryFrom, optionMid, type OptionSide } from "../shared/volatility";
 import type { TickerRecord } from "../../../types/ticker";
 import type { TickerFinancials } from "../../../types/financials";
 import type { IvStats } from "../iv-history/client";
@@ -176,6 +178,9 @@ export function OptionsView({ width, height, focused, nestedInTabs = false, ivRa
   const ticker = useMemo(() => savedTicker ?? (boundSymbol ? transientTicker(boundSymbol, fallbackExchange, fallbackCurrency) : null),
     [savedTicker, boundSymbol, fallbackExchange, fallbackCurrency]);
   const { createPaneFromTemplate } = usePluginAppActions();
+  const { pinTicker } = usePluginTickerActions();
+  const { getBrokerAdapter } = usePluginBrokerActions();
+  const appConfig = usePaneAppConfig();
   const liveStreaming = useLiveStreamingSetting();
   // A number from the app, or the date or seconds `fn OMON --expiration` took as text.
   const [seededSetting] = usePaneSettingValue<unknown>("expiration", undefined);
@@ -238,13 +243,20 @@ export function OptionsView({ width, height, focused, nestedInTabs = false, ivRa
   const strikeWindowText = strikeWindowValue(strikeWindow);
   const initialChainEntry = useOptionsQuery(baseRequest);
   const initialChain = useResolvedEntryValue(initialChainEntry);
-  const initialExpiration = initialChain?.expirationDates.reduce((best, expiration) => (
+  // A listing can still carry a date whose 16:00 ET close has passed. The chain
+  // never opens there, nor on a saved date that has since passed: it takes the nearest live one.
+  const now = Date.now();
+  const liveExpiration = (expiration: number) => daysToExpiryFrom(expiration, now) > 0;
+  const listedExpirations = initialChain?.expirationDates ?? [];
+  const openingExpirations = listedExpirations.some(liveExpiration) ? listedExpirations.filter(liveExpiration) : listedExpirations;
+  const initialExpiration = openingExpirations.length === 0 ? undefined : openingExpirations.reduce((best, expiration) => (
     parsed && Math.abs(expiration - parsed.expTs) < Math.abs(best - parsed.expTs) ? expiration : best
-  ), initialChain.expirationDates[0]!);
+  ), openingExpirations[0]!);
   // A typed date names a day; the catalogue's stamp for that day is the expiry.
   const seededDate = readOptionExpiration(seededSetting);
-  const seededExpiration = seededDate == null ? undefined
-    : findListedExpiry(seededDate, initialChain?.expirationDates ?? []) ?? seededDate;
+  const seededListed = seededDate == null ? undefined : findListedExpiry(seededDate, listedExpirations) ?? seededDate;
+  const seededExpiration = seededListed != null && (liveExpiration(seededListed) || !openingExpirations.some(liveExpiration))
+    ? seededListed : undefined;
   const selectedExpiration = expirationTargetKey == null || expirationTargetKey === selectionTargetKey
     ? seededExpiration ?? initialExpiration : initialExpiration;
   const viewportKey = `${effectiveTicker}:${selectedExpiration ?? "initial"}`;
@@ -281,8 +293,11 @@ export function OptionsView({ width, height, focused, nestedInTabs = false, ivRa
     ?? (matchesSelectedExpiration(initialChain) ? initialChain : null);
   const strikesLoading = strikeChain === null && !expirationUnavailable;
   const expirationDates = useMemo(() => {
-    return selectedExpirationMissing
+    const listed = selectedExpirationMissing
       ? [...availableExpirations, selectedExpiration!].sort((left, right) => left - right) : availableExpirations;
+    // A date that has ended has no contracts left to show; the strip leaves it out, unless every date has.
+    const current = (expiration: number) => daysToExpiry(expiration, Date.now()) >= 0;
+    return listed.some(current) ? listed.filter((expiration) => expiration === selectedExpiration || current(expiration)) : listed;
   }, [availableExpirations, selectedExpiration, selectedExpirationMissing]);
   // Keep the date strip stable while a mouse press focuses this pane. A new
   // tab list asks the web host to reveal the active tab and can move the date
@@ -468,13 +483,17 @@ export function OptionsView({ width, height, focused, nestedInTabs = false, ivRa
         : { key: viewportKey, range }
     ));
   }, [viewportKey]);
+  // A chain read from a broker profile has its contracts quoted by that profile too.
+  const quoteBrokerId = instrument?.brokerId, quoteBrokerInstanceId = instrument?.brokerInstanceId;
+  const optionQuoteBroker = useMemo(() => quoteBrokerId || quoteBrokerInstanceId
+    ? { brokerId: quoteBrokerId, brokerInstanceId: quoteBrokerInstanceId } : undefined, [quoteBrokerId, quoteBrokerInstanceId]);
   const optionQuoteTargets = useMemo(
     () => buildOptionQuoteTargets(quoteRows, {
       fallbackHeight: height,
       selectedIndex: selectedStrikeIdx,
       visibleRange: visibleStrikeRange,
-    }),
-    [height, quoteRows, selectedStrikeIdx, visibleStrikeRange],
+    }, optionQuoteBroker),
+    [height, quoteRows, selectedStrikeIdx, visibleStrikeRange, optionQuoteBroker],
   );
   const {
     entries: optionQuoteEntries,
@@ -497,8 +516,8 @@ export function OptionsView({ width, height, focused, nestedInTabs = false, ivRa
   // The snapshot object itself comes back while nothing streamed, so the
   // memos below only recompute when a quote actually landed.
   const liveChain = useMemo(
-    () => strikeChain ? overlayOptionChainQuotes(strikeChain, optionQuoteEntries, optionQuoteFreshness).chain : null,
-    [optionQuoteEntries, optionQuoteFreshness, strikeChain],
+    () => strikeChain ? overlayOptionChainQuotes(strikeChain, optionQuoteEntries, optionQuoteFreshness, optionQuoteBroker).chain : null,
+    [optionQuoteEntries, optionQuoteFreshness, strikeChain, optionQuoteBroker],
   );
   const callsByStrike = useMemo(
     () => new Map(liveChain?.calls.map((c) => [c.strike, c]) ?? []),
@@ -672,6 +691,28 @@ export function OptionsView({ width, height, focused, nestedInTabs = false, ivRa
   }, [scenarioContract, scenarioAvailable, scenarioMid, scenarioVolatility, createPaneFromTemplate, dividendYield, effectiveTicker,
     effectiveExchange, selectedSide, spot, underlying?.quote?.lastUpdated]);
 
+  // A contract opens as its own listing: quote, chart and Trade. It stays on
+  // the chain's broker while that profile is on, else it opens by its symbol.
+  const contractListing = useCallback((contract: OptionContract) => {
+    const symbol = contract.contractSymbol.trim().toUpperCase();
+    const currency = contract.currency || underlying?.quote?.currency || "USD";
+    const brokerOn = !!instrument && appConfig.brokerInstances.some((profile) => profile.id === instrument.brokerInstanceId && profile.enabled !== false);
+    return { symbol, selection: { instrument: brokerOn ? chainOptionContract(symbol, instrument, currency) : null,
+      listing: { name: optionContractName(symbol) ?? symbol, exchange: "", currency, type: "OPT" } } };
+  }, [appConfig.brokerInstances, instrument, underlying?.quote?.currency]);
+  const openContract = useCallback((contract: OptionContract | null | undefined) => {
+    if (!contract) return;
+    const { symbol, selection } = contractListing(contract);
+    pinTicker(symbol, selection);
+  }, [contractListing, pinTicker]);
+  const tradable = !!scenarioContract && brokerCanTrade(appConfig.brokerInstances, getBrokerAdapter, scenarioContract.contractSymbol.trim().toUpperCase(), "OPT");
+  const tradeContract = useCallback(() => {
+    if (!scenarioContract || !tradable) return;
+    const { symbol, selection } = contractListing(scenarioContract);
+    // A new contract's ticket starts on Buy; b and s choose the side in it.
+    openTradeTicket({ pinTicker }, symbol, { action: "BUY" }, selection);
+  }, [contractListing, pinTicker, scenarioContract, tradable]);
+
   const openSurface = useCallback(() => {
     if (!ticker || selectedExpiration == null) return;
     createPaneFromTemplate("vol-surface-pane", { symbol: ticker.metadata.ticker, ticker, instrument,
@@ -703,12 +744,14 @@ export function OptionsView({ width, height, focused, nestedInTabs = false, ivRa
     setCalcSide(sideTarget);
   }, [selectContract, selectedRow, selectedStrikeIdx, sideTarget]);
 
+  // With a broker that trades the contract, [t]rade opens its ticket on Buy, and Sell is chosen there.
   const footerHints = useMemo(() => [
     ...(sideTarget ? [{ id: "side", key: SIDE_KEY, label: ` ${sideTarget}`, title: sideTarget === "put" ? "Select Put" : "Select Call", onPress: switchSide }] : []),
+    ...(tradable ? [{ id: "trade-contract", key: "t", label: "rade", title: "Trade Contract", onPress: tradeContract }] : []),
     ...(calcParams ? [{ id: "calc", key: "c", label: "alc", onPress: openCalculator }] : []),
     ...(scenarioAvailable ? [{ id: "scenario", key: "a", label: "dd to OSA", onPress: openScenario }] : []),
     ...(ticker && selectedExpiration != null ? [{ id: "surface", key: "s", label: "urface", onPress: openSurface }] : []),
-  ], [sideTarget, switchSide, calcParams, openCalculator, scenarioAvailable, openScenario, ticker, selectedExpiration, openSurface]);
+  ], [sideTarget, switchSide, tradable, tradeContract, calcParams, openCalculator, scenarioAvailable, openScenario, ticker, selectedExpiration, openSurface]);
 
   // Back to where the chain opens: the held contract's strike, else the money.
   const defaultStrikeIndex = strikes.length === 0 ? -1 : (() => {
@@ -732,8 +775,10 @@ export function OptionsView({ width, height, focused, nestedInTabs = false, ivRa
     { id: "default-strike", label: parsed ? "Go to Held Strike" : "Go to ATM Strike",
       enabled: defaultStrikeIndex >= 0, onSelect: goToDefaultStrike },
     ...(enrichment?.asOf && dialog ? [{ id: "analytics-as-of", label: "Analytics As Of…", onSelect: showAnalyticsAsOf }] : []),
+    { id: "open-contract", label: "Open Contract", accelerator: "Enter", enabled: !!scenarioContract, onSelect: () => openContract(scenarioContract) },
+    ...(tradable ? [{ id: "trade-contract", label: "Trade Contract", accelerator: "t", onSelect: tradeContract }] : []),
   ], [defaultStrikeIndex, dialog, enrichment?.asOf, expirationDates.length, goToDefaultStrike, parsed,
-    selectAdjacentExpiration, selectedExpirationIndex, showAnalyticsAsOf]);
+    selectAdjacentExpiration, selectedExpirationIndex, showAnalyticsAsOf, scenarioContract, openContract, tradable, tradeContract]);
 
   const renderCell = useCallback((
     row: OptionTableRow,
@@ -756,6 +801,7 @@ export function OptionsView({ width, height, focused, nestedInTabs = false, ivRa
   }, [selectContract, selectedSide]);
 
   useOptionsAccessFooter({
+    broker: !!optionQuoteBroker,
     chain,
     error: [error, underlyingStale ? "Underlying quote stale: Greeks and calculator unavailable" : null,
       selectedContract && strikeChain && !selectedContractAvailable
@@ -789,7 +835,21 @@ export function OptionsView({ width, height, focused, nestedInTabs = false, ivRa
   // the arrows for it; in a research tab those stay with the tab strip.
   useShortcut((event) => {
     if (event.defaultPrevented || event.propagationStopped || event.targetEditable) return;
-    if (event.ctrl || event.meta || event.alt || event.shift) return;
+    if (event.ctrl || event.meta || event.alt) return;
+    const surface = isPlainKey(event, "s");
+    if (surface && ticker && selectedExpiration != null) {
+      event.preventDefault();
+      event.stopPropagation();
+      openSurface();
+      return;
+    }
+    if (event.shift) return;
+    if (tradable && isPlainKey(event, "t") && !event.repeat) {
+      event.preventDefault();
+      event.stopPropagation();
+      tradeContract();
+      return;
+    }
 
     const expiryStep = isPlainKey(event, EXPIRY_PREVIOUS_KEY) || (!nestedInTabs && isPlainKey(event, "h", "left")) ? -1
       : isPlainKey(event, EXPIRY_NEXT_KEY) || (!nestedInTabs && isPlainKey(event, "l", "right")) ? 1 : 0;
@@ -799,12 +859,6 @@ export function OptionsView({ width, height, focused, nestedInTabs = false, ivRa
       selectAdjacentExpiration(expiryStep);
       return;
     }
-    if (isPlainKey(event, "s") && ticker && selectedExpiration != null) {
-      event.preventDefault();
-      event.stopPropagation();
-      openSurface();
-      return;
-    }
     if (isPlainKey(event, "c") && calcParams) {
       event.preventDefault();
       event.stopPropagation();
@@ -925,6 +979,7 @@ export function OptionsView({ width, height, focused, nestedInTabs = false, ivRa
         onVisibleRangeChange={handleVisibleStrikeRangeChange}
         getItemKey={(row) => String(row.strike)}
         renderCell={renderCell}
+        onActivate={(row) => openContract(selectedSide === "put" ? row.put : selectedSide === "call" ? row.call : null)}
         selectedTextOverridesCellColor
         emptyStateTitle={unavailableExpiry ?? (error && !strikeChain ? "Selected expiration unavailable." : strikesLoading ? "Loading strikes..."
           : strikeWindowResult.total > 0 ? "No strikes in this window." : "No strikes available.")}

package/src/plugins/builtin/options-calculator/pane.tsx

@@ -1,5 +1,5 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { FieldGrid, KeyValueRow, QueryBar, usePaneFooter, usePaneNoticeFooter, type GridField } from "../../../components";
+import { delayedFooterSegment, FieldGrid, KeyValueRow, QueryBar, usePaneFooter, usePaneNoticeFooter, type GridField } from "../../../components";
 import { CompositeChart } from "../../../components/chart/composite/composite-chart";
 import { usePaneRefreshKey } from "../../../components/data-table/table-pane";
 import { useAsyncResource, useInputCapture } from "../../../public/react";
@@ -279,7 +279,9 @@ export function OptionsCalculatorPane({ focused, width, height }: PaneProps) {
       ...(surfaceSource && surfaceResource.loading ? [{ id: "loading", parts: [{ text: "loading surface", tone: "muted" as const }] }] : []),
       ...(surfaceSource && surface?.asOf ? [{ id: "surface-asof", parts: [{ text: `surface · ${surface.asOf}`, tone: "muted" as const }] }] : []),
       ...(effectiveSteps && effectiveSteps !== (draft.steps ?? 400) ? [{ id: "refined", parts: [{ text: `tree refined to ${effectiveSteps} steps`, tone: "muted" as const }] }] : []),
-      ...(liveInputs ? [{ id: "market", parts: [{ text: liveInputs.delayed ? "delayed market" : "real-time market", tone: "muted" as const }] }] : []),
+      ...(liveInputs ? [liveInputs.delayed
+        ? delayedFooterSegment({ id: "market", detail: "Delayed market inputs" })
+        : { id: "market", parts: [{ text: "real-time market", tone: "muted" as const }] }] : []),
     ],
     hints: activeFieldId ? [] : [
       // Names the cell Enter or `e` edits, which the grid does not mark.