gloomberb 0.17.5 → 0.17.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gloomberb",
-  "version": "0.17.5",
+  "version": "0.17.6",
   "packageManager": "bun@1.3.11",
   "description": "Market research and portfolio tracker for the terminal",
   "module": "src/public/index.ts",
@@ -83,6 +83,7 @@
     "benchmark:tui:compare": "bun run scripts/benchmark-tui-compare.ts",
     "benchmark:tui:memory": "bun run scripts/benchmark-tui-memory.ts",
     "check:pane-chrome": "bun run scripts/pane-chrome/checks.ts",
+    "check:chat-mentions": "bun scripts/pane-chrome/chat-mentions.ts",
     "check:pane-screenshot": "bun run scripts/pane-chrome/screenshot.ts",
     "check:pane-rest": "bun run scripts/pane-chrome/rest-diff.ts",
     "check:pane-layout": "bun run scripts/pane-chrome/layout-sweep.ts",
@@ -111,6 +112,7 @@
     "gloom-polls": "github:gloom-sh/gloom-polls",
     "gloom-prediction-markets": "github:gloom-sh/gloom-prediction-markets",
     "happy-dom": "^20.11.1",
+    "playwright-core": "1.60.0",
     "png-to-ico": "^2.1.8",
     "rcedit": "^4.0.1",
     "typescript": "^5.9.2",

package/src/api-client/chat.ts

@@ -12,6 +12,7 @@ import type {
   ChatAttachment,
   ChatChannel,
   ChatChannelState,
+  ChatMentionCandidate,
   ChatDiscordLink,
   ChatMessage,
   ChatNotification,
@@ -118,6 +119,14 @@ export class CloudChatApi {
     this.emitAttachmentSupport();
   }
 
+  getMentionCandidates(channelId: string): Promise<ChatMentionCandidate[]> {
+    return this.request(`/chat/channels/${encodeURIComponent(channelId)}/mention-candidates`);
+  }
+
+  subscribeMentionCandidatesChanged(listener: () => void): () => void {
+    return this.options.socket.subscribeChatMentionCandidatesChanged(listener);
+  }
+
   async getChannels(): Promise<ChatChannel[]> {
     const channels =
       await this.request<ChatChannel[]>("/chat/channels");

package/src/api-client/commodity-balances.ts

@@ -0,0 +1,77 @@
+/** Whether a board is whole, missing a part, or not loaded on the server yet. */
+type BalanceBoardStatus = "available" | "partial" | "unavailable";
+
+/** One country's crude or natural gas balance, as GET /cloud/jodi/board serves it. */
+export interface JodiBalanceRow {
+  country: string;
+  /** The month the figures are for, YYYY-MM: each country's own latest report. Null when it never reported one. */
+  month: string | null;
+  production: number | null;
+  demand: number | null;
+  imports: number | null;
+  exports: number | null;
+  stocks: number | null;
+  unit: string;
+}
+
+export interface JodiBalanceBoard {
+  /** The newest month on the board, YYYY-MM. */
+  month: string;
+  commodity: "oil" | "gas";
+  rows: JodiBalanceRow[];
+}
+
+/** The Oil & Gas board: JODI's monthly crude and natural gas balances. */
+export interface JodiBoardPayload {
+  source: "JODI";
+  status: BalanceBoardStatus;
+  /** When JODI last confirmed the oldest copy on the board, ISO. */
+  checkedAt: string | null;
+  /** The server has not been able to read JODI for days: these are the last copies it read. */
+  stale: boolean;
+  gaps: string[];
+  oil: JodiBalanceBoard | null;
+  gas: JodiBalanceBoard | null;
+}
+
+/** One crop, country and attribute of the latest market year, as GET /cloud/psd/board serves it. */
+export interface PsdBalanceRow {
+  id: string;
+  crop: string;
+  country: string;
+  attribute: string;
+  value: number;
+  unit: string;
+  /** Market year, 2026/27. */
+  year: string;
+  cropOrder: number;
+  countryOrder: number;
+  attributeOrder: number;
+}
+
+/** A season-average farm price forecast. */
+export interface PsdPriceForecast {
+  id: string;
+  crop: string;
+  forecast: number;
+  unit: string;
+  season: string;
+  cropOrder: number;
+  seasonYear: number;
+}
+
+/** The Crops board: USDA's world crop balances and season-average price forecasts. */
+export interface PsdBoardPayload {
+  source: "USDA";
+  status: BalanceBoardStatus;
+  checkedAt: string | null;
+  stale: boolean;
+  gaps: string[];
+  /** YYYY-MM of the newest estimate on the board: the monthly supply and demand report that set it. */
+  month: string | null;
+  marketYear: string | null;
+  rows: PsdBalanceRow[];
+  prices: PsdPriceForecast[];
+  /** The model forecast date of the prices, YYYY-MM-DD. */
+  pricesDate: string | null;
+}

package/src/api-client/data.ts

@@ -35,10 +35,12 @@ import type { CloudCurveHistory, CloudCurveId, CloudCurveView, CloudWorldCurves
 import type { CdxBoardPayload, CloudCreditBoardParams, SovrBoardPayload } from "./credit-boards";
 import type { ShortVolumePayload, ShortVolumeScope } from "./short-volume";
 import type { BeneficialOwnersPayload, CloudBeneficialOwnersParams } from "./beneficial-owners";
+import type { CloudInsiderSignalsParams, InsiderSignalsPayload } from "./insider-signals";
 import type { SocialMentionDayPosts, SocialMentionsPayload, SocialMentionsRange } from "./social-mentions";
 import type { FuturesContractTermsPayload, FuturesCurveAsOfPayload, FuturesCurvePayload } from "./futures-curve";
 import type { CotBoardPayload, CotContractPayload, CotFamily, CotClass } from "./cot";
 import type { DoeBoardPayload, DoePricesPayload } from "./doe";
+import type { JodiBoardPayload, PsdBoardPayload } from "./commodity-balances";
 import type { CarbonBoard, CarbonHistory, EuropePowerBoard, EuropePowerHistory, GasStorageBoard, GasStorageHistory, GasStorageSeasonal } from "./europe-energy";
 import type { GpuBoardPayload, GpuEventsPayload, GpuHistoryPayload, GpuHistoryQuery } from "./gpu";
 import type { CpiBoardPayload } from "./cpi";
@@ -81,6 +83,7 @@ import {
   cloudExchangeRatePath,
   cloudSec13FPath,
   cloudSecBeneficialOwnersPath,
+  cloudSecInsiderSignalsPath,
   cloudSecFilingContentPath,
   cloudSecFilingDocumentsPath,
   cloudSecFilingsPath,
@@ -143,6 +146,7 @@ import type {
   CloudMarketResponse,
   CloudMarketScreenerCategory,
   CloudMarketScreenerPayload,
+  CloudMoverSession,
   CloudNewsListResponse,
   CloudNewsPayload,
   CloudSavedSearch,
@@ -283,8 +287,10 @@ export class CloudDataApi {
     return this.request(`/news/article-summary?${new URLSearchParams({ url })}`);
   }
 
-  getMarketMovers(category: "day_gainers" | "day_losers" | "most_actives", count = 25, refresh = false): Promise<CloudMarketResponse<MarketMoversPayload>> {
+  /** `session` is what Gainers and Losers are ranked by (see CloudMoverSession). */
+  getMarketMovers(category: "day_gainers" | "day_losers" | "most_actives", count = 25, refresh = false, session?: CloudMoverSession): Promise<CloudMarketResponse<MarketMoversPayload>> {
     const params = new URLSearchParams({ category, count: String(count), mode: refresh ? "refresh" : "cache-first" });
+    if (session && category !== "most_actives") params.set("session", session);
     return this.request(`/market/movers?${params}`);
   }
 
@@ -300,12 +306,17 @@ export class CloudDataApi {
     return this.requestMarketSymbol("/market/dividends", symbol, exchange);
   }
 
-  /** Gainers, losers and most active, or the pre-market, after-hours and gap lists with a `side`. */
+  /**
+   * Gainers, losers and most active, or the pre-market, after-hours and gap
+   * lists with a `side`. `session` is what Gainers and Losers are ranked by
+   * (see CloudMoverSession).
+   */
   async getCloudMarketScreener<Category extends CloudMarketScreenerCategory | CloudSessionMoversCategory>(
     category: Category,
     count = 25,
     mode: "cache-first" | "refresh" = "cache-first",
     side?: CloudSessionMoversSide,
+    session?: CloudMoverSession,
   ): Promise<CloudMarketResponse<Category extends CloudSessionMoversCategory ? CloudSessionMoversPayload : CloudMarketScreenerPayload>> {
     const requestedCount = Number.isFinite(count) ? Math.round(count) : 25;
     const params = new URLSearchParams({
@@ -314,6 +325,7 @@ export class CloudDataApi {
       mode,
     });
     if (side && isSessionMoversCategory(category)) params.set("side", side);
+    if (session && (category === "gainers" || category === "losers")) params.set("session", session);
     return this.request(`/market/screener?${params.toString()}`);
   }
 
@@ -590,6 +602,14 @@ export class CloudDataApi {
     return this.request<DoePricesPayload>("/cloud/doe/prices");
   }
 
+  getCloudJodiBoard(signal?: AbortSignal): Promise<JodiBoardPayload> {
+    return this.request<JodiBoardPayload>("/cloud/jodi/board", { signal });
+  }
+
+  getCloudPsdBoard(signal?: AbortSignal): Promise<PsdBoardPayload> {
+    return this.request<PsdBoardPayload>("/cloud/psd/board", { signal });
+  }
+
   async getCloudAttention(window: AttentionWindow = "now", symbol?: string): Promise<AttentionPayload> {
     const path = symbol ? `/cloud/attention/${encodeURIComponent(symbol)}` : "/cloud/attention";
     return this.request<AttentionPayload>(`${path}?window=${window}`);
@@ -934,6 +954,15 @@ export class CloudDataApi {
     });
   }
 
+  async getCloudSecInsiderSignals(
+    params: CloudInsiderSignalsParams = {},
+    options?: { signal?: AbortSignal },
+  ): Promise<InsiderSignalsPayload> {
+    return this.request<InsiderSignalsPayload>(cloudSecInsiderSignalsPath(params), {
+      signal: options?.signal,
+    });
+  }
+
   async getCloudSecFilingDocuments(
     params: CloudSecFilingParams,
   ): Promise<CloudSecDocumentsResponse> {

package/src/api-client/earnings.ts

@@ -27,6 +27,8 @@ interface EarningsRealizedMove {
   afterClose: number;
 }
 
+type EarningsActualSource = "calendar" | "press-release";
+
 export interface EarningsReport {
   symbol: string;
   name: string | null;
@@ -43,6 +45,12 @@ export interface EarningsReport {
   /** For an upcoming report, the consensus every earnings view shows, with `epsAnalysts` behind it. */
   epsEstimate: number | null;
   epsActual: number | null;
+  /**
+   * Where `epsActual` comes from: `press-release` is the company's own
+   * release, read the day it reports and provisional until the calendar's
+   * figure replaces it. Absent from older servers.
+   */
+  epsActualSource?: EarningsActualSource | null;
   epsAnalysts: number | null;
   revenueEstimate: number | null;
   revenueAnalysts: number | null;
@@ -69,6 +77,8 @@ export interface EarningsCalendarPayload {
 
 interface EarningsHistoryReport extends EarningsReport {
   revenueActual: number | null;
+  /** `press-release` until the statements have the quarter; absent from older servers. */
+  revenueActualSource?: "statements" | "press-release" | null;
 }
 
 export interface EarningsHistoryPayload {

package/src/api-client/index.ts

@@ -645,6 +645,8 @@ class GloomApiClient {
   getChannels = this.chat.getChannels.bind(this.chat);
   getChatPresence = this.chat.getPresence.bind(this.chat);
   getChatState = this.chat.getState.bind(this.chat);
+  getChatMentionCandidates = this.chat.getMentionCandidates.bind(this.chat);
+  subscribeChatMentionCandidatesChanged = this.chat.subscribeMentionCandidatesChanged.bind(this.chat);
   updateChatChannelState = this.chat.updateChannelState.bind(this.chat);
   markChatNotificationsDelivered = this.chat.markNotificationsDelivered.bind(this.chat);
   getUnseenChatNotificationIds = this.chat.getUnseenNotificationIds.bind(this.chat);
@@ -826,6 +828,8 @@ class GloomApiClient {
   getCloudAward = this.data.getCloudAward.bind(this.data);
   getCloudDoeBoard = this.data.getCloudDoeBoard.bind(this.data);
   getCloudDoePrices = this.data.getCloudDoePrices.bind(this.data);
+  getCloudJodiBoard = this.data.getCloudJodiBoard.bind(this.data);
+  getCloudPsdBoard = this.data.getCloudPsdBoard.bind(this.data);
   getCloudAttention = this.data.getCloudAttention.bind(this.data);
   getCloudPowerBoard = this.data.getCloudPowerBoard.bind(this.data);
   getCloudPowerHistory = this.data.getCloudPowerHistory.bind(this.data);
@@ -864,6 +868,7 @@ class GloomApiClient {
   getRiskReport = this.data.getRiskReport.bind(this.data);
   getCloudSecFilings = this.data.getCloudSecFilings.bind(this.data);
   getCloudSecBeneficialOwners = this.data.getCloudSecBeneficialOwners.bind(this.data);
+  getCloudSecInsiderSignals = this.data.getCloudSecInsiderSignals.bind(this.data);
   getCloudSecFilingDocuments = this.data.getCloudSecFilingDocuments.bind(this.data);
   getCloudSecFilingContent = this.data.getCloudSecFilingContent.bind(this.data);
   getCloudSec13F = this.data.getCloudSec13F.bind(this.data);

package/src/api-client/insider-signals.ts

@@ -0,0 +1,75 @@
+/**
+ * Companies ranked by recent open-market insider buying, as
+ * `GET /cloud/sec/insider-signals` returns them. Only Form 4 purchases (code
+ * P) by officers, directors and 10% owners count. Dates are `YYYY-MM-DD`,
+ * values USD.
+ */
+
+type InsiderSignalRole =
+  | "CEO"
+  | "CFO"
+  | "COO"
+  | "President"
+  | "Chair"
+  | "Officer"
+  | "Director"
+  | "10% owner";
+
+interface InsiderSignalBuyer {
+  name: string;
+  role: InsiderSignalRole;
+  value: number;
+  /** Days the insider bought in the window. */
+  buys: number;
+  lastBuy: string;
+}
+
+export interface InsiderSignalRow {
+  ticker: string;
+  issuerCik: string;
+  company: string;
+  /** 0 to 100. */
+  score: number;
+  /** Why the company ranks, strongest first, in plain words. */
+  reasons: string[];
+  /** Distinct insiders who bought in the window. */
+  insiders: number;
+  /** Insider buy days in the window. */
+  buys: number;
+  value: number;
+  shares: number;
+  firstBuy: string;
+  lastBuy: string;
+  lastFiled: string;
+  signals: {
+    clusterInsiders: number;
+    repeatBuys: number;
+    usualRatio: number | null;
+    stakeIncreasePct: number | null;
+    newPosition: boolean;
+  };
+  /** The biggest buyers, up to five. */
+  buyers: InsiderSignalBuyer[];
+}
+
+export interface InsiderSignalsPayload {
+  /** Days of buying each row covers, ending `through`. */
+  window: number;
+  through: string;
+  /** The newest filing day read. */
+  asOf: string | null;
+  /**
+   * Days whose filings have all been read. `missingDays`: weekdays since
+   * `from` the server no longer reads on its own and has not read whole, a gap
+   * an outage left (left out by servers that predate it).
+   */
+  coverage: { from: string | null; through: string | null; missingDays?: string[] };
+  rows: InsiderSignalRow[];
+}
+
+export interface CloudInsiderSignalsParams {
+  /** Days, 1 to 90; the server reads 30 when left out. */
+  window?: number;
+  /** Rows, 1 to 200; the server reads 50 when left out. */
+  limit?: number;
+}

package/src/api-client/market-discovery.ts

@@ -19,7 +19,7 @@ export interface ScreenerQuote {
   lastUpdated?: number;
   /** Session-fixed, so the price column reads its decimals from it rather than from each tick. */
   previousClose?: number;
-  /** The quote's sessions beside the live print the list ranks by, when the server sends them. */
+  /** The quote's sessions beside the live print the server ranked the row by, when the server sends them. */
   sessions?: CloudMoverSessionFields;
 }
 

package/src/api-client/normalizers.ts

@@ -220,6 +220,7 @@ export function normalizeChatChannel(
     ...channel,
     kind: channel.kind ?? fallbackKind,
     created_at: normalizeTimestamp(channel.created_at),
+    ...(typeof channel.lastMessageAt === "string" ? { lastMessageAt: normalizeTimestamp(channel.lastMessageAt) } : {}),
     ...(channel.dmUser ? { dmUser: normalizeChatUser(channel.dmUser) } : {}),
     ...(Array.isArray(channel.members) ? { members: channel.members.map(normalizeChatUser) } : {}),
   };

package/src/api-client/paths.ts

@@ -7,6 +7,7 @@ import { isUsListingExchange, normalizeSymbol, parsePublicTickerKey, publicTicke
 import { nonUsSecListingVenue } from "../utils/sec";
 import type { HistoryRetention } from "../sources/history-retention";
 import type { CloudBeneficialOwnersParams } from "./beneficial-owners";
+import type { CloudInsiderSignalsParams } from "./insider-signals";
 import type { RevenueBreakdownView } from "./revenue-breakdown";
 
 export type CloudHistoryParams = {
@@ -444,6 +445,14 @@ export function cloudSecBeneficialOwnersPath(params: CloudBeneficialOwnersParams
   return appendQuery("/cloud/sec/beneficial-owners", search);
 }
 
+/** Companies ranked by recent open-market insider buying. */
+export function cloudSecInsiderSignalsPath(params: CloudInsiderSignalsParams = {}): string {
+  const search = new URLSearchParams();
+  if (params.window != null) search.set("window", String(params.window));
+  if (params.limit != null) search.set("limit", String(params.limit));
+  return appendQuery("/cloud/sec/insider-signals", search);
+}
+
 export function cloudSecFilingDocumentsPath(
   params: CloudSecFilingParams,
 ): string {

package/src/api-client/socket.ts

@@ -109,6 +109,7 @@ export class CloudApiSocket {
   private reconnectDelayMs = 1000;
 
   private readonly channelListeners = new Map<string, Set<ChannelListener>>();
+  private readonly chatMentionCandidatesListeners = new Set<() => void>();
   private readonly chatNotificationListeners =
     new Set<ChatNotificationListener>();
   private readonly chatChannelStateListeners =
@@ -254,6 +255,11 @@ export class CloudApiSocket {
     };
   }
 
+  subscribeChatMentionCandidatesChanged(listener: () => void): () => void {
+    this.chatMentionCandidatesListeners.add(listener);
+    return () => { this.chatMentionCandidatesListeners.delete(listener); };
+  }
+
   /**
    * The reader's read state or mute changed on another device or window. Like
    * notifications, it never opens the socket by itself.
@@ -631,6 +637,10 @@ export class CloudApiSocket {
       return;
     }
 
+    if (parsed?.type === "chat.mentions_changed") {
+      for (const listener of this.chatMentionCandidatesListeners) listener();
+      return;
+    }
     if (parsed?.type === "chat.channel_state") {
       const state = normalizeChatChannelStateFrame(parsed.data);
       if (state) {

package/src/api-client/types.ts

@@ -143,6 +143,21 @@ export interface ChatChannel {
   teamId?: string;
   dmUser?: ChatUserSummary | null;
   members?: ChatUserSummary[];
+  /**
+   * When the newest message you can see in a direct or group conversation was
+   * sent; null when it has none. Absent from channels of other kinds and from
+   * servers that do not report it.
+   */
+  lastMessageAt?: string | null;
+}
+
+/** Minimal identities scoped by the server to this channel and existing DMs. */
+export interface ChatMentionCandidate {
+  id: string;
+  username: string;
+  displayName: string | null;
+  channelActivityAt: string | null;
+  conversationActivityAt: string | null;
 }
 
 export interface ChatChannelState {
@@ -1517,6 +1532,15 @@ export interface CloudMarketBatchPayload<T> {
 
 export type CloudMarketScreenerCategory = "gainers" | "losers" | "most-active";
 
+/**
+ * What Gloom Cloud selects and ranks Gainers and Losers by: `regular` the last
+ * completed regular session's move, the Chg% a row shows; `extended` the
+ * latest print, after-hours or pre-market included. While the regular session
+ * trades the two are one list. A server that predates the choice ignores it
+ * and ranks by the latest print.
+ */
+export type CloudMoverSession = "regular" | "extended";
+
 /**
  * A movers row's quote sessions, under the quote's field names and meaning:
  * the session it was read in, the day its change is dated to, the last
@@ -1529,7 +1553,7 @@ export type CloudMoverSessionFields = Partial<Pick<Quote,
   | "preMarketPrice" | "preMarketChange" | "preMarketChangePercent"
   | "postMarketPrice" | "postMarketChange" | "postMarketChangePercent">>;
 
-/** price, change and changePercent are the live print the list is ranked by; the session fields say how it reads. */
+/** price, change and changePercent are the live print the server ranks the list by; the session fields say how it reads. */
 export interface CloudMarketScreenerItem extends CloudMoverSessionFields {
   rank: number;
   symbol: string;

package/src/app/runtime/broker-import.ts

@@ -8,7 +8,7 @@ import {
 import type { SyncBrokerInstanceResult } from "../../brokers/sync-broker-instance";
 import type { AppTickerRepositoryPort } from "../../core/app-service-ports";
 import type { PluginRegistry } from "../../plugins/registry";
-import { adoptHeldPortfolioCurrencies } from "../../plugins/builtin/portfolio-list/mutations";
+import { adoptHeldPortfolioCurrencies } from "../../portfolio/mutations";
 import { saveConfigImmediately } from "../../state/config-save-scheduler";
 import type { AppAction, AppState } from "../../state/app/context";
 import type { AppConfig } from "../../types/config";
@@ -18,6 +18,7 @@ import { getBrokerInstance } from "../../utils/broker-instances";
 export interface AppBrokerImportRuntime {
   importBrokerPositions: (
     instanceId: string,
+    /** What the sync reads. It lands on the app's tickers as they are when it commits, whatever was passed. */
     tickerMap?: Map<string, TickerRecord>,
     options?: BrokerImportOptions,
   ) => Promise<SyncBrokerInstanceResult>;
@@ -52,6 +53,13 @@ export function useBrokerImportRuntime({
   stateRef: { current: AppState };
   tickerRepository: AppTickerRepositoryPort;
 }): AppBrokerImportRuntime {
+  /**
+   * Commits a sync: carried onto the app as it is now (a pull or an edit while
+   * the broker answered stays) and handed to the app before anything is
+   * written. With a wait in between, a pull landing in it would be overwritten
+   * by this older copy and pushed from here as an edit. The writes start in
+   * the same tick, so the copy of anyone writing after lands on disk after it.
+   */
   const applyBrokerImportResult = useCallback(async (
     instanceId: string,
     result: SyncBrokerInstanceResult,
@@ -62,31 +70,27 @@ export function useBrokerImportRuntime({
     },
   ) => {
     throwIfBrokerImportCancelled(options?.signal);
-    dispatch({ type: "SET_BROKER_ACCOUNTS", instanceId, accounts: result.brokerAccounts });
-
-    const liveConfig = stateRef.current.config;
+    const live = stateRef.current;
+    result.rebase(live);
     const nextConfig = options?.callerOwnsConfig
-      ? (result.config !== baseConfig ? result.config : liveConfig)
-      : rebaseBrokerSyncConfig(liveConfig, baseConfig, result.config, instanceId);
-    if (nextConfig !== liveConfig) {
-      throwIfBrokerImportCancelled(options?.signal);
-      dispatch({ type: "SET_CONFIG", config: nextConfig });
-      await saveConfigImmediately(nextConfig);
-      throwIfBrokerImportCancelled(options?.signal);
-      pluginRegistry.events.emit("config:changed", { config: nextConfig });
+      ? (result.config !== baseConfig ? result.config : live.config)
+      : rebaseBrokerSyncConfig(live.config, baseConfig, result.config, instanceId);
+    const configChanged = nextConfig !== live.config;
+
+    dispatch({ type: "SET_BROKER_ACCOUNTS", instanceId, accounts: result.brokerAccounts });
+    if (configChanged) dispatch({ type: "SET_CONFIG", config: nextConfig });
+    for (const ticker of [...result.addedTickers, ...result.updatedTickers]) {
+      dispatch({ type: "UPDATE_TICKER", ticker });
     }
+    await Promise.all([result.commit(), configChanged ? saveConfigImmediately(nextConfig) : undefined]);
 
+    if (configChanged) pluginRegistry.events.emit("config:changed", { config: nextConfig });
     for (const ticker of result.addedTickers) {
-      throwIfBrokerImportCancelled(options?.signal);
       pluginRegistry.events.emit("ticker:added", { symbol: ticker.metadata.ticker, ticker });
     }
-    for (const ticker of [...result.addedTickers, ...result.updatedTickers]) {
-      throwIfBrokerImportCancelled(options?.signal);
-      dispatch({ type: "UPDATE_TICKER", ticker: { ...ticker } });
-    }
 
     for (const position of result.positions) {
-      throwIfBrokerImportCancelled(options?.signal);
+      if (options?.signal?.aborted) break;
       // Skip market data for broker option symbols; position marks are already available.
       // Position data (markPrice, marketValue, unrealizedPnl) is used directly.
       if (options?.refreshImportedTickers !== false && position.assetCategory !== "OPT") {
@@ -120,8 +124,6 @@ export function useBrokerImportRuntime({
       throwIfBrokerImportCancelled(options?.signal);
       options?.onCommitStart?.();
       commitStarted = true;
-      await result.commit();
-      throwIfBrokerImportCancelled(options?.signal);
       await applyBrokerImportResult(instanceId, result, baseConfig, {
         ...options,
         callerOwnsConfig: options?.config !== undefined,
@@ -155,7 +157,7 @@ export function useBrokerImportRuntime({
       deferPersistence: true,
       onResult: async (result, instance, previousConfig) => {
         if (!getBrokerInstance(stateRef.current.config.brokerInstances, instance.id)) return;
-        await result.commit();
+        // Startup syncs run beside the first pull: each lands on what it left.
         await applyBrokerImportResult(instance.id, result, previousConfig, {
           refreshImportedTickers: false,
         });

package/src/app/runtime/plugin-bindings.ts

@@ -3,7 +3,7 @@ import {
   clearPersistedBrokerAccounts,
   getBrokerAccountCacheSourceKey,
 } from "../../brokers/account-cache";
-import { findPortfolioHeir } from "../../brokers/broker-portfolio-sync";
+import { clearLeftoverBrokerHoldings, findPortfolioHeir, knownBrokerHoldings } from "../../brokers/broker-portfolio-sync";
 import type { AppTickerRepositoryPort } from "../../core/app-service-ports";
 import type { MarketDataCoordinator } from "../../market-data/coordinator";
 import { instrumentFromTicker } from "../../market-data/request-types";
@@ -216,15 +216,20 @@ export function bindPluginRegistryRuntimeAccess({
         return [heirId ? { ...portfolio, brokerInstanceId: heirId } : portfolio];
       });
       const nextTickers = new Map(stateRef.current.tickers);
+      const nextBrokerInstances = stateRef.current.config.brokerInstances.filter((entry) => entry.id !== instanceId);
+      // What older removals and pulls from other devices left behind goes as well.
+      const known = knownBrokerHoldings({ portfolios: nextPortfolios, brokerInstances: nextBrokerInstances });
 
       for (const ticker of stateRef.current.tickers.values()) {
-        const nextPositions = ticker.metadata.positions.filter((position) => position.brokerInstanceId !== instanceId);
+        // A position here without a profile came from another device's sync of this one.
+        const nextPositions = ticker.metadata.positions.filter((position) => position.brokerInstanceId !== instanceId
+          && !(removedPortfolioIds.has(position.portfolio) && !position.brokerInstanceId));
         const heldPortfolioIds = new Set(nextPositions.map((position) => position.portfolio));
         const nextPortfolioRefs = ticker.metadata.portfolios.filter((portfolioId) =>
           !removedPortfolioIds.has(portfolioId) && (!heirs.has(portfolioId) || heldPortfolioIds.has(portfolioId)));
         const nextBrokerContracts = (ticker.metadata.broker_contracts ?? []).filter((contract) => contract.brokerInstanceId !== instanceId);
 
-        const nextTicker: TickerRecord = {
+        const removedTicker: TickerRecord = {
           ...ticker,
           metadata: {
             ...ticker.metadata,
@@ -233,12 +238,13 @@ export function bindPluginRegistryRuntimeAccess({
             broker_contracts: nextBrokerContracts,
           },
         };
+        const nextTicker = clearLeftoverBrokerHoldings(removedTicker, known) ?? removedTicker;
 
         const shouldDeleteTicker =
-          nextPositions.length === 0
-          && nextPortfolioRefs.length === 0
+          nextTicker.metadata.positions.length === 0
+          && nextTicker.metadata.portfolios.length === 0
           && nextTicker.metadata.watchlists.length === 0
-          && nextBrokerContracts.length === 0
+          && (nextTicker.metadata.broker_contracts ?? []).length === 0
           && nextTicker.metadata.tags.length === 0
           && Object.keys(nextTicker.metadata.custom).length === 0;
 
@@ -256,7 +262,7 @@ export function bindPluginRegistryRuntimeAccess({
 
       const nextConfig = {
         ...stateRef.current.config,
-        brokerInstances: stateRef.current.config.brokerInstances.filter((entry) => entry.id !== instanceId),
+        brokerInstances: nextBrokerInstances,
         portfolios: nextPortfolios,
       };
 

package/src/app/runtime/update.ts

@@ -68,11 +68,24 @@ export function useAppUpdateRuntime({
   runUpdateCommand: () => void;
 } {
   const restartingRef = useRef(false);
+  /** The tag of a release whose download found nothing to take; the hourly check does not offer it again. */
+  const declinedTagRef = useRef<string | null>(null);
 
   const startUpdate = useCallback((release: ReleaseInfo) => {
     dispatch({ type: "SET_UPDATE_PROGRESS", progress: { phase: "downloading", percent: 0 } });
     void performUpdate(release, (progress) => {
       logUpdateFailure(progress);
+      if (progress.phase === "done") {
+        // The download had nothing to take (that build is the installed one):
+        // an answer like a check's, so it passes as a notice like one. The
+        // release goes before the progress, so the effect below never starts
+        // it again, and the hourly check does not offer it again.
+        declinedTagRef.current = release.tagName;
+        dispatch({ type: "SET_UPDATE_AVAILABLE", release: null });
+        dispatch({ type: "SET_UPDATE_PROGRESS", progress: null });
+        dispatch({ type: "SET_UPDATE_NOTICE", notice: progress.message ?? null });
+        return;
+      }
       dispatch({ type: "SET_UPDATE_PROGRESS", progress });
     });
   }, [dispatch]);
@@ -116,7 +129,7 @@ export function useAppUpdateRuntime({
     if (result.kind === "error") updateLog.warn("update check failed", { error: result.error });
 
     if (!manual) {
-      if (result.kind === "available") {
+      if (result.kind === "available" && result.release.tagName !== declinedTagRef.current) {
         dispatch({ type: "SET_UPDATE_AVAILABLE", release: result.release });
       }
       return;