gloomberb 0.11.0 → 0.11.2

package/src/sources/yahoo-finance/symbols.ts

@@ -1,3 +1,5 @@
+import { canonicalExchange } from "../../utils/exchanges";
+
 const EXCHANGE_SUFFIX_MAP: Record<string, string> = {
   NASDAQ: "", NMS: "", NYSE: "", AMEX: "", ARCA: "", NYSEArca: "", BATS: "", BYX: "", IEX: "", PINK: "", OTC: "",
   TSX: ".TO", VENTURE: ".V", CSE2: ".CN", CNSX: ".CN",
@@ -46,17 +48,19 @@ const KNOWN_SUFFIXES = new Set(
 
 export function getYahooSymbol(ticker: string, exchange: string): string {
   if (tickerHasYahooSuffix(ticker)) return ticker;
-  const suffix = EXCHANGE_SUFFIX_MAP[exchange] ?? "";
-  return `${normalizeYahooTicker(ticker, exchange)}${suffix}`;
+  const canonical = canonicalExchange(exchange) || exchange;
+  const suffix = EXCHANGE_SUFFIX_MAP[canonical] ?? EXCHANGE_SUFFIX_MAP[exchange] ?? "";
+  return `${normalizeYahooTicker(ticker, canonical)}${suffix}`;
 }
 
 export function getYahooSymbolsToTry(ticker: string, exchange: string): string[] {
   if (tickerHasYahooSuffix(ticker)) return [ticker];
 
-  const normalized = normalizeYahooTicker(ticker, exchange);
+  const canonical = canonicalExchange(exchange) || exchange;
+  const normalized = normalizeYahooTicker(ticker, canonical);
   const dotVariant = normalized.includes(".") ? normalized.replace(/\./g, "-") : null;
 
-  if (!exchange) {
+  if (!canonical) {
     const symbols = new Set<string>();
     const candidates = [normalized];
     if (dotVariant) candidates.unshift(dotVariant);
@@ -69,16 +73,16 @@ export function getYahooSymbolsToTry(ticker: string, exchange: string): string[]
     return Array.from(symbols);
   }
 
-  const fallbacks = EXCHANGE_FALLBACKS[exchange];
+  const fallbacks = EXCHANGE_FALLBACKS[canonical] ?? EXCHANGE_FALLBACKS[exchange];
   if (fallbacks) {
     const results = fallbacks.map((suffix) => `${normalized}${suffix}`);
     if (dotVariant) results.unshift(...fallbacks.map((suffix) => `${dotVariant}${suffix}`));
     return results;
   }
 
-  const primary = getYahooSymbol(ticker, exchange);
+  const primary = getYahooSymbol(ticker, canonical);
   if (dotVariant) {
-    const suffix = EXCHANGE_SUFFIX_MAP[exchange] ?? "";
+    const suffix = EXCHANGE_SUFFIX_MAP[canonical] ?? EXCHANGE_SUFFIX_MAP[exchange] ?? "";
     return [`${dotVariant}${suffix}`, primary];
   }
   return [primary];
@@ -98,5 +102,6 @@ function normalizeYahooTicker(ticker: string, exchange: string): string {
 }
 
 function isHongKongExchange(exchange: string): boolean {
-  return exchange === "HKEX" || exchange === "SEHK" || exchange === "HKG";
+  const canonical = canonicalExchange(exchange) || exchange;
+  return canonical === "HKEX" || canonical === "SEHK" || canonical === "HKG";
 }

package/src/sources/yahoo-finance.test.ts

@@ -282,7 +282,7 @@ describe("YahooFinanceClient exchange aliases", () => {
       dividends: [{ exDate: "2026-02-03", amount: 0.12 }],
       splits: [{ date: "2026-01-02", description: "2:1 split", ratio: 2, fromFactor: 1, toFactor: 2 }],
       earnings: [
-        { date: "2026-03-16", time: "BMO", epsEstimate: -0.185 },
+        { date: "2026-03-16", time: "", epsEstimate: -0.185 },
         { date: "2026-01-31", epsActual: -0.35, epsEstimate: -0.13, difference: -0.22, surprisePercent: -169.23 },
       ],
     });

package/src/sources/yahoo-finance.ts

@@ -137,7 +137,9 @@ export class YahooFinanceClient implements DataProvider {
         const result = await loadYahooTickerFinancials(symbol, {
           fetchAssetProfile: (targetSymbol) => this.fetchAssetProfile(targetSymbol),
           fetchChart: (targetSymbol, range, interval) => this.fetchChart(targetSymbol, range, interval),
-          fetchExtendedHoursData: (targetSymbol, meta) => this.fetchExtendedHoursData(targetSymbol, meta),
+          fetchExtendedHoursData: (targetSymbol, meta, regularClose) => (
+            this.fetchExtendedHoursData(targetSymbol, meta, regularClose)
+          ),
           fetchQuoteSupplement: (targetSymbol, currencyDivisor) =>
             this.fetchQuoteSupplement(targetSymbol, currencyDivisor),
           fetchTimeseries: (targetSymbol, types, period1) => this.fetchTimeseries(targetSymbol, types, period1),
@@ -176,7 +178,9 @@ export class YahooFinanceClient implements DataProvider {
       try {
         return await loadYahooQuote(symbol, {
           fetchChart: (targetSymbol, range, interval) => this.fetchChart(targetSymbol, range, interval),
-          fetchExtendedHoursData: (targetSymbol, meta) => this.fetchExtendedHoursData(targetSymbol, meta),
+          fetchExtendedHoursData: (targetSymbol, meta, regularClose) => (
+            this.fetchExtendedHoursData(targetSymbol, meta, regularClose)
+          ),
           fetchQuoteSupplement: (targetSymbol, currencyDivisor) =>
             this.fetchQuoteSupplement(targetSymbol, currencyDivisor),
           providerId: this.id,

package/src/state/app/bootstrap.ts

@@ -105,13 +105,12 @@ function resolveSymbolForPane(
   const instance = findPaneInstance(config.layout, instanceId);
   if (!instance) return null;
 
-  if (instance.paneId === "portfolio-list") {
-    const cursor = paneStateSeed[instanceId]?.cursorSymbol
-      ?? (typeof sessionSnapshot?.paneState?.[instanceId]?.cursorSymbol === "string"
-        ? sessionSnapshot.paneState[instanceId]?.cursorSymbol as string
-        : null);
-    return cursor && tickerMap.has(cursor) ? cursor : null;
-  }
+  // Any pane can publish a cursor symbol; followers resolve through it.
+  const cursor = paneStateSeed[instanceId]?.cursorSymbol
+    ?? (typeof sessionSnapshot?.paneState?.[instanceId]?.cursorSymbol === "string"
+      ? sessionSnapshot.paneState[instanceId]?.cursorSymbol as string
+      : null);
+  if (cursor) return tickerMap.has(cursor) ? cursor : null;
 
   if (instance.binding?.kind === "fixed") {
     return tickerMap.has(instance.binding.symbol) ? instance.binding.symbol : null;

package/src/state/app/context/index.test.ts

@@ -1,7 +1,8 @@
 import { describe, expect, test } from "bun:test";
 import { appReducer, createInitialState, resolveCollectionForPane, resolveTickerForPane } from "./index";
-import { cloneLayout, createDefaultConfig, createPaneInstance } from "../../../types/config";
+import { cloneLayout, createDefaultConfig, createPaneInstance, findPaneInstance } from "../../../types/config";
 import type { AppSessionSnapshot } from "../../../core/state/session-persistence";
+import { removePane } from "../../../plugins/pane-manager";
 import { buildBrokerPortfolioId } from "../../../utils/broker-instances";
 
 describe("resolveTickerForPane", () => {
@@ -18,6 +19,45 @@ describe("resolveTickerForPane", () => {
     expect(resolveTickerForPane(state, "ticker-detail:main")).toBe("AAPL");
   });
 
+  test("follows cursor symbols from any ticker source pane", () => {
+    const config = createDefaultConfig("/tmp/gloomberb-test");
+    const source = createPaneInstance("ai-screener", {
+      instanceId: "ai-screener:main",
+      binding: { kind: "none" },
+    });
+    const follower = createPaneInstance("ticker-detail", {
+      instanceId: "ticker-detail:screener",
+      binding: { kind: "follow", sourceInstanceId: source.instanceId },
+    });
+    config.layout.instances.push(source, follower);
+    config.layout.floating.push(
+      { instanceId: source.instanceId, x: 0, y: 0, width: 40, height: 12 },
+      { instanceId: follower.instanceId, x: 1, y: 1, width: 40, height: 12 },
+    );
+
+    const state = createInitialState(config);
+    state.paneState[source.instanceId] = { cursorSymbol: "NVDA" };
+
+    expect(resolveTickerForPane(state, source.instanceId)).toBe("NVDA");
+    expect(resolveTickerForPane(state, follower.instanceId)).toBe("NVDA");
+  });
+
+  test("pins a follower to its last ticker when its source closes", () => {
+    const config = createDefaultConfig("/tmp/gloomberb-test");
+    const state = createInitialState(config);
+    state.paneState["portfolio-list:main"] = { collectionId: "main", cursorSymbol: "AAPL" };
+
+    const next = appReducer(state, {
+      type: "UPDATE_LAYOUT",
+      layout: removePane(state.config.layout, "portfolio-list:main"),
+    });
+
+    expect(findPaneInstance(next.config.layout, "ticker-detail:main")?.binding).toEqual({
+      kind: "fixed",
+      symbol: "AAPL",
+    });
+  });
+
   test("uses fixed ticker bindings for pinned panes", () => {
     const config = createDefaultConfig("/tmp/gloomberb-test");
     const instance = createPaneInstance("ticker-detail", {

package/src/state/app/context/index.test.tsx

@@ -4,22 +4,6 @@ import { appReducer, createInitialState } from "./index";
 import { removePane } from "../../../plugins/pane-manager";
 
 describe("appReducer command bar state", () => {
-  test("re-shows the gridlock tip and refreshes its sequence on every trigger", () => {
-    const initial = createInitialState(createDefaultConfig("/tmp/gloomberb-test"));
-
-    const shown = appReducer(initial, { type: "SHOW_GRIDLOCK_TIP" });
-    expect(shown.gridlockTipVisible).toBe(true);
-    expect(shown.gridlockTipSequence).toBe(1);
-
-    const dismissed = appReducer(shown, { type: "DISMISS_GRIDLOCK_TIP" });
-    expect(dismissed.gridlockTipVisible).toBe(false);
-    expect(dismissed.gridlockTipSequence).toBe(1);
-
-    const repeated = appReducer(dismissed, { type: "SHOW_GRIDLOCK_TIP" });
-    expect(repeated.gridlockTipVisible).toBe(true);
-    expect(repeated.gridlockTipSequence).toBe(2);
-  });
-
   test("tracks layout undo and redo history", () => {
     const initial = createInitialState(createDefaultConfig("/tmp/gloomberb-test"));
     const defaultRatio = initial.config.layout.dockRoot && initial.config.layout.dockRoot.kind === "split"
@@ -195,6 +179,40 @@ describe("appReducer command bar state", () => {
     expect(state.config.layouts[state.config.activeLayoutIndex]?.name).toBe("Overview Copy");
   });
 
+  test("installs marketplace layouts as independent editable copies", () => {
+    const config = createDefaultConfig("/tmp/gloomberb-marketplace-install-test");
+    config.layouts.push(
+      { name: "Research", layout: cloneLayout(config.layout) },
+      { name: "Research (2)", layout: cloneLayout(config.layout) },
+    );
+    const marketplaceLayout = cloneLayout(config.layout);
+    if (!marketplaceLayout.dockRoot || marketplaceLayout.dockRoot.kind !== "split") {
+      throw new Error("expected split dock root");
+    }
+    marketplaceLayout.dockRoot.ratio = 0.72;
+
+    const installed = appReducer(createInitialState(config), {
+      type: "INSTALL_LAYOUT_COPY",
+      name: "Research",
+      layout: marketplaceLayout,
+      paneState: {
+        "ticker-detail:main": {
+          pluginState: { "prediction-markets": { searchQuery: "fed" } },
+        },
+      },
+    });
+
+    expect(installed.config.layouts.at(-1)?.name).toBe("Research (3)");
+    expect(installed.config.activeLayoutIndex).toBe(installed.config.layouts.length - 1);
+    expect(installed.config.layout.dockRoot).toMatchObject({ kind: "split", ratio: 0.72 });
+    expect(installed.paneState["ticker-detail:main"]).toMatchObject({
+      pluginState: { "prediction-markets": { searchQuery: "fed" } },
+    });
+
+    marketplaceLayout.dockRoot.ratio = 0.2;
+    expect(installed.config.layout.dockRoot).toMatchObject({ kind: "split", ratio: 0.72 });
+  });
+
   test("restores an explicit focus target after a layout removes the focused pane", () => {
     const config = createDefaultConfig("/tmp/gloomberb-test-focus-restore");
     const nextLayout = removePane(config.layout, "ticker-detail:main");

package/src/state/selectors-ui.ts

@@ -30,14 +30,6 @@ export function selectActiveLayoutIndex(state: AppState): number {
   return state.config.activeLayoutIndex;
 }
 
-export function selectGridlockTipVisible(state: AppState): boolean {
-  return state.gridlockTipVisible;
-}
-
-export function selectGridlockTipSequence(state: AppState): number {
-  return state.gridlockTipSequence;
-}
-
 export function selectUpdateAvailable(state: AppState): ReleaseInfo | null {
   return state.updateAvailable;
 }

package/src/sync/baseline.ts

@@ -0,0 +1,32 @@
+import type { AppPluginStateStorePort } from "../core/app-service-ports";
+import type { SyncBaselineStore } from "./types";
+
+const BASELINE_PLUGIN_ID = "core.sync";
+const BASELINE_KEY = "last-synced-payloads";
+
+/**
+ * Persists what this device last pushed so the next pull can tell "the cloud is
+ * newer" from "local changed while the app was closed". Without it every launch
+ * treats local state as pristine and the cloud overwrites CLI/offline edits.
+ *
+ * Storage failures are swallowed: a missing baseline only falls back to keeping
+ * local state, never to discarding it.
+ */
+export function createSyncBaselineStore(pluginState: AppPluginStateStorePort): SyncBaselineStore {
+  return {
+    load: () => {
+      try {
+        return pluginState.get<Record<string, unknown>>(BASELINE_PLUGIN_ID, BASELINE_KEY)?.value ?? null;
+      } catch {
+        return null;
+      }
+    },
+    save: (payloads) => {
+      try {
+        pluginState.set(BASELINE_PLUGIN_ID, BASELINE_KEY, payloads);
+      } catch {
+        // Ignored: a stale baseline only makes the next pull more conservative.
+      }
+    },
+  };
+}

package/src/sync/controller.test.ts

@@ -14,12 +14,79 @@ import {
 import { CloudSyncController } from "./controller";
 import {
   SYNC_SNAPSHOT_SCHEMA_VERSION,
+  type SyncBaselineStore,
   type SyncContributor,
   type SyncSnapshot,
   type SyncSnapshotResponse,
   type SyncTransport,
 } from "./types";
 
+test("keeps workspace edits made while the app was closed and uploads them", async () => {
+  // The CLI writes config.json directly, so at launch local state looks
+  // pristine and the cloud copy used to overwrite it.
+  const syncedConfig = createDefaultConfig("/tmp/gloomberb-sync-offline-edit-test");
+  syncedConfig.portfolios = [{ id: "main", name: "Main", currency: "USD" }];
+  const syncedPayload = __syncContributorInternalsForTests.collectCoreConfigPayload(syncedConfig);
+  const stored: Record<string, unknown> = { "core.config": syncedPayload };
+  const baselineStore: SyncBaselineStore = {
+    load: () => stored,
+    save: (payloads) => Object.assign(stored, payloads),
+  };
+
+  let state = createInitialState({
+    ...syncedConfig,
+    portfolios: [...syncedConfig.portfolios, { id: "research", name: "Research", currency: "USD" }],
+  });
+  const dispatch = (action: AppAction) => {
+    state = appReducer(state, action);
+  };
+  const pushes: SyncSnapshot[] = [];
+  const transport: SyncTransport = {
+    id: "offline-edit",
+    isAvailable: () => true,
+    pullSnapshot: async () => ({
+      snapshot: {
+        schemaVersion: SYNC_SNAPSHOT_SCHEMA_VERSION,
+        appId: "gloomberb",
+        clientId: "remote-client",
+        createdAt: "2026-08-23T10:00:00.000Z",
+        contributors: {
+          "core.config": {
+            schemaVersion: 1,
+            updatedAt: "2026-08-23T10:00:00.000Z",
+            payload: syncedPayload,
+          },
+        },
+      },
+      revision: 4,
+      updatedAt: "2026-08-23T10:00:00.000Z",
+    }),
+    pushSnapshot: async (snapshot) => {
+      pushes.push(snapshot);
+      return { revision: 5, updatedAt: "2026-08-23T10:00:05.000Z" };
+    },
+  };
+
+  const controller = new CloudSyncController();
+  controller.setRuntime({
+    getState: () => state,
+    dispatch,
+    tickerRepository: {} as TickerRepository,
+    baselineStore,
+    getContributors: () => [{ pluginId: "core", contributor: coreConfigSyncContributor }],
+    getTransport: () => ({ pluginId: "test", transport }),
+  });
+
+  await controller.requestSync({ reason: "startup" });
+
+  const pushedPortfolios = (pushes[0]?.contributors["core.config"]?.payload as {
+    portfolios: Array<{ id: string }>;
+  }).portfolios.map((portfolio) => portfolio.id);
+  expect(state.config.portfolios.map((portfolio) => portfolio.id)).toEqual(["main", "research"]);
+  expect(pushedPortfolios).toEqual(["main", "research"]);
+  expect((stored["core.config"] as { portfolios: Array<{ id: string }> }).portfolios).toHaveLength(2);
+});
+
 test("does not push local state when the initial pull fails", async () => {
   let pushes = 0;
   const transport: SyncTransport = {
@@ -240,7 +307,7 @@ test("keeps startup layout changes while serializing pull and push", async () =>
   const pushedConfig = pushes[0]?.snapshot.contributors["core.config"]?.payload as {
     layout: AppState["config"]["layout"];
   };
-  expect(pulls).toBe(1);
+  expect(pulls).toBe(2);
   expect(pushes).toHaveLength(1);
   expect(pushes[0]?.options).toEqual({ baseRevision: 7 });
   expect(state.config.theme).toBe("green");
@@ -314,3 +381,59 @@ test("keeps the latest layout when switching away and back during a pull", async
   expect(state.config.activeLayoutIndex).toBe(0);
   expect(pushedConfig.activeLayoutIndex).toBe(0);
 });
+
+test("pulls remote changes on later syncs instead of only once per session", async () => {
+  const applied: unknown[] = [];
+  const contributor: SyncContributor = {
+    id: "test.data",
+    schemaVersion: 1,
+    collect: () => ({ local: applied.at(-1) ?? null }),
+    apply: (payload) => {
+      applied.push(payload);
+    },
+  };
+  let remote = { value: 1 };
+  let remoteRevision = 4;
+  let pulls = 0;
+  const transport: SyncTransport = {
+    id: "repeat-pull",
+    isAvailable: () => true,
+    pullSnapshot: async () => {
+      pulls += 1;
+      return {
+        snapshot: {
+          schemaVersion: SYNC_SNAPSHOT_SCHEMA_VERSION,
+          appId: "gloomberb",
+          clientId: "remote-client",
+          createdAt: "2026-08-27T00:00:00.000Z",
+          contributors: {
+            "test.data": {
+              schemaVersion: 1,
+              updatedAt: "2026-08-27T00:00:00.000Z",
+              payload: remote,
+            },
+          },
+        },
+        revision: remoteRevision,
+        updatedAt: "2026-08-27T00:00:00.000Z",
+      };
+    },
+    pushSnapshot: async () => ({ revision: remoteRevision + 1, updatedAt: "2026-08-27T00:00:01.000Z" }),
+  };
+  const controller = new CloudSyncController();
+  controller.setRuntime({
+    getState: () => ({} as AppState),
+    dispatch: () => {},
+    tickerRepository: {} as TickerRepository,
+    getContributors: () => [{ pluginId: "test", contributor }],
+    getTransport: () => ({ pluginId: "test", transport }),
+  });
+
+  await controller.requestSync({ reason: "startup" });
+  remote = { value: 2 };
+  remoteRevision = 12;
+  await controller.requestSync({ reason: "poll" });
+
+  expect(pulls).toBe(2);
+  expect(applied).toEqual([{ value: 1 }, { value: 2 }]);
+});

package/src/sync/controller.ts

@@ -6,6 +6,7 @@ import {
   SYNC_SNAPSHOT_SCHEMA_VERSION,
   type RegisteredSyncContributor,
   type RegisteredSyncTransport,
+  type SyncBaselineStore,
   type SyncContributor,
   type SyncSnapshot,
   type SyncTransport,
@@ -28,6 +29,7 @@ interface SyncRuntime {
   tickerRepository: AppTickerRepositoryPort;
   getContributors: () => RegisteredSyncContributor[];
   getTransport: () => RegisteredSyncTransport | null;
+  baselineStore?: SyncBaselineStore;
 }
 
 const CLIENT_ID_STORAGE_KEY = "gloomberb.sync.clientId";
@@ -65,7 +67,10 @@ export class CloudSyncController {
   private syncQueued = false;
   private clientId: string | null = null;
   private lastSignature: string | null = null;
-  private hasPulledForTransport = new Set<string>();
+  private baseline: Record<string, unknown> | null = null;
+  private baselineLoaded = false;
+  private pulledContributors: SyncSnapshot["contributors"] = {};
+  private appliedRevision: number | null = null;
   private status: CloudSyncStatus = {
     phase: "idle",
     transportId: null,
@@ -181,12 +186,11 @@ export class CloudSyncController {
     }
     const transport = registration.transport;
 
-    if (!this.hasPulledForTransport.has(transport.id)) {
-      this.lastSignature = null;
-      if (!await this.runPull(runtime, transport)) return;
-      if (!this.isCurrent(runtime, transport)) return;
-      this.hasPulledForTransport.add(transport.id);
-    }
+    // Always pull before push. Another device (TUI, browser, phone) may have
+    // written since this process last synced, and contributors already merge
+    // so local-only edits survive the apply.
+    if (!await this.runPull(runtime, transport)) return;
+    if (!this.isCurrent(runtime, transport)) return;
 
     const snapshot = await this.assembleSnapshot(runtime);
     if (!this.isCurrent(runtime, transport)) return;
@@ -198,6 +202,8 @@ export class CloudSyncController {
       const result = await transport.pushSnapshot(snapshot, { baseRevision: this.status.revision });
       if (!this.isCurrent(runtime, transport)) return;
       this.lastSignature = signature;
+      this.appliedRevision = result.revision;
+      this.saveBaseline(runtime, snapshot);
       this.setStatus({
         phase: "synced",
         transportId: transport.id,
@@ -222,8 +228,9 @@ export class CloudSyncController {
       const response = await transport.pullSnapshot();
       if (!this.isCurrent(runtime, transport)) return false;
 
-      if (response.snapshot) {
+      if (response.snapshot && this.shouldApplyPulledRevision(response.revision)) {
         this.assertSnapshotCompatible(response.snapshot, runtime.getContributors());
+        this.pulledContributors = response.snapshot.contributors;
         for (const entry of runtime.getContributors()) {
           if (!this.isCurrent(runtime, transport)) return false;
           const contributorPayload = response.snapshot.contributors[entry.contributor.id];
@@ -231,6 +238,7 @@ export class CloudSyncController {
           await entry.contributor.apply(contributorPayload.payload, {
             snapshot: response.snapshot,
             baselineState,
+            baselinePayload: this.loadBaseline(runtime)?.[entry.contributor.id] ?? null,
             state: runtime.getState(),
             getState: runtime.getState,
             isCurrent: () => this.isCurrent(runtime, transport),
@@ -238,15 +246,16 @@ export class CloudSyncController {
             tickerRepository: runtime.tickerRepository,
           });
         }
+        if (response.revision != null) this.appliedRevision = response.revision;
       }
 
       if (!this.isCurrent(runtime, transport)) return false;
       this.setStatus({
         phase: response.snapshot ? "synced" : "idle",
         transportId: transport.id,
-        revision: response.revision,
+        revision: this.newerRevision(response.revision),
         lastPullAt: response.updatedAt ?? nowIso(),
-        lastSyncAt: response.updatedAt,
+        lastSyncAt: response.updatedAt ?? this.status.lastSyncAt,
         error: null,
       });
       return true;
@@ -287,7 +296,10 @@ export class CloudSyncController {
   private async assembleSnapshot(runtime: SyncRuntime): Promise<SyncSnapshot> {
     const contributors = runtime.getContributors();
     const createdAt = nowIso();
-    const payloads: SyncSnapshot["contributors"] = {};
+    // The snapshot replaces the stored one wholesale, so data owned by a
+    // contributor this client does not run (disabled plugin, older build) is
+    // carried over instead of being deleted for every other device.
+    const payloads: SyncSnapshot["contributors"] = { ...this.pulledContributors };
     for (const entry of contributors) {
       const payload = await entry.contributor.collect({ state: runtime.getState() });
       payloads[entry.contributor.id] = {
@@ -305,17 +317,47 @@ export class CloudSyncController {
     };
   }
 
+  private loadBaseline(runtime: SyncRuntime): Record<string, unknown> | null {
+    if (!this.baselineLoaded) {
+      this.baselineLoaded = true;
+      this.baseline = runtime.baselineStore?.load() ?? null;
+    }
+    return this.baseline;
+  }
+
+  private saveBaseline(runtime: SyncRuntime, snapshot: SyncSnapshot): void {
+    const payloads = Object.fromEntries(
+      Object.entries(snapshot.contributors).map(([id, contributor]) => [id, contributor.payload]),
+    );
+    this.baseline = payloads;
+    this.baselineLoaded = true;
+    runtime.baselineStore?.save(payloads);
+  }
+
   private isCurrent(runtime: SyncRuntime, transport: SyncTransport): boolean {
     return this.runtime === runtime && runtime.getTransport()?.transport === transport;
   }
 
+  private shouldApplyPulledRevision(revision: number | null): boolean {
+    return revision == null || this.appliedRevision == null || revision > this.appliedRevision;
+  }
+
+  private newerRevision(revision: number | null): number | null {
+    if (revision == null) return this.status.revision;
+    if (this.status.revision == null || revision > this.status.revision) return revision;
+    return this.status.revision;
+  }
+
   private resetOperations(): void {
     if (this.pushTimer) clearTimeout(this.pushTimer);
     this.pushTimer = null;
     this.inFlight = null;
     this.syncQueued = false;
-    this.hasPulledForTransport.clear();
     this.lastSignature = null;
+    this.appliedRevision = null;
+    this.baseline = null;
+    this.baselineLoaded = false;
+    this.pulledContributors = {};
   }
 
   private updateAvailability(): void {

package/src/sync/core-contributors.test.ts

@@ -260,6 +260,50 @@ describe("core sync contributors", () => {
     expect((payload as any).analyticsByPortfolio.main.oneYearReturn).toBe(0.42);
   });
 
+  test("keeps a position written while the app was closed", async () => {
+    const config = createDefaultConfig("/tmp/gloomberb-sync-position-test");
+    config.portfolios = [{ id: "main", name: "Main", currency: "USD" }];
+    const withoutPosition: TickerRecord = {
+      metadata: {
+        ticker: "NVDA",
+        exchange: "NASDAQ",
+        currency: "USD",
+        name: "NVIDIA",
+        portfolios: ["main"],
+        watchlists: [],
+        positions: [],
+        custom: {},
+        tags: [],
+      },
+    };
+    const syncedState = createInitialState(config);
+    syncedState.tickers = new Map([["NVDA", withoutPosition]]);
+    const syncedPayload = await coreCollectionsSyncContributor.collect({ state: syncedState });
+
+    // `gloomberb portfolio position set` wrote this straight to the database.
+    const state = createInitialState(config);
+    state.tickers = new Map([["NVDA", {
+      metadata: {
+        ...withoutPosition.metadata,
+        positions: [{ portfolio: "main", shares: 10, avgCost: 100, broker: "manual", currency: "USD" }],
+      },
+    }]]);
+
+    const saved: TickerRecord[] = [];
+    await coreCollectionsSyncContributor.apply?.(syncedPayload, {
+      baselinePayload: syncedPayload,
+      baselineState: state,
+      state,
+      getState: () => state,
+      isCurrent: () => true,
+      dispatch: () => {},
+      tickerRepository: { saveTicker: async (record: TickerRecord) => { saved.push(record); } },
+    } as unknown as Parameters<NonNullable<typeof coreCollectionsSyncContributor.apply>>[1]);
+
+    expect(saved).toHaveLength(0);
+    expect(state.tickers.get("NVDA")?.metadata.positions).toHaveLength(1);
+  });
+
   test("syncs only public return and beta analytics", async () => {
     const config = createDefaultConfig("/tmp/gloomberb-sync-test");
     config.baseCurrency = "USD";