gloomberb 0.18.2 → 0.18.4

package/src/plugins/builtin/broker-trading/orders.tsx

@@ -1,9 +1,11 @@
+import { logFailure } from "../../../utils/log-failure";
 import { useCallback, useEffect, useId, useMemo, useReducer, useRef, useState, useSyncExternalStore } from "react";
 import {
   Badge, Button, DataTableView, IconButton, PaneStatusBody, RatioBar, SegmentedControl, Notice, SectionHeading, confirmDialog, usePaneFooter, usePaneNoticeFooter,
   type DataTableCell, type DataTableColumn, type SelectControl,
 } from "../../../components";
 import { loadingErrorFooterInfo, usePaneRefreshKey } from "../../../components/data-table/table-pane";
+import { useRowNotes } from "../../../components/ui/row-notes";
 import { useAsyncResource } from "../../../react/async-resource";
 import { useShortcut } from "../../../react/input";
 import { usePaneVisible } from "../../../state/app/activity";
@@ -25,6 +27,7 @@ import { orderInstrumentLabel, strategyShape } from "./strategy";
 import { stepNumber } from "../../../components/ui/number-step";
 import { ticketTypeName } from "./ticket-parts";
 import { wrapTextLines } from "../../../utils/text-wrap";
+import { linkedOrderRows, linkRoleName, linkRoleShort, trailingText } from "./linked-orders";
 
 export interface BrokerOrdersViewProps {
   broker: BrokerAdapter;
@@ -64,10 +67,23 @@ const activityColumns: DataTableColumn[] = [
   { id: "quantity", label: "Quantity", width: 12, align: "right" }, { id: "price", label: "Price", width: 12, align: "right" },
   { id: "fees", label: "Fees", width: 12, align: "right" }, { id: "age", label: "Age", width: 5, align: "right" },
 ];
-/** An order's type, prices and time in force, as a cancellation names them: "Limit 336.50 · DAY". */
+/** An order's type, prices and time in force, as a cancellation names them: "Limit 336.50 · DAY", "Take profit, limit 345.00 · GTC". */
 function orderTerms(order: BrokerOrder): string {
+  if (order.orderType === "TRAIL") return `${trailingText(order, price)} · ${order.tif ?? "DAY"}`;
   const prices = order.orderType === "MKT" ? "" : order.orderType === "STP LMT" ? ` ${price(order.stopPrice)}, limit ${price(order.limitPrice)}` : ` ${price(order.limitPrice ?? order.stopPrice)}`;
-  return `${ticketTypeName[order.orderType] ?? order.orderType}${prices} · ${order.tif ?? "DAY"}`;
+  const role = order.linkRole && order.linkRole !== "entry" ? `${linkRoleName[order.linkRole]}, ` : "";
+  return `${role}${role ? (ticketTypeName[order.orderType] ?? order.orderType).toLowerCase() : ticketTypeName[order.orderType] ?? order.orderType}${prices} · ${order.tif ?? "DAY"}`;
+}
+
+/** "TP", "SL", "Trail": what a one-line row says an order is beside its price. */
+const rowTag = (order: BrokerOrder) => order.linkRole && order.linkRole !== "entry" ? linkRoleShort[order.linkRole] : order.orderType === "TRAIL" ? "Trail" : "";
+
+/** A price as a row shows it: market, the limit or stop, or a trailing stop's trigger and distance. */
+function orderPriceText(order: BrokerOrder): string {
+  if (order.orderType === "MKT") return "Market";
+  // Its trigger where the broker reports one, else its distance: the type column says it trails.
+  if (order.orderType === "TRAIL") return order.stopPrice !== undefined ? price(order.stopPrice) : order.trailingPercent !== undefined ? `${quantity(order.trailingPercent)}%` : price(order.trailingAmount);
+  return price(order.limitPrice ?? order.stopPrice);
 }
 
 function age(timestamp: number, now: number): string {
@@ -79,11 +95,27 @@ function age(timestamp: number, now: number): string {
   return `${Math.floor(seconds / 86400)}d`;
 }
 
-function renderOrderCell(order: BrokerOrder, column: DataTableColumn, now: number): DataTableCell {
+/**
+ * What a cancel this view sent came to, said on the order's row while it is listed: `status` in STATUS (none keeps
+ * the broker's own word, as when the order filled first), `text` under the table while the row is selected.
+ */
+interface OrderNote {
+  text: string;
+  status?: string;
+  tone: "negative" | "warning";
+}
+
+/** The order's state as the broker reports it: a later one is newer news than a note about a cancel. */
+const orderSignature = (order: BrokerOrder) => brokerOrderStatus(order.status);
+
+function renderOrderCell(order: BrokerOrder, column: DataTableColumn, now: number, child = false, note: OrderNote | null = null): DataTableCell {
   const status = brokerOrderStatus(order.status);
   switch (column.id) {
-    case "symbol": return { text: orderInstrumentLabel(order), attributes: TextAttributes.BOLD };
+    // A bracket's exits sit indented under their entry, named by what they do.
+    case "symbol": return child && order.linkRole ? { text: linkRoleShort[order.linkRole], content: <Box paddingLeft={2}><Text fg={colors.textDim} wrapMode="none">{linkRoleShort[order.linkRole]}</Text></Box> }
+      : { text: `${orderInstrumentLabel(order)}${order.linkRole && order.linkRole !== "entry" ? ` ${linkRoleShort[order.linkRole]}` : ""}`, attributes: TextAttributes.BOLD };
     case "status": {
+      if (note?.status) return { text: note.status, content: <Badge label={note.status} tone={note.tone} /> };
       const tone = status === "Rejected" ? "negative" : status === "Filled" ? "positive" : ["UNKNOWN", "Pending cancel", "Partially filled"].includes(status) ? "warning" : "accent";
       return { text: status, content: <Badge label={status === "Partially filled" ? "Partial fill" : status} variant={status === "Working" ? "solid" : "subtle"} tone={tone} /> };
     }
@@ -92,8 +124,8 @@ function renderOrderCell(order: BrokerOrder, column: DataTableColumn, now: numbe
       <RatioBar ratio={order.quantity > 0 ? order.filled / order.quantity : 0} width={4} color={order.filled > 0 ? colors.positive : colors.textMuted} track thickness={5} />
       <Text fg={colors.text} truncate wrapMode="none">{`${quantity(order.filled)} / ${quantity(order.quantity)}`}</Text>
     </Box> };
-    case "type": return { text: order.orderType };
-    case "price": return { text: order.orderType === "MKT" ? "Market" : price(order.limitPrice ?? order.stopPrice) };
+    case "type": return { text: order.orderType === "TRAIL" ? "TRL" : order.orderType };
+    case "price": return { text: orderPriceText(order) };
     default: return { text: age(order.updatedAt, now), color: colors.textDim };
   }
 }
@@ -152,15 +184,9 @@ export function BrokerOrdersView({
   const context = useRef<BrokerTradingContext>({ adapter: broker, instance, accounts, accountId, connection });
   context.current = { adapter: broker, instance, accounts, accountId, connection };
   const { notify } = usePluginAppActions();
-  // What a refused cancel came to, said once: the order feed records it quietly and reads the list again.
+  // What a refused cancel came to, said once (see `report` below).
   const onOutcome = useRef<(outcome: BrokerOrderOutcome) => void>(() => {});
-  onOutcome.current = (outcome) => {
-    brokerOrderFeed.note(instance.id, outcome.order);
-    brokerOrderFeed.refresh(instance.id);
-    notify({ type: outcome.type, title: outcome.title, body: orderToastBody(outcome.order) });
-  };
   const controller = useMemo(() => new BrokerTradingController({ getContext: () => context.current, onOutcome: (outcome) => onOutcome.current(outcome) }), [broker, instance.id]);
-  const failed = useCallback((error: unknown, fallback: string) => notify({ type: "error", body: error instanceof Error && error.message ? error.message : fallback }), [notify]);
   const trading = useSyncExternalStore(controller.subscribe, controller.getSnapshot, controller.getSnapshot);
   useEffect(() => () => controller.dispose(), [controller]);
   useEffect(() => { controller.syncContext(); }, [controller, instance, accountId, accounts, connection.state]);
@@ -185,11 +211,11 @@ export function BrokerOrdersView({
   const unknown = trading.result?.status.toUpperCase() === "UNKNOWN";
   useEffect(() => {
     if (!canRead || !visible || (feed.live && !unknown) || !trading.result || brokerOrderDone(trading.result.status)) return;
-    const timer = setInterval(() => { void controller.refreshResult().catch(() => {}); }, 15_000);
+    const timer = setInterval(() => { void controller.refreshResult().catch(logFailure("broker-trading.orders", "Poll cancelled broker order failed")); }, 15_000);
     return () => clearInterval(timer);
   }, [canRead, visible, feed.live, unknown, trading.result, controller]);
   const refresh = useCallback(() => {
-    void controller.refreshResult().catch(() => {});
+    void controller.refreshResult().catch(logFailure("broker-trading.orders", "Refresh broker order result failed"));
     brokerOrderFeed.refresh(instance.id);
     void reload();
   }, [controller, reload, instance.id]);
@@ -218,8 +244,43 @@ export function BrokerOrdersView({
   }, [snapshot, trading.result, accountId, instance.id, contract, latestOrder]);
   // Keep terminal acknowledgements in the projection even after hiding their rows.
   // The full list shows an order that ended only when it is the one this view just acted on.
-  const rows = useMemo(() => reconciledRows.filter((order) => !brokerOrderDone(order.status)
-    || (!compact && !!trading.result && brokerOrderKey(order) === brokerOrderKey(trading.result))), [compact, reconciledRows, trading.result]);
+  // A bracket's or OCO pair's orders list together, the entry first.
+  const linkedRows = useMemo(() => linkedOrderRows(reconciledRows.filter((order) => !brokerOrderDone(order.status)
+    || (!compact && !!trading.result && brokerOrderKey(order) === brokerOrderKey(trading.result)))), [compact, reconciledRows, trading.result]);
+  const rows = useMemo(() => linkedRows.map((row) => row.order), [linkedRows]);
+  const notes = useRowNotes<BrokerOrder, OrderNote>(rows, { key: brokerOrderKey, signature: orderSignature });
+  const setNote = notes.setNote;
+  const rowsRef = useRef(rows); rowsRef.current = rows;
+  /**
+   * What a cancel came to goes on the order's row while the list shows it as it now reads (the full list keeps the
+   * order this view acted on after it ended, the drawer only open ones), and in a toast once it has left.
+   */
+  const report = useCallback((order: BrokerOrder, note: OrderNote, toast: { type: "info" | "error"; title?: string; body: string }) => {
+    const key = brokerOrderKey(order);
+    if (rowsRef.current.some((row) => brokerOrderKey(row) === key) && (!compact || !brokerOrderDone(order.status))) setNote(key, note);
+    else notify(toast);
+  }, [compact, notify, setNote]);
+  // The order feed records a refused cancel quietly and reads the list again.
+  onOutcome.current = (outcome) => {
+    brokerOrderFeed.note(instance.id, outcome.order);
+    brokerOrderFeed.refresh(instance.id);
+    // An order that ended first keeps the broker's word in STATUS (Filled); one that stands says the cancel was refused.
+    report(outcome.order, { text: outcome.title, status: brokerOrderDone(outcome.order.status) ? undefined : "Cancel refused", tone: outcome.type === "error" ? "negative" : "warning" },
+      { type: outcome.type, title: outcome.title, body: orderToastBody(outcome.order) });
+  };
+  const failed = useCallback((order: BrokerOrder, error: unknown) => {
+    const text = error instanceof Error && error.message ? error.message : "Cancellation could not be confirmed.";
+    report(order, { text, status: "Cancel failed", tone: "negative" }, { type: "error", body: text });
+    // A cancel that never went out leaves its question, so the row and what became of it show again.
+    setInlineCancel(false);
+    if (controller.getSnapshot().phase === "cancel-review") {
+      void controller.confirmCancel(false).catch(() => { /* Intentional ignore: the cancel already failed and its row says why. */ });
+    }
+  }, [controller, report]);
+  /** The note on a row, or the outcome of its cancel the broker has not confirmed yet. */
+  const noteFor = useCallback((order: BrokerOrder): OrderNote | null => notes.noteFor(order)
+    ?? (trading.error && trading.result && brokerOrderKey(trading.result) === brokerOrderKey(order) ? { text: trading.error, tone: "warning" } : null), [notes, trading.error, trading.result]);
+  const childKeys = useMemo(() => new Set(linkedRows.filter((row) => row.child).map((row) => brokerOrderKey(row.order))), [linkedRows]);
   useEffect(() => { onOrders?.(reconciledRows); }, [reconciledRows, onOrders]);
   // Only an order the trader chose is selected: c, m and Enter never fall back to another row.
   const selected = rows.find((order) => brokerOrderKey(order) === selectedKey);
@@ -238,12 +299,18 @@ export function BrokerOrdersView({
   const canCancel = changeable && !!broker.cancelOrder && capabilities?.cancel === true;
   const modifyOrder = useCallback((order: BrokerOrder) => {
     const capability = broker.getTradingCapabilities?.(instance, order.contract);
-    if (canRead && !busy && broker.modifyOrder && capability?.enabled && capability.modify && canChangeBrokerOrder(order)) onModify(order);
-  }, [broker, instance, canRead, busy, onModify]);
+    if (!canRead || busy || !broker.modifyOrder || !capability?.enabled || !capability.modify || !canChangeBrokerOrder(order)) return;
+    setNote(brokerOrderKey(order), null);
+    onModify(order);
+  }, [broker, instance, canRead, busy, onModify, setNote]);
   const modify = useCallback(() => { const order = rows.find((row) => brokerOrderKey(row) === selectedKeyRef.current); if (order) modifyOrder(order); }, [rows, modifyOrder]);
   const cancelOrder = useCallback(async (order: BrokerOrder) => {
     const capability = broker.getTradingCapabilities?.(instance, order.contract);
     if (!account || !canRead || busy || !broker.cancelOrder || !capability?.enabled || !capability.cancel || !canChangeBrokerOrder(order)) return;
+    // The order acted on is the one chosen, so what the cancel comes to shows for it; the last one's goes.
+    const key = brokerOrderKey(order);
+    selectedKeyRef.current = key; setSelectedKey(key);
+    setNote(key, null);
     try {
       controller.requestCancel(order);
       if (compact) { setInlineCancel(true); setKeepOrder(false); return; }
@@ -254,18 +321,19 @@ export function BrokerOrdersView({
       });
       await controller.confirmCancel(confirmed);
       if (confirmed) {
-        if (controller.getSnapshot().result?.status === "PENDING_CANCEL") await controller.refreshResult().catch(() => {});
+        if (controller.getSnapshot().result?.status === "PENDING_CANCEL") await controller.refreshResult().catch(logFailure("broker-trading.orders", "Read pending broker cancellation failed"));
         brokerOrderFeed.refresh(instance.id);
       }
     } catch (error) {
-      failed(error, "Cancellation could not be confirmed.");
+      failed(order, error);
     }
-  }, [account, canRead, busy, broker, instance, controller, dialog, compact, failed]);
+  }, [account, canRead, busy, broker, instance, controller, dialog, compact, failed, setNote]);
   const cancel = useCallback(() => { const order = rows.find((row) => brokerOrderKey(row) === selectedKeyRef.current); return order ? cancelOrder(order) : Promise.resolve(); }, [rows, cancelOrder]);
   const confirmInline = async (confirmed: boolean) => {
-    if (controller.getSnapshot().phase !== "cancel-review") return;
+    const order = controller.getSnapshot().cancelOrder;
+    if (controller.getSnapshot().phase !== "cancel-review" || !order) return;
     try { await controller.confirmCancel(confirmed); setInlineCancel(false); if (confirmed) brokerOrderFeed.refresh(instance.id); }
-    catch (failure) { failed(failure, "Cancellation could not be confirmed."); }
+    catch (failure) { failed(order, failure); }
   };
   useShortcut((event) => {
     if (event.defaultPrevented || event.propagationStopped || event.targetEditable || event.ctrl || event.meta || event.alt || event.super) return;
@@ -295,7 +363,7 @@ export function BrokerOrdersView({
         selectedKeyRef.current = brokerOrderKey(next); setSelectedKey(selectedKeyRef.current); setPriceEdit(undefined);
       } else if (!order) {
         // The arrows and Enter act on a chosen order only.
-      } else if ((event.name === "up" || event.name === "down") && canModify && order.orderType !== "MKT") {
+      } else if ((event.name === "up" || event.name === "down") && canModify && order.orderType !== "MKT" && order.orderType !== "TRAIL") {
         const key = brokerOrderKey(order);
         const current = priceEditRef.current?.key === key ? priceEditRef.current.value : String(order.limitPrice ?? order.stopPrice ?? "");
         const caps = broker.getTradingCapabilities?.(instance, order.contract, order.orderType as BrokerOrderType);
@@ -321,8 +389,12 @@ export function BrokerOrdersView({
     if (!event.repeat) invoke();
   }, { enabled: focused && active && !dialogOpen, phase: "before", scope: keyboardScope });
 
-  const status = connection.state !== "connected" ? "Broker disconnected" : trading.error ?? resource.error
+  // An unconfirmed cancel is its order's, and said on its row while that is listed.
+  const resultListed = !!trading.result && rows.some((order) => brokerOrderKey(order) === brokerOrderKey(trading.result!));
+  const status = connection.state !== "connected" ? "Broker disconnected" : (resultListed ? null : trading.error) ?? resource.error
     ?? (capabilities?.enabled === false ? capabilities.disabledReason ?? "Trading is off" : null);
+  // The open list has no detail (Enter changes the order), so the chosen order's note shows in full under it.
+  const selectedNote = view === "open" && selected ? noteFor(selected) : null;
   usePaneNoticeFooter({ registrationId: "broker-orders-notices", focused, enabled: active, notices: [...(snapshot?.errors ?? []), ...(snapshot?.notes ?? [])] });
   usePaneFooter("broker-orders", () => active ? {
     info: loadingErrorFooterInfo(resource.loading || trading.phase === "cancelling", status),
@@ -349,7 +421,8 @@ export function BrokerOrdersView({
   // Confirming a cancel takes a question, its wrapped note and the two buttons (the note's width is allowed some slack).
   const contentRows = trading.phase === "cancel-review" ? 1 + [...cancelLines(trading.cancelOrder), CANCEL_NOTE]
     .reduce((rows, text) => rows + Math.max(1, wrapTextLines(text, Math.max(12, width - 6)).length), 0)
-    : (view === "open" ? rows.length : executions.length) + (snapshot?.errors?.length ?? 0);
+    : (view === "open" ? rows.length : executions.length) + (snapshot?.errors?.length ?? 0)
+      + (selectedNote ? wrapTextLines(selectedNote.text, Math.max(12, width - 2)).length : 0);
   useEffect(() => { if (compact) onContentRows?.(contentRows); }, [compact, contentRows, onContentRows]);
 
 
@@ -377,6 +450,7 @@ export function BrokerOrdersView({
         const allowed = broker.getTradingCapabilities?.(instance, order.contract);
         const disabled = !canRead || busy || !allowed?.enabled || !canChangeBrokerOrder(order);
         const state = brokerOrderStatus(order.status);
+        const note = noteFor(order);
         // One line: side and size, price, state, then edit and cancel as icons.
         return <Box key={key} position="relative" flexDirection="row" alignItems="center" gap={1} paddingLeft={1} height={native ? 1.6 : 1} backgroundColor={picked ? colors.panel : undefined}>
           {picked ? <Box position="absolute" left={0} top={0} width={1} height="100%" backgroundColor={focused ? colors.borderFocused : colors.border} style={native ? { width: 2 } : undefined} /> : null}
@@ -387,8 +461,10 @@ export function BrokerOrdersView({
                 <Text fg={order.action === "BUY" ? colors.positive : colors.negative} attributes={TextAttributes.BOLD} flexShrink={0}>{`${order.action === "BUY" ? "Buy" : "Sell"} ${quantity(order.quantity)}`}</Text>
                 {/* The drawer is the ticker's: a spread names its shape, the stock needs no name. */}
                 {order.legs?.length ? <Text fg={colors.text} truncate wrapMode="none" flexShrink={1} minWidth={0}>{strategyShape(order.legs)}</Text> : null}
-                <Text fg={colors.text} selectable flexShrink={0}>{priceEdit?.key === key ? `→ ${priceEdit.value}` : order.orderType === "MKT" ? "Mkt" : price(order.limitPrice ?? order.stopPrice)}</Text>
-                <Text fg={colors.warning} truncate wrapMode="none" flexShrink={1} minWidth={0}>{compactOrderState(order)}</Text>
+                {/* A bracket's exit or an OCO order says which it is; a trailing stop that it trails. */}
+                {rowTag(order) ? <Text fg={colors.textDim} flexShrink={0}>{rowTag(order)}</Text> : null}
+                <Text fg={colors.text} selectable flexShrink={0}>{priceEdit?.key === key ? `→ ${priceEdit.value}` : order.orderType === "MKT" ? "Mkt" : order.orderType === "TRAIL" ? orderPriceText(order) : price(order.limitPrice ?? order.stopPrice)}</Text>
+                <Text fg={note?.status && note.tone === "negative" ? colors.negative : colors.warning} truncate wrapMode="none" flexShrink={1} minWidth={0}>{note?.status ?? compactOrderState(order)}</Text>
               </Box>
             </Button>
           </Box>
@@ -400,6 +476,7 @@ export function BrokerOrdersView({
       }) : executions.map((execution) => <Box key={execution.execId} paddingX={1} height={native ? 1.6 : 1} flexDirection="row" alignItems="center">
         <Text selectable>{`${execution.side} ${quantity(execution.shares)} @ ${price(execution.price)}`}</Text>
       </Box>)}
+      {selectedNote ? <Box paddingX={1}><Notice tone={selectedNote.tone}>{selectedNote.text}</Notice></Box> : null}
       {!resource.loading && (view === "open" ? feed.loaded && !rows.length : !executions.length) ? <Box paddingX={1}><Text fg={colors.textDim}>{view === "open" ? "No open orders for this ticker." : "No recent activity."}</Text></Box> : null}
     </ScrollBox>}
   </Box>;
@@ -416,7 +493,7 @@ export function BrokerOrdersView({
       empty={!account || !canRead} emptyTitle={!account ? "Choose an account to see its orders." : "Connect this broker in Brokers to read orders."}>
       {view === "open" ? <DataTableView<BrokerOrder> rootWidth={width} rootHeight={Math.max(2, height - 2)} focused={focused && !busy && !dialogOpen}
         columns={orderColumns} items={rows} sortColumnId={null} sortDirection="desc" getItemKey={brokerOrderKey} renderCell={(order, column) => {
-          if (column.id !== "actions") return renderOrderCell(order, column, now);
+          if (column.id !== "actions") return renderOrderCell(order, column, now, childKeys.has(brokerOrderKey(order)), noteFor(order));
           if (brokerOrderDone(order.status)) return { text: "" };
           const allowed = broker.getTradingCapabilities?.(instance, order.contract);
           const disabled = !canRead || busy || !allowed?.enabled || !canChangeBrokerOrder(order);
@@ -426,7 +503,8 @@ export function BrokerOrdersView({
           </Box> };
         }}
         selection={{ kind: "id", selectedId: selected ? brokerOrderKey(selected) : "", getId: brokerOrderKey, onChange: (key) => { selectedKeyRef.current = key; setSelectedKey(key); } }}
-        onActivate={modifyOrder} selectedTextOverridesCellColor emptyStateTitle="No open orders in this account." />
+        onActivate={modifyOrder} selectedTextOverridesCellColor emptyStateTitle="No open orders in this account."
+        rootAfter={selectedNote ? <Box paddingX={1} flexShrink={0}><Notice tone={selectedNote.tone}>{selectedNote.text}</Notice></Box> : undefined} />
         : <DataTableView<BrokerExecution> rootWidth={width} rootHeight={Math.max(2, height - 2)} focused={focused && !dialogOpen}
           columns={activityColumns.map((column) => column.id === "quantity" && summaries ? { ...column, label: "Cumulative qty" } : column)}
           items={snapshot?.executions ?? []} sortColumnId={null} sortDirection="desc" getItemKey={(execution) => execution.execId}

package/src/plugins/builtin/broker-trading/overview-orders.tsx

@@ -1,3 +1,4 @@
+import { logFailure } from "../../../utils/log-failure";
 import { useCallback, useEffect, useMemo, useState } from "react";
 import { ActionRow, SectionHeading } from "../../../components";
 import { useAsyncResource } from "../../../react/async-resource";
@@ -16,6 +17,7 @@ import { strategyShape } from "./strategy";
 import { brokerOrderDone, brokerOrderKey, brokerOrderStatus, canChangeBrokerOrder, formatOrderPrice as money, formatOrderQuantity as amount, isBuySide } from "./orders-data";
 import { useBrokerOrderFeeds } from "./order-feed";
 import { ticketTypeName } from "./ticket-parts";
+import { linkRoleName, trailingText } from "./linked-orders";
 import { resolveTicketContract, subscribeTradingStatus } from "./pane-model";
 
 export interface TickerOrderSource {
@@ -43,7 +45,11 @@ async function loadTickerActivity(sources: readonly TickerOrderSource[]): Promis
     try {
       const recent = await Promise.resolve().then(() => broker.listExecutions?.(instance) ?? []);
       return recent.filter((row) => ticketOrderMatches(row, contract, instance.id, row.accountId));
-    } catch { failed = true; return []; }
+    } catch (error) {
+      logFailure("broker-trading.overview-orders", "Read broker executions failed")(error);
+      failed = true;
+      return [];
+    }
   }));
   return { recent: results.flat().sort((a, b) => b.time - a.time).slice(0, RECENT_LIMIT), failed };
 }
@@ -58,8 +64,8 @@ function ago(timestamp: number, now: number): string {
 
 function orderSummary(order: BrokerOrder): string {
   const status = brokerOrderStatus(order.status);
-  const type = ticketTypeName[order.orderType] ?? order.orderType;
-  const priced = order.orderType === "MKT" ? type : `${type} ${money(order.limitPrice ?? order.stopPrice)}`;
+  const type = order.linkRole && order.linkRole !== "entry" ? linkRoleName[order.linkRole] : ticketTypeName[order.orderType] ?? order.orderType;
+  const priced = order.orderType === "MKT" ? type : order.orderType === "TRAIL" ? trailingText(order, money) : `${type} ${money(order.limitPrice ?? order.stopPrice)}`;
   const state = status === "Partially filled" ? `${amount(order.filled)} of ${amount(order.quantity)} filled` : status === "Working" ? "" : status;
   return [`${order.action === "BUY" ? "Buy" : "Sell"} ${amount(order.quantity)}${order.legs?.length ? ` ${strategyShape(order.legs)}` : ""}`, priced, state].filter(Boolean).join(" · ");
 }

package/src/plugins/builtin/broker-trading/pane-model.ts

@@ -8,6 +8,7 @@ import type { Quote } from "../../../types/financials";
 import type { BrokerAccount, BrokerOrderRequest, BrokerTradingCapabilities } from "../../../types/trading";
 import type { BrokerAccountChoice } from "./account-picker";
 import { reverseStrategy, strategyContract, strategyOrderLegs, type StrategyIntent } from "./strategy";
+import { trailingUnit } from "./linked-orders";
 
 /** Successful broker reads may publish status heartbeats. They must not schedule another read. */
 export function subscribeTradingStatus(broker: BrokerAdapter, profile: BrokerInstanceConfig, onChange: () => void): () => void {
@@ -194,11 +195,38 @@ export function editTicketDraft(broker: BrokerAdapter, instance: BrokerInstanceC
     const { limitPrice: _debit, ...reversed } = reverseStrategy(draft);
     return reversed;
   }
-  const numeric = ["quantity", "limitPrice", "stopPrice"].includes(field);
-  const next = { ...draft, [field]: numeric ? value === "" ? field === "quantity" ? NaN : undefined : Number(value) : value };
+  // A bracket's exits come and go with it.
+  if (field === "bracket") {
+    const next = { ...draft };
+    if (value === true) next.orderClass = "bracket";
+    else { delete next.orderClass; delete next.takeProfitPrice; delete next.stopLossPrice; }
+    return next;
+  }
+  // A trailing distance is in one unit at a time. A number in one unit means nothing in the other: $1.50 is not 1.5%,
+  // so switching the unit clears it.
+  if (field === "trailingUnit" || field === "trailing") {
+    const current = trailingUnit(draft);
+    const unit = field === "trailingUnit" ? value === "percent" ? "percent" : "amount" : current;
+    const typed = field === "trailing" ? value === "" ? NaN : Number(value)
+      : unit !== current ? NaN : current === "percent" ? draft.trailingPercent : draft.trailingAmount;
+    const { trailingAmount: _amount, trailingPercent: _percent, ...rest } = draft;
+    return { ...rest, [unit === "percent" ? "trailingPercent" : "trailingAmount"]: typed ?? NaN };
+  }
+  const numeric = ["quantity", "limitPrice", "stopPrice", "takeProfitPrice", "stopLossPrice"].includes(field);
+  // OCO is a limit with a stop that cancels it: the ticket lists it as a type of its own.
+  const oco = field === "orderType" && value === "OCO";
+  const next = { ...draft, [field]: oco ? "LMT" : numeric ? value === "" ? field === "quantity" ? NaN : undefined : Number(value) : value };
   if (field === "orderType") {
     if (next.orderType !== "LMT" && next.orderType !== "STP LMT") delete next.limitPrice;
     if (next.orderType !== "STP" && next.orderType !== "STP LMT") delete next.stopPrice;
+    // An OCO's stop is on its own side, a bracket's stop loss on the other: neither carries over.
+    if (oco !== (draft.orderClass === "oco") || next.orderType === "TRAIL") { delete next.orderClass; delete next.takeProfitPrice; delete next.stopLossPrice; }
+    if (oco) next.orderClass = "oco";
+    if (next.orderType === "TRAIL" && draft.orderType !== "TRAIL") {
+      const units = broker.getTradingCapabilities?.(instance, next.contract, "TRAIL")?.trailing;
+      Object.assign(next, units?.[0] === "percent" ? { trailingPercent: NaN } : { trailingAmount: NaN });
+    }
+    if (next.orderType !== "TRAIL") { delete next.trailingAmount; delete next.trailingPercent; }
   }
   const capabilities = broker.getTradingCapabilities?.(instance, next.contract, next.orderType);
   if (capabilities && !capabilities.tif.includes(next.tif ?? "DAY")) next.tif = capabilities.tif[0];