gloomberb 0.18.3 → 0.18.4

package/src/brokers/signed-in/adapter.ts

@@ -10,12 +10,15 @@ import { ApiRequestError } from "../../api-client/errors";
 import { openUrl } from "../../components/ui/external-link";
 import type { BrokerAdapter, BrokerConnectionStatus, BrokerPosition } from "../../types/broker";
 import type { BrokerInstanceConfig } from "../../types/config";
+import type { Quote } from "../../types/financials";
 import type {
   BrokerAccount,
   BrokerExecution,
   BrokerOrder,
+  BrokerOrderPreview,
   BrokerOrderRequest,
   BrokerPortfolioPerformance,
+  BrokerTradingCapabilities,
 } from "../../types/trading";
 import { findSignedInBroker, refreshSignedInBrokers } from "./catalog";
 import type { SignedInBroker, SignedInBrokerConnection } from "./client";
@@ -47,16 +50,50 @@ function brokerReason(lastError: string | null | undefined): string | null {
   return described.replace(/[\s.]+$/, "").slice(0, 200) || null;
 }
 
-/** What to tell the user when Gloom answers a broker call with an error. */
-function describeSignedInBrokerError(error: unknown, brokerName: string): string {
+/** Gloom holds no live sign-in for the broker: only connecting again helps. */
+class SignInNeededError extends Error {}
+
+/**
+ * What to tell the user when Gloom answers a broker call with an error, and
+ * whether only a new sign-in, to Gloom or the broker, gets the profile going.
+ */
+function describeSignedInBrokerError(error: unknown, brokerName: string): { message: string; needsSignIn: boolean } {
   const status = error instanceof ApiRequestError ? error.status : undefined;
-  if (status === 401) return `Sign in to Gloom first, then connect ${brokerName}.`;
+  if (status === 401) return { message: `Sign in to Gloom first, then connect ${brokerName}.`, needsSignIn: true };
   const signInAgain = `${brokerName} needs you to sign in again. Press Connect in Brokers.`;
   // A sign-in the broker ended says why, in Gloom's words.
-  if (status === 409) return (error instanceof ApiRequestError && writtenMessage(error)) || signInAgain;
-  if (status === 404) return signInAgain;
-  if (status === 502) return `${brokerName} is not responding. Try again shortly.`;
-  return error instanceof Error && error.message ? error.message : String(error);
+  if (status === 409) return { message: (error instanceof ApiRequestError && writtenMessage(error)) || signInAgain, needsSignIn: true };
+  if (status === 404) return { message: signInAgain, needsSignIn: true };
+  if (status === 502) return { message: `${brokerName} is not responding. Try again shortly.`, needsSignIn: false };
+  // A refused order or a busy broker says why without its error code.
+  if (error instanceof ApiRequestError && (status === 403 || status === 422 || status === 503)) {
+    return { message: writtenMessage(error) ?? error.message, needsSignIn: false };
+  }
+  return {
+    message: error instanceof Error && error.message ? error.message : String(error),
+    needsSignIn: error instanceof SignInNeededError,
+  };
+}
+
+/**
+ * Gloom answered an order action and nothing was placed, changed or
+ * cancelled: the broker refused it, its check lapsed, trading is not granted,
+ * the broker was too busy to take it, or the sign-in has to be renewed. A
+ * 502 or a lost answer may have reached the broker, so it is not one.
+ */
+function refusedOrderAction(error: unknown): boolean {
+  if (!(error instanceof ApiRequestError)) return false;
+  return error.status !== undefined && error.status >= 400 && error.status < 500 || error.status === 503;
+}
+
+/** A sign-in that ended or was never made, as opposed to a refused order: the profile's status says so. */
+function signInLost(error: unknown): boolean {
+  if (!(error instanceof ApiRequestError)) return false;
+  return error.status === 401 || error.status === 404 || error.status === 409 && error.code === "reauth_required";
+}
+
+function refused(message: string): Error {
+  return Object.assign(new Error(message), { refused: true });
 }
 
 /** The broker does not offer this. A broker tool that failed is also a 422, but a failure. */
@@ -67,7 +104,7 @@ function isUnsupported(error: unknown): boolean {
 type BrokerRequest = <T>(
   broker: string,
   path: string,
-  options?: { method?: "GET" | "POST" | "DELETE"; body?: unknown },
+  options?: { method?: "GET" | "POST" | "PUT" | "DELETE"; body?: unknown },
 ) => Promise<T>;
 
 export interface SignedInBrokerAdapterDeps {
@@ -84,6 +121,60 @@ interface PortfolioSnapshot {
   fetchedAt?: number;
 }
 
+/** Gloom's answer to a direct-mode order, before the user confirms it. */
+interface DirectOrderPreview {
+  status: "preview";
+  previewId: string;
+  expiresAt: string;
+  impact: {
+    source: "broker" | "unavailable";
+    sourceLabel: string;
+    currency?: string;
+    estimatedCost?: number;
+    cashBefore?: number;
+    cashAfter?: number;
+    commission?: number;
+    fees?: number;
+    disclosure: string;
+  };
+}
+
+interface PlacedOrder { status: "placed"; order: BrokerOrder }
+
+/** The quote a direct-mode broker gives the ticket. */
+interface SignedInBrokerQuote {
+  symbol: string;
+  name?: string;
+  currency?: string;
+  price: number;
+  bid?: number;
+  ask?: number;
+  bidSize?: number;
+  askSize?: number;
+  lastTradePrice?: number;
+  lastUpdated: number;
+  dataSource: "live" | "delayed";
+}
+
+/** The same order always keys the same, whatever order its fields arrive in. */
+function canonical(value: unknown): string {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.entries(value).filter(([, entry]) => entry !== undefined).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+      .map(([key, entry]) => `${JSON.stringify(key)}:${canonical(entry)}`).join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "null";
+}
+
+/** The ticket's fields, without the profile's own, as Gloom checks and places the order. */
+function orderBody(request: BrokerOrderRequest): BrokerOrderRequest {
+  const { brokerInstanceId: _profile, ...body } = request;
+  const { brokerInstanceId: _contractProfile, ...contract } = body.contract;
+  return { ...body, contract };
+}
+
+const DIRECT_TIF = ["DAY"];
+
 export function createSignedInBrokerAdapter(overrides: Partial<SignedInBrokerAdapterDeps> = {}): BrokerAdapter {
   const deps: SignedInBrokerAdapterDeps = {
     request: (broker, path, options) => apiClient.brokerRequest(broker, path, options),
@@ -95,12 +186,29 @@ export function createSignedInBrokerAdapter(overrides: Partial<SignedInBrokerAda
   };
   const statuses = new Map<string, BrokerConnectionStatus>();
   const listeners = new Map<string, Set<() => void>>();
+  /** Whether each profile's sign-in granted trading, as its last connect read it. */
+  const canTrade = new Map<string, boolean>();
+  /** Direct mode: the check the user is reviewing, per profile, by the exact order it was for. */
+  const previews = new Map<string, { order: string; previewId: string; expiresAt: number }>();
+  /** Direct mode: the broker's own id behind each order number the app holds, per profile. */
+  const handles = new Map<string, Map<number, { accountId: string; brokerOrderId: string }>>();
 
   const brokerName = (instance: BrokerInstanceConfig) =>
     deps.findBroker(signedInBrokerId(instance))?.name ?? instance.label;
 
-  const setStatus = (instance: BrokerInstanceConfig, state: "connected" | "error", message?: string) => {
-    statuses.set(instance.id, { state, message, mode: METHOD, updatedAt: deps.now() });
+  /** The broker's direct-mode orders, or null for one that keeps orders for review or takes none. */
+  const directOrders = (instance: BrokerInstanceConfig) => {
+    const orders = deps.findBroker(signedInBrokerId(instance))?.capabilities.orders;
+    return orders && orders.mode === "direct" ? orders : null;
+  };
+
+  const setStatus = (instance: BrokerInstanceConfig, state: "connected" | "error", message?: string, needsSignIn = false) => {
+    statuses.set(instance.id, {
+      state, message, mode: METHOD, updatedAt: deps.now(),
+      ...(needsSignIn ? { needsSignIn } : {}),
+      // A direct-mode broker says per quote whether it is real-time.
+      ...(directOrders(instance) ? { quoteData: "realtime" as const } : {}),
+    });
     for (const listener of listeners.get(instance.id) ?? []) listener();
   };
 
@@ -111,8 +219,8 @@ export function createSignedInBrokerAdapter(overrides: Partial<SignedInBrokerAda
       setStatus(instance, "connected");
       return result;
     } catch (error) {
-      const message = describeSignedInBrokerError(error, brokerName(instance));
-      setStatus(instance, "error", message);
+      const { message, needsSignIn } = describeSignedInBrokerError(error, brokerName(instance));
+      setStatus(instance, "error", message, needsSignIn);
       throw new Error(message);
     }
   };
@@ -130,7 +238,51 @@ export function createSignedInBrokerAdapter(overrides: Partial<SignedInBrokerAda
   const snapshot = (instance: BrokerInstanceConfig) =>
     track(instance, () => get<PortfolioSnapshot>(instance, "/snapshot"));
 
-  /** Checks an order against what the broker takes, before Gloom sees it. */
+  /**
+   * An order as the app holds it: this profile's, under this adapter, and
+   * remembered by its number so a change or cancel can name it to the broker.
+   */
+  const ownOrder = (instance: BrokerInstanceConfig, order: BrokerOrder): BrokerOrder => {
+    if (order.brokerOrderId && order.accountId) {
+      const known = handles.get(instance.id) ?? new Map();
+      known.set(order.orderId, { accountId: order.accountId, brokerOrderId: order.brokerOrderId });
+      handles.set(instance.id, known);
+    }
+    return { ...order, brokerInstanceId: instance.id, contract: { ...order.contract, brokerId: SIGNED_IN_BROKER_TYPE, brokerInstanceId: instance.id } };
+  };
+
+  /**
+   * One order action. A refusal leaves the profile's status alone (the
+   * broker is fine; the order is not) and is marked refused; a sign-in that
+   * ended shows on the profile as any failed call does.
+   */
+  const orderAction = async <T>(instance: BrokerInstanceConfig, run: () => Promise<T>): Promise<T> => {
+    try {
+      const result = await run();
+      setStatus(instance, "connected");
+      return result;
+    } catch (error) {
+      const { message, needsSignIn } = describeSignedInBrokerError(error, brokerName(instance));
+      if (signInLost(error)) setStatus(instance, "error", message, needsSignIn);
+      throw refusedOrderAction(error) ? refused(message) : new Error(message);
+    }
+  };
+
+  /** The broker's id for an order number; nothing is sent when it cannot be found. */
+  const brokerOrderHandle = async (instance: BrokerInstanceConfig, orderId: number) => {
+    const known = handles.get(instance.id)?.get(orderId);
+    if (known) return known;
+    try {
+      for (const order of await get<BrokerOrder[]>(instance, "/orders")) ownOrder(instance, order);
+    } catch (error) {
+      throw refused(describeSignedInBrokerError(error, brokerName(instance)).message);
+    }
+    const found = handles.get(instance.id)?.get(orderId);
+    if (!found) throw refused("This order is no longer listed. Refresh your orders.");
+    return found;
+  };
+
+  /** Checks an order against what the broker takes, before Gloom sees it: a failure sent nothing. */
   const checkOrder = async (instance: BrokerInstanceConfig, request: BrokerOrderRequest) => {
     const id = signedInBrokerId(instance);
     let broker = deps.findBroker(id);
@@ -140,14 +292,25 @@ export function createSignedInBrokerAdapter(overrides: Partial<SignedInBrokerAda
     }
     const name = broker?.name ?? instance.label;
     const orders = broker?.capabilities.orders;
-    if (!orders) throw new Error(`${name} does not take orders from Gloom.`);
+    if (!orders) throw refused(`${name} does not take orders from Gloom.`);
     if (!orders.types.includes(request.orderType)) {
-      throw new Error(`${name} does not take ${request.orderType} orders from Gloom.`);
+      throw refused(`${name} does not take ${request.orderType} orders from Gloom.`);
+    }
+    // A server that does not say it takes a bracket, an OCO pair or a trailing stop would drop its fields and place a bare
+    // order: never send one it has not named.
+    if (!request.orderClass && (request.takeProfitPrice !== undefined || request.stopLossPrice !== undefined)) {
+      throw refused("A take profit or stop loss needs a bracket or OCO order.");
+    }
+    if (request.orderClass && !orders.orderClasses?.includes(request.orderClass)) {
+      throw refused(`${name} does not take ${request.orderClass === "oco" ? "OCO" : "bracket"} orders from Gloom.`);
+    }
+    if (request.orderType === "TRAIL" && !orders.trailing?.includes(request.trailingPercent !== undefined ? "percent" : "amount")) {
+      throw refused(`${name} does not take this trailing stop from Gloom.`);
     }
-    if (!(request.quantity > 0)) throw new Error("Quantity must be positive.");
+    if (!(request.quantity > 0)) throw refused("Quantity must be positive.");
     const needsLimit = request.orderType === "LMT" || request.orderType === "STP LMT";
     if (needsLimit && !(typeof request.limitPrice === "number" && request.limitPrice > 0)) {
-      throw new Error("A limit order needs a limit price.");
+      throw refused("A limit order needs a limit price.");
     }
     return { name, mode: orders.mode };
   };
@@ -156,6 +319,8 @@ export function createSignedInBrokerAdapter(overrides: Partial<SignedInBrokerAda
     id: SIGNED_IN_BROKER_TYPE,
     name: "Signed-in broker",
     configSchema: [],
+    // A signed-in broker's quotes come through Gloom and count against the broker's allowance.
+    ticketQuotesOnly: true,
 
     async validate() {
       return true;
@@ -191,17 +356,51 @@ export function createSignedInBrokerAdapter(overrides: Partial<SignedInBrokerAda
       return getOptional<BrokerExecution[]>(instance, "/executions?period=DAYS_90", []);
     },
 
-    listOpenOrders(instance) {
-      return getOptional<BrokerOrder[]>(instance, "/orders", []);
+    async listOpenOrders(instance) {
+      return (await getOptional<BrokerOrder[]>(instance, "/orders", [])).map((order) => ownOrder(instance, order));
     },
 
     async previewOrder(instance, request) {
       const { name, mode } = await checkOrder(instance, request);
-      return mode === "review" ? { warningText: `${name} opens this order for you to review and submit.` } : {};
+      if (mode === "review") return { warningText: `${name} opens this order for you to review and submit.` };
+      const answer = await orderAction(instance, () => deps.request<DirectOrderPreview>(
+        signedInBrokerId(instance),
+        "/orders",
+        { method: "POST", body: orderBody(request) },
+      ));
+      previews.set(instance.id, { order: canonical(orderBody(request)), previewId: answer.previewId, expiresAt: Date.parse(answer.expiresAt) });
+      const { impact } = answer;
+      const preview: BrokerOrderPreview = {
+        impactSource: impact.source,
+        impactSourceLabel: impact.sourceLabel,
+        disclosure: impact.disclosure,
+        currency: impact.currency,
+        estimatedCost: impact.estimatedCost,
+        commission: impact.commission,
+        commissionCurrency: impact.commission === undefined ? undefined : impact.currency,
+        fees: impact.fees,
+        cashBefore: impact.cashBefore,
+        cashAfter: impact.cashAfter,
+      };
+      return Object.fromEntries(Object.entries(preview).filter(([, value]) => value !== undefined)) as BrokerOrderPreview;
     },
 
     async placeOrder(instance, request) {
-      const { name } = await checkOrder(instance, request);
+      const { name, mode } = await checkOrder(instance, request);
+      if (mode === "direct") {
+        // Only the order the user reviewed, while its check stands.
+        const preview = previews.get(instance.id);
+        if (!preview || preview.order !== canonical(orderBody(request)) || !(preview.expiresAt > deps.now())) {
+          throw refused("Review this order again before placing it.");
+        }
+        const placed = await orderAction(instance, () => deps.request<PlacedOrder>(
+          signedInBrokerId(instance),
+          "/orders",
+          { method: "POST", body: { ...orderBody(request), previewId: preview.previewId } },
+        ));
+        previews.delete(instance.id);
+        return ownOrder(instance, placed.order);
+      }
       const placed = await track(instance, () => deps.request<{ status: string; id: string; reviewUrl: string }>(
         signedInBrokerId(instance),
         "/orders",
@@ -228,23 +427,102 @@ export function createSignedInBrokerAdapter(overrides: Partial<SignedInBrokerAda
       };
     },
 
-    async modifyOrder(instance) {
+    async modifyOrder(instance, orderId, request) {
+      const { name, mode } = await checkOrder(instance, request);
+      if (mode !== "direct") throw refused(`Orders sent to ${name} are managed in ${name}.`);
+      const handle = await brokerOrderHandle(instance, orderId);
+      const changed = await orderAction(instance, () => deps.request<PlacedOrder>(
+        signedInBrokerId(instance),
+        `/orders/${encodeURIComponent(handle.brokerOrderId)}`,
+        { method: "PUT", body: { ...orderBody(request), accountId: handle.accountId } },
+      ));
+      return ownOrder(instance, changed.order);
+    },
+
+    async cancelOrder(instance, orderId) {
       const name = brokerName(instance);
-      throw new Error(`Orders sent to ${name} are managed in ${name}.`);
+      if (!directOrders(instance)) throw refused(`Orders sent to ${name} are managed in ${name}.`);
+      const handle = await brokerOrderHandle(instance, orderId);
+      await orderAction(instance, () => deps.request<{ cancelled: boolean }>(
+        signedInBrokerId(instance),
+        `/orders/${encodeURIComponent(handle.brokerOrderId)}?accountId=${encodeURIComponent(handle.accountId)}`,
+        { method: "DELETE" },
+      ));
     },
 
-    async cancelOrder(instance) {
+    /**
+     * Direct mode only: what the ticket offers. Trading needs the profile
+     * switched on and a sign-in that granted it; the broker's linked
+     * account may still be read-only, which its check then says.
+     */
+    getTradingCapabilities(instance) {
       const name = brokerName(instance);
-      throw new Error(`Orders sent to ${name} are managed in ${name}.`);
+      const orders = directOrders(instance);
+      if (!orders) {
+        return { enabled: false, disabledReason: `${name} does not take orders from the ticket.`, orderTypes: [], tif: [] };
+      }
+      const granted = canTrade.get(instance.id) === true;
+      const switchedOn = instance.config.tradingEnabled === true;
+      const capabilities: BrokerTradingCapabilities = {
+        enabled: granted && switchedOn,
+        orderTypes: [...orders.types],
+        tif: orders.tif?.length ? [...orders.tif] : DIRECT_TIF,
+        ...(orders.orderClasses?.length ? { orderClasses: [...orders.orderClasses] } : {}),
+        ...(orders.trailing?.length ? { trailing: [...orders.trailing] } : {}),
+        minQuantity: 1,
+        quantityStep: 1,
+        modify: true,
+        cancel: true,
+        executionKind: "order-summaries",
+      };
+      if (!granted) capabilities.disabledReason = `${name} is connected read-only. Connect it again in Brokers to allow trading.`;
+      else if (!switchedOn) capabilities.disabledReason = "Trading is off for this profile.";
+      return capabilities;
+    },
+
+    getTradingConfigUpdate(_instance, enabled) {
+      return { tradingEnabled: enabled };
+    },
+
+    // The ticket's quote. A symbol the broker cannot price, or its request
+    // allowance spent, is the ticket's to say; only a lost sign-in is the profile's.
+    async getQuote(ticker, instance) {
+      const id = signedInBrokerId(instance);
+      if (!directOrders(instance)) throw new Error(`${brokerName(instance)} gives no quotes to the ticket.`);
+      const answer = await orderAction(instance, () => deps.request<SignedInBrokerQuote>(
+        id,
+        `/quote?symbol=${encodeURIComponent(ticker.trim().toUpperCase())}`,
+      ));
+      const quote: Quote = {
+        symbol: answer.symbol,
+        name: answer.name,
+        price: answer.price,
+        bid: answer.bid,
+        ask: answer.ask,
+        bidSize: answer.bidSize,
+        askSize: answer.askSize,
+        currency: answer.currency ?? "USD",
+        // The broker gives no prior close: no change to show.
+        change: Number.NaN,
+        changePercent: Number.NaN,
+        changeBasis: "none",
+        lastUpdated: answer.lastUpdated,
+        receivedAt: deps.now(),
+        dataSource: answer.dataSource,
+        delivery: "poll",
+        providerId: id,
+      };
+      return quote;
     },
 
     async connect(instance) {
       await track(instance, async () => {
         const connection = await get<SignedInBrokerConnection>(instance, "");
+        canTrade.set(instance.id, connection.status === "connected" && connection.canTrade === true);
         if (connection.status !== "connected") {
           const name = brokerName(instance);
           const reason = brokerReason(connection.lastError);
-          throw new Error(reason
+          throw new SignInNeededError(reason
             ? `${name} needs you to sign in again: ${reason}. Press Connect in Brokers.`
             : `Press Connect in Brokers to sign in to ${name}.`);
         }

package/src/brokers/signed-in/client.ts

@@ -4,12 +4,22 @@
  * appears here without an app release.
  */
 import { apiClient } from "../../api-client";
-import type { BrokerOrderType } from "../../types/trading";
+import type { BrokerOrderClass, BrokerOrderType, BrokerTrailingUnit } from "../../types/trading";
 
 interface SignedInBrokerCapabilities {
   history: boolean;
   executions: boolean;
-  orders: false | { mode: "review" | "direct"; types: BrokerOrderType[] };
+  /**
+   * Review: the broker keeps each order for the user to submit there. Direct: Gloom checks the
+   * order with the broker, the user confirms that check in the ticket, and Gloom places it.
+   */
+  orders: false | {
+    mode: "review" | "direct"; types: BrokerOrderType[]; tif?: string[];
+    /** Brackets and OCO pairs the broker places and runs itself; absent from a server that sends none. */
+    orderClasses?: BrokerOrderClass[];
+    /** How a trailing stop (`TRAIL` in `types`) is set. */
+    trailing?: BrokerTrailingUnit[];
+  };
   /** Connecting Gloom replaces this broker's link to other AI apps. */
   singleConnection: boolean;
   /** Shown before connecting, e.g. an account the user must create first. */
@@ -19,6 +29,8 @@ interface SignedInBrokerCapabilities {
 export interface SignedInBroker {
   id: string;
   name: string;
+  /** Under the name where brokers are listed, for one that is not itself a broker (SnapTrade). */
+  description?: string;
   capabilities: SignedInBrokerCapabilities;
 }
 

package/src/brokers/signed-in/connect.ts

@@ -31,6 +31,8 @@ export function signedInBrokerForProfile(instance: BrokerInstanceConfig, fallbac
 export interface ConnectSignedInBrokerDeps<T> {
   getConfig(): AppConfig;
   createBrokerInstance(brokerType: string, label: string, values: Record<string, unknown>): Promise<BrokerInstanceConfig>;
+  /** Turns a profile that was turned off back on. */
+  enableBrokerInstance(instanceId: string): Promise<void>;
   syncBrokerInstance(instanceId: string): Promise<T>;
   /** Asks the user to connect: a form's own connect step, or the connect dialog when missing. */
   requestSignIn?: (broker: SignedInBroker) => Promise<boolean>;
@@ -39,6 +41,9 @@ export interface ConnectSignedInBrokerDeps<T> {
 /**
  * Asks the user to connect `broker`, then syncs its profile, creating it the
  * first time. Resolves null when the broker was not connected.
+ *
+ * Connecting a broker whose profile is turned off turns it back on first:
+ * nothing syncs a disabled profile, and connecting it again is asking for it.
  */
 export async function connectSignedInBrokerProfile<T>(
   broker: SignedInBroker,
@@ -46,8 +51,11 @@ export async function connectSignedInBrokerProfile<T>(
 ): Promise<{ instance: BrokerInstanceConfig; synced: T } | null> {
   const connected = await (deps.requestSignIn ?? requestBrokerSignIn)(broker);
   if (!connected) return null;
-  const instance = findSignedInBrokerProfile(deps.getConfig().brokerInstances, broker.id)
-    ?? await deps.createBrokerInstance(SIGNED_IN_BROKER_TYPE, broker.name, { connectionMode: broker.id, broker: broker.id });
+  const existing = findSignedInBrokerProfile(deps.getConfig().brokerInstances, broker.id);
+  if (existing?.enabled === false) await deps.enableBrokerInstance(existing.id);
+  const instance = existing
+    ? { ...existing, enabled: true }
+    : await deps.createBrokerInstance(SIGNED_IN_BROKER_TYPE, broker.name, { connectionMode: broker.id, broker: broker.id });
   return { instance, synced: await deps.syncBrokerInstance(instance.id) };
 }
 

package/src/brokers/sync-broker-instance.ts

@@ -7,6 +7,7 @@ import type { BrokerAccount } from "../types/trading";
 import type { TickerRecord } from "../types/ticker";
 import { getBrokerInstance } from "../utils/broker-instances";
 import {
+  accountsHeldUnderOwnNumber,
   clearBrokerInstanceTickerData,
   clearLeftoverBrokerHoldings,
   ensureBrokerPortfolio,
@@ -248,6 +249,13 @@ export async function syncBrokerInstance({
     throwIfBrokerImportCancelled(signal);
   }
 
+  // An account another profile holds under its own number stays with it.
+  const heldUnderOwnNumber = accountsHeldUnderOwnNumber(config, instance, brokerAccounts);
+  if (heldUnderOwnNumber.size > 0) {
+    brokerAccounts = brokerAccounts.filter((account) => !heldUnderOwnNumber.has(account.accountId));
+    positions = positions.filter((position) => !position.accountId || !heldUnderOwnNumber.has(position.accountId));
+  }
+
   const accountMetadata = new Map(
     brokerAccounts.map((account) => [
       account.accountId,
@@ -301,7 +309,7 @@ export async function syncBrokerInstance({
       const account = accountMetadata.get(accountId);
       claimPortfolio(portfolioId, account?.name || accountId, account?.currency || "USD", accountId);
     }
-  } else {
+  } else if (heldUnderOwnNumber.size === 0) {
     const defaultAccount = brokerAccounts[0];
     const portfolioId = findReusableBrokerPortfolioId(nextConfig, instance, defaultAccount?.accountId, portfolioBrokerId);
     const fallbackName = defaultAccount?.name || defaultAccount?.accountId || instance.label || broker.name;

package/src/capabilities/chart-series.ts

@@ -9,7 +9,8 @@ import type {
   SeriesTransform,
   TimeSeriesPoint,
 } from "../time-series/types";
-import { CHART_RESOLUTIONS, TIME_RANGES } from "../time-series/range";
+import { TIME_RANGES } from "../time-series/range";
+import { isChartResolution } from "../time-series/resolution";
 import type {
   CapabilityInvoker,
   CapabilitySchema,
@@ -26,7 +27,6 @@ const CAPABILITY_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,79}$/;
 const SERIES_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._~%:/-]{0,239}$/;
 const chartSeriesLog = debugLog.createLogger("chart-series");
 const ranges = new Set<string>(TIME_RANGES);
-const resolutions = new Set<string>(CHART_RESOLUTIONS);
 const periods = new Set(["auto", "daily", "weekly", "monthly", "quarterly", "annual", "ttm"]);
 const styles = new Set(["line", "area", "step", "columns", "points", "candles", "ohlc", "hlc"]);
 const transforms = new Set(["raw", "percent", "index100", "yoy", "qoq", "log"]);
@@ -103,7 +103,8 @@ function viewport(value: unknown): ChartViewportSpec {
   const input = object(value, "resolve viewport");
   onlyKeys(input, "resolve viewport", ["range", "resolution", "dateWindow", "maxPoints"]);
   const range = enumValue<ChartViewportSpec["range"]>(input.range, "viewport range", ranges);
-  const resolution = enumValue<ChartViewportSpec["resolution"]>(input.resolution, "viewport resolution", resolutions);
+  if (!isChartResolution(input.resolution)) fail("viewport resolution", `unsupported value ${String(input.resolution)}.`);
+  const resolution = input.resolution;
   let dateWindow: ChartViewportSpec["dateWindow"];
   if (input.dateWindow !== undefined) {
     const window = object(input.dateWindow, "viewport date window");
@@ -276,12 +277,15 @@ function searchableChartSeriesManifests(invoker: CapabilityInvoker) {
   return chartSeriesCapabilityManifests(invoker).filter((manifest) => manifest.sourceId !== REGISTERED_SERIES_SOURCE_ID);
 }
 
-export async function searchChartSeriesCapabilities(
+type CatalogSuggestion = ChartSeriesCatalogItem & { capabilityId: string; capabilityName: string };
+
+/** Partial search results retain failures for the shared picker error state. */
+export async function searchChartSeriesCatalogs(
   invoker: CapabilityInvoker,
   query: string,
   limit = 8,
   signal?: AbortSignal,
-): Promise<Array<ChartSeriesCatalogItem & { capabilityId: string; capabilityName: string }>> {
+): Promise<{ items: CatalogSuggestion[]; errors: string[] }> {
   const manifests = searchableChartSeriesManifests(invoker);
   const results = await Promise.allSettled(manifests.map(async (manifest) => {
     const items = await invoker.invokeCapability<ChartSeriesCatalogItem[]>(
@@ -297,15 +301,27 @@ export async function searchChartSeriesCapabilities(
     }));
   }));
   if (signal?.aborted) throw signal.reason ?? new DOMException("Aborted", "AbortError");
+  const errors: string[] = [];
   for (const [index, result] of results.entries()) {
     if (result.status === "rejected") {
+      errors.push(`${manifests[index]!.name} search unavailable.`);
       chartSeriesLog.warn("Chart series provider catalog failed", {
         capabilityId: manifests[index]?.id,
         error: result.reason instanceof Error ? result.reason.message : String(result.reason),
       });
     }
   }
-  return results.flatMap((result) => result.status === "fulfilled" ? result.value : []).slice(0, limit);
+  return { items: results.flatMap((result) => result.status === "fulfilled" ? result.value : []).slice(0, limit), errors };
+}
+
+/** The public list-only API keeps its existing partial-results contract. */
+export async function searchChartSeriesCapabilities(
+  invoker: CapabilityInvoker,
+  query: string,
+  limit = 8,
+  signal?: AbortSignal,
+): Promise<CatalogSuggestion[]> {
+  return (await searchChartSeriesCatalogs(invoker, query, limit, signal)).items;
 }
 
 export function chartSeriesSourceKey(

package/src/cli/bank-section.ts

@@ -31,7 +31,7 @@ export function nimCommand(symbol: string): string {
   const definition = JSON.stringify({
     version: 1, currency: null, criteria: [{ field: "symbol", op: "in", value: [symbol] }], sort: { field: "symbol", direction: "asc" },
   });
-  return `gloomberb fn EQS --metric kpiNimPercent --definition '${definition}'`;
+  return `gloom fn EQS --metric kpiNimPercent --definition '${definition}'`;
 }
 
 /** Gloom Cloud's note for a company with no US GAAP deposits tag, which reads as if it filed 10-Qs; a foreign issuer files neither. */