gloomberb 0.18.4 → 0.19.0

package/src/sources/provider-router/index.ts

@@ -21,7 +21,8 @@ import type {
 } from "../../types/data-provider";
 import type { CapabilityRouteSource } from "../../types/capability-route-source";
 import { routeSourcePriority } from "../../types/capability-route-source";
-import type { AnalystResearchData, CorporateActionsData, HolderData, OptionsChain, PricePoint, Quote, QuoteMetadata, TickerFinancials } from "../../types/financials";
+import type { AnalystResearchData, CorporateActionsData, HolderData, OptionsChain, PricePoint, Quote, QuoteContributionMap, QuoteMetadata, TickerFinancials } from "../../types/financials";
+import { datedCloseListingKey, PreviousCloseDates, type DatedCloseListing } from "../../market-data/market/dated-previous-close";
 import { mergeQuoteMetadata, quoteMetadataFromQuote, quoteMetadataMatchesTarget } from "../../market-data/quotes/metadata";
 import type { NewsArticle, NewsQuery } from "../../news/types";
 import type { BrokerContractRef, InstrumentSearchResult } from "../../types/instrument";
@@ -52,6 +53,7 @@ import { ProviderRouterSearchRoutes } from "./search";
 import { collectCapabilityRouteSources, normalizeRouteSource } from "./sources";
 import type { ProviderRouterCoreDeps } from "./route-types";
 import { withProviderConnectionHealth } from "./connection-health";
+import { withFiledTrailingEps } from "../../time-series/filed-trailing-eps";
 import {
   contextFromCachedTarget,
   getBrokerCandidates,
@@ -64,6 +66,14 @@ import {
 
 const providerLog = debugLog.createLogger("asset-data-router");
 
+/**
+ * How long a short-lived process (the CLI) waits in all, per request that
+ * prints what its moves are from, for the daily closes that date them. The
+ * long-lived app never waits: it answers with what was read and dates the
+ * copies after.
+ */
+const CHANGE_BASIS_WAIT_MS = 2_500;
+
 export class AssetDataRouter implements DataProvider {
   readonly id = "asset-data-router";
   readonly name = "Asset Data Router";
@@ -86,6 +96,18 @@ export class AssetDataRouter implements DataProvider {
   private realtimeCloudAccess: RealtimeCloudAccess = createSignedInRealtimeCloudAccess();
   /** A short-lived process exits before a background refresh can land, so it must await stale entries. */
   private revalidateInBackground = true;
+  /**
+   * Every quote this router answers names the day its previous close is from,
+   * where the venue's calendar cannot. The closes come from the providers
+   * alone, the chart's month of them shared: a broker is never asked once
+   * per listing. A read that lands dates the latest copy for its listing's
+   * stream subscribers.
+   */
+  private readonly previousCloseDates = new PreviousCloseDates(
+    (listing) => this.historyRoutes.getPriceHistory(listing.symbol, listing.exchange, "1M", listingHistoryContext(listing.context), { askBrokers: false }),
+    { onDated: (listing, quote) => { for (const listener of this.datedQuoteListeners.get(datedCloseListingKey(listing)) ?? []) listener(quote); } },
+  );
+  private readonly datedQuoteListeners = new Map<string, Set<(quote: Quote) => void>>();
 
   constructor(
     fallbackSource: CapabilityRouteSource | DataProvider | null = null,
@@ -188,7 +210,13 @@ export class AssetDataRouter implements DataProvider {
     options: { allowExpired?: boolean; includeStaleQuotes?: boolean } = {},
   ): Map<string, TickerFinancials> {
     const { valid } = mapListingTargets(targets, (target) => this.resolvePublicExchange(target.symbol, target.exchange, contextFromCachedTarget(target)));
-    return this.financialRoutes.getCachedFinancialsForTargets(valid, options);
+    const cached = this.financialRoutes.getCachedFinancialsForTargets(valid, options);
+    for (const target of valid) {
+      const key = target.symbol.toUpperCase();
+      const financials = cached.get(key);
+      if (financials) cached.set(key, withFiledTrailingEps(this.knownFinancials(financials, listingOf(target, contextFromCachedTarget(target)))));
+    }
+    return cached;
   }
 
   getCachedExchangeRates(currencies: string[], options: { allowExpired?: boolean } = {}): Map<string, number> {
@@ -200,7 +228,18 @@ export class AssetDataRouter implements DataProvider {
     options: QuoteBatchOptions = {},
   ): Promise<QuoteBatchResult[]> {
     const mapped = mapListingTargets(targets, (target) => this.resolvePublicExchange(target.symbol, target.exchange, target.context));
-    const results = await this.batchRoutes.getQuotesBatch(mapped.valid, options);
+    const answered = await this.batchRoutes.getQuotesBatch(mapped.valid, withoutDating(options));
+    const quoted = answered.flatMap((result) => result.quote ? [{ quote: result.quote, listing: listingOf(result.target, result.target.context) }] : []);
+    // A cache-only answer never reaches the network, so it is dated only by what was read already.
+    const dated = options.cacheOnly
+      ? quoted.map(({ quote, listing }) => this.previousCloseDates.known(quote, listing))
+      : await this.datedAnswers(quoted, options.datesChangeBasis, options.signal);
+    let next = 0;
+    const results = answered.map((result) => {
+      if (!result.quote) return result;
+      const quote = dated[next++]!;
+      return quote === result.quote ? result : { ...result, quote };
+    });
     const restored = new Map<QuoteSubscriptionTarget, QuoteBatchResult>(results.map((result) => {
       const target = mapped.original(result.target);
       return [target, { ...result, target }] as const;
@@ -216,10 +255,20 @@ export class AssetDataRouter implements DataProvider {
 
   async getTickerFinancialsBatch(
     targets: CachedFinancialsTarget[],
-    options: { forceRefresh?: boolean } = {},
+    options: { forceRefresh?: boolean; datesChangeBasis?: boolean } = {},
   ): Promise<TickerFinancialsBatchResult[]> {
     const mapped = mapListingTargets(targets, (target) => this.resolvePublicExchange(target.symbol, target.exchange, contextFromCachedTarget(target)));
-    const results = await this.batchRoutes.getTickerFinancialsBatch(mapped.valid, options);
+    const answered = await this.batchRoutes.getTickerFinancialsBatch(mapped.valid, { forceRefresh: options.forceRefresh });
+    const listingOfResult = (result: TickerFinancialsBatchResult) => listingOf(result.target, contextFromCachedTarget(result.target));
+    const quoted = answered.flatMap((result) => result.financials?.quote ? [{ quote: result.financials.quote, listing: listingOfResult(result) }] : []);
+    const dated = await this.datedAnswers(quoted, options.datesChangeBasis);
+    let next = 0;
+    const results = answered.map((result) => {
+      if (!result.financials) return result;
+      const quoted = result.financials.quote ? this.withDatedQuote(result.financials, dated[next++]!, listingOfResult(result)) : result.financials;
+      const financials = withFiledTrailingEps(quoted);
+      return financials === result.financials ? result : { ...result, financials };
+    });
     const restored = new Map(results.map((result) => {
       const target = mapped.original(result.target);
       return [target, { ...result, target }] as const;
@@ -228,14 +277,56 @@ export class AssetDataRouter implements DataProvider {
     return targets.map((target) => restored.get(target) ?? { target, financials: null });
   }
 
-  async getTickerFinancials(ticker: string, exchange?: string, context?: MarketDataRequestContext): Promise<TickerFinancials> {
+  async getTickerFinancials(ticker: string, exchange?: string, requestContext?: MarketDataRequestContext): Promise<TickerFinancials> {
+    const { context, datesChangeBasis } = splitDating(requestContext);
     exchange = this.resolvePublicExchange(ticker, exchange, context);
-    return this.financialRoutes.getTickerFinancials(ticker, exchange, context);
+    const financials = await this.financialRoutes.getTickerFinancials(ticker, exchange, context);
+    if (!financials.quote) return withFiledTrailingEps(financials);
+    const listing = listingOf({ symbol: ticker, exchange }, context);
+    const [quote] = await this.datedAnswers([{ quote: financials.quote, listing }], datesChangeBasis);
+    // One trailing EPS and P/E for every view of the listing: the filed quarters', as PEB and GE read them.
+    return withFiledTrailingEps(this.withDatedQuote(financials, quote!, listing));
   }
 
-  async getQuote(ticker: string, exchange?: string, context?: MarketDataRequestContext): Promise<Quote> {
+  async getQuote(ticker: string, exchange?: string, requestContext?: MarketDataRequestContext): Promise<Quote> {
+    const { context, datesChangeBasis } = splitDating(requestContext);
     exchange = this.resolvePublicExchange(ticker, exchange, context);
-    return this.financialRoutes.getQuote(ticker, exchange, context);
+    const quote = await this.financialRoutes.getQuote(ticker, exchange, context);
+    return (await this.datedAnswers([{ quote, listing: listingOf({ symbol: ticker, exchange }, context) }], datesChangeBasis))[0]!;
+  }
+
+  /**
+   * The quotes as this router answers them, their previous closes dated
+   * (PreviousCloseDates). The long-lived app never waits: each is dated by
+   * what was read already, and the reads it lacks start for the copies after
+   * it. A short-lived process starts reads only for a request that prints
+   * what its moves are from (`datesChangeBasis`), and waits for them a few
+   * seconds in all.
+   */
+  private async datedAnswers(
+    entries: Array<{ quote: Quote; listing: DatedCloseListing }>,
+    datesChangeBasis?: boolean,
+    signal?: AbortSignal,
+  ): Promise<Quote[]> {
+    if (this.revalidateInBackground) return entries.map(({ quote, listing }) => this.previousCloseDates.observe(quote, listing));
+    if (datesChangeBasis) await this.previousCloseDates.settle(entries, { waitMs: CHANGE_BASIS_WAIT_MS, signal });
+    return entries.map(({ quote, listing }) => this.previousCloseDates.known(quote, listing));
+  }
+
+  /** The financials with their dated quote, and the contributions it is resolved from dated alike. */
+  private withDatedQuote(financials: TickerFinancials, quote: Quote, listing: DatedCloseListing): TickerFinancials {
+    return quote === financials.quote ? financials : { ...this.knownFinancials(financials, listing), quote };
+  }
+
+  /** The financials dated by what was read already: their quote and the contributions it is resolved from. */
+  private knownFinancials(financials: TickerFinancials, listing: DatedCloseListing): TickerFinancials {
+    const quote = this.previousCloseDates.known(financials.quote, listing);
+    const contributions = financials.quoteContributions;
+    const quoteContributions = contributions && Object.fromEntries(Object.entries(contributions)
+      .map(([key, contribution]) => [key, this.previousCloseDates.known(contribution, listing)])) as QuoteContributionMap;
+    const contributionsChanged = !!contributions && Object.keys(contributions).some((key) => quoteContributions![key] !== contributions[key]);
+    if (quote === financials.quote && !contributionsChanged) return financials;
+    return { ...financials, quote, ...(contributionsChanged ? { quoteContributions } : {}) };
   }
 
   async getQuoteMetadata(ticker: string, exchange?: string, context?: MarketDataRequestContext): Promise<QuoteMetadata | null> {
@@ -569,6 +660,54 @@ export class AssetDataRouter implements DataProvider {
     onQuote: (target: QuoteSubscriptionTarget, quote: Quote) => void,
   ): () => void {
     const mapped = mapListingTargets(targets, (target) => this.resolvePublicExchange(target.symbol, target.exchange, target.context));
-    return this.streamingRoutes.subscribeQuotes(mapped.valid, (target, quote) => onQuote(mapped.original(target), quote));
+    // A read that lands dates the latest copy of a quote for the listing's subscribers.
+    const listeners = mapped.valid.map((target) => {
+      const key = datedCloseListingKey(listingOf(target));
+      const listener = (quote: Quote) => onQuote(mapped.original(target), quote);
+      const set = this.datedQuoteListeners.get(key) ?? new Set();
+      set.add(listener);
+      this.datedQuoteListeners.set(key, set);
+      return { key, listener };
+    });
+    const unsubscribe = this.streamingRoutes.subscribeQuotes(mapped.valid, (target, quote) => {
+      // A tick is dated by what was read already; one not yet read is read for the ticks after it.
+      onQuote(mapped.original(target), this.previousCloseDates.observe(quote, listingOf(target, target.context)));
+    });
+    return () => {
+      unsubscribe();
+      for (const { key, listener } of listeners) {
+        const set = this.datedQuoteListeners.get(key);
+        set?.delete(listener);
+        if (set?.size === 0) this.datedQuoteListeners.delete(key);
+      }
+    };
   }
 }
+
+function listingOf(target: { symbol: string; exchange?: string }, context?: MarketDataRequestContext): DatedCloseListing {
+  return { symbol: target.symbol, exchange: target.exchange ?? "", ...(context ? { context } : {}) };
+}
+
+/** A request's context without the dating flag, which no source reads. */
+function splitDating(requestContext?: MarketDataRequestContext): { context?: MarketDataRequestContext; datesChangeBasis: boolean } {
+  if (!requestContext || !("datesChangeBasis" in requestContext)) return { context: requestContext, datesChangeBasis: false };
+  const { datesChangeBasis, ...context } = requestContext;
+  return { context: Object.keys(context).length ? context : undefined, datesChangeBasis: datesChangeBasis === true };
+}
+
+function withoutDating(options: QuoteBatchOptions): QuoteBatchOptions {
+  if (!("datesChangeBasis" in options)) return options;
+  const { datesChangeBasis: _dates, ...rest } = options;
+  return rest;
+}
+
+/**
+ * The context a listing's daily closes are read with: its broker contract, so
+ * the chart's copy of them is shared, and nothing about the quote request.
+ */
+function listingHistoryContext(context?: MarketDataRequestContext): MarketDataRequestContext | undefined {
+  if (!context) return undefined;
+  const { brokerId, brokerInstanceId, instrument } = context;
+  const history = { ...(brokerId ? { brokerId } : {}), ...(brokerInstanceId ? { brokerInstanceId } : {}), ...(instrument ? { instrument } : {}) };
+  return Object.keys(history).length ? history : undefined;
+}

package/src/sources/provider-router/search.ts

@@ -5,6 +5,7 @@ import type { BrokerCandidate } from "./brokers";
 import { isProviderBusy, ProviderBusyError, SEARCH_BUSY_MESSAGE, shouldLogProviderError } from "../provider-errors";
 import { searchInstrumentKey } from "../../tickers/search/identity";
 import { OperationTimeoutError, settleWithin, withDeadline } from "../../utils/async-deadline";
+import { isNetworkFailure } from "../../utils/network-failure";
 
 const SEARCH_CACHE_TTL_MS = 30_000;
 const SEARCH_CACHE_MAX_ENTRIES = 100;
@@ -142,6 +143,9 @@ export class ProviderRouterSearchRoutes {
    * A search nothing answered because a provider was busy (rate limited,
    * overloaded, out of time) rejects with a `ProviderBusyError` instead of
    * reading as an empty one, and is not cached, so asking again asks again.
+   * One nothing answered because the data service could not be reached
+   * (offline, a refused or hung connection) rejects with that failure: it is
+   * no answer, not a search that found nothing.
    */
   private fetchSearchResults(
     query: string,
@@ -172,6 +176,7 @@ export class ProviderRouterSearchRoutes {
     });
     let answered = false;
     let busy = false;
+    let unreachable: unknown = null;
 
     const record = (items: InstrumentSearchResult[] | null) => {
       if (!items?.length) return;
@@ -204,8 +209,10 @@ export class ProviderRouterSearchRoutes {
         record(await withDeadline(provider.search(query, context), timeoutMs, `${provider.id} search timed out`));
       } catch (error) {
         const timedOut = error instanceof OperationTimeoutError;
-        // A keystroke gives up on a slow source by design and asks again on the next one; only a full wait is busy.
-        if (isProviderBusy(error) || (timedOut && !context?.interactive)) {
+        if (isNetworkFailure(error)) {
+          unreachable ??= error;
+        } else if (isProviderBusy(error) || (timedOut && !context?.interactive)) {
+          // A keystroke gives up on a slow source by design and asks again on the next one; only a full wait is busy.
           busy = true;
         } else if (!timedOut && shouldLogProviderError(error)) {
           this.deps.logProviderError(`${provider.id} failed: ${error}`);
@@ -231,6 +238,10 @@ export class ProviderRouterSearchRoutes {
     })().then(() => {
       if (answered) return;
       answered = true;
+      if (unreachable) {
+        rejectFirst(unreachable);
+        return;
+      }
       if (busy) {
         rejectFirst(new ProviderBusyError(SEARCH_BUSY_MESSAGE));
         return;

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

@@ -495,6 +495,7 @@ export function AppProvider({
     paneState: currentState.paneState,
     focusedPaneId: currentState.focusedPaneId,
     statusBarVisible: currentState.statusBarVisible,
+    brokerSyncErrors: currentState.brokerSyncErrors,
   }), []);
 
   const serializeDesktopSnapshot = useCallback((snapshot: DesktopSharedStateSnapshot): string => JSON.stringify({
@@ -502,6 +503,7 @@ export function AppProvider({
     paneState: snapshot.paneState,
     focusedPaneId: snapshot.focusedPaneId,
     statusBarVisible: snapshot.statusBarVisible,
+    brokerSyncErrors: snapshot.brokerSyncErrors ?? {},
   }), []);
 
   const serializePaneState = useCallback((paneState: PaneRuntimeState | undefined): string => JSON.stringify(paneState ?? {}), []);
@@ -594,6 +596,7 @@ export function AppProvider({
     state.focusedPaneId,
     state.paneState,
     state.statusBarVisible,
+    state.brokerSyncErrors,
   ]);
 
   useEffect(() => {

package/src/state/ticker-cleanup.ts

@@ -0,0 +1,50 @@
+import type { AppTickerRepositoryPort } from "../core/app-service-ports";
+import { hasPendingTickerWrites, settleTickerWrites, tickerWriteRevision } from "../data/ticker-writes";
+import type { TickerRecord } from "../types/ticker";
+
+/**
+ * Persist cleanup before publishing it, retrying against edits acknowledged in between.
+ * Return the cleaned map so callers can recheck it after their config save.
+ */
+export async function persistTickerCleanup({
+  tickerRepository,
+  getTickers,
+  transform,
+  publish,
+  isCurrent = () => true,
+}: {
+  tickerRepository: AppTickerRepositoryPort;
+  getTickers: () => ReadonlyMap<string, TickerRecord>;
+  transform: (ticker: TickerRecord) => TickerRecord | null;
+  publish: (symbol: string, ticker: TickerRecord | null) => void;
+  isCurrent?: () => boolean;
+}): Promise<ReadonlyMap<string, TickerRecord> | null> {
+  for (;;) {
+    do {
+      await settleTickerWrites(tickerRepository);
+    } while (hasPendingTickerWrites(tickerRepository));
+    if (!isCurrent()) return null;
+    const before = getTickers();
+    let wrote = false;
+    for (const symbol of before.keys()) {
+      do {
+        await settleTickerWrites(tickerRepository);
+      } while (hasPendingTickerWrites(tickerRepository));
+      if (!isCurrent()) return null;
+      const source = getTickers().get(symbol);
+      if (!source) continue;
+      const next = transform(source);
+      if (next === source) continue;
+      wrote = true;
+      const save = next ? tickerRepository.saveTicker(next) : tickerRepository.deleteTicker(symbol);
+      const revision = tickerWriteRevision(tickerRepository, symbol);
+      await save;
+      if (!isCurrent()) return null;
+      // An edit can start its save before publishing state, especially over RPC.
+      if (tickerWriteRevision(tickerRepository, symbol) !== revision || getTickers().get(symbol) !== source) continue;
+      publish(symbol, next);
+    }
+    // Include rows created or recreated while earlier rows were being saved.
+    if (!wrote && getTickers() === before) return before;
+  }
+}

package/src/sync/auth-transition.ts

@@ -1,22 +1,32 @@
 export interface CloudSessionLifecycle {
-  isVerified(): boolean;
+  getCurrentUser(): { id: string } | null;
+  isSignedIn(): boolean;
+  getVerifiedSessionIdentity(): object | null;
   subscribeCurrentUser(listener: () => void): () => void;
 }
 
-/**
- * Runs exactly when a signed-in desktop session becomes verified. It deliberately
- * ignores ordinary account and entitlement refreshes so they cannot re-run the
- * initial sync pull and push.
- */
+/** Starts a first merge for a newly verified account, ignoring ordinary user and entitlement refreshes. */
 export function subscribeToCloudVerification(
   session: CloudSessionLifecycle,
   onVerified: () => void,
+  onAccountChange: (accountId: string) => void,
+  onSuspended?: () => void,
 ): () => void {
-  let wasVerified = session.isVerified();
+  let accountId = session.getCurrentUser()?.id ?? null;
+  let wasVerified = session.getVerifiedSessionIdentity() !== null;
   return session.subscribeCurrentUser(() => {
-    const isVerified = session.isVerified();
-    const becameVerified = !wasVerified && isVerified;
+    const isVerified = session.getVerifiedSessionIdentity() !== null;
+    const nextAccountId = isVerified ? session.getCurrentUser()?.id ?? null : null;
+    const accountChanged = nextAccountId !== null && nextAccountId !== accountId;
+    const becameVerified = isVerified && (!wasVerified || accountChanged);
+    const becameSuspended = wasVerified && !isVerified;
+    const resetAccount = accountChanged && accountId !== null;
+    // Sign-out and failed validation retire pending work, but keep the last
+    // account's merge history until a different account is confirmed.
+    if (nextAccountId !== null) accountId = nextAccountId;
     wasVerified = isVerified;
+    if (becameSuspended) onSuspended?.();
+    if (resetAccount) onAccountChange(nextAccountId!);
     if (becameVerified) onVerified();
   });
 }

package/src/sync/baseline.ts

@@ -4,16 +4,17 @@ import type { SyncBaselineStore } from "./types";
 const BASELINE_PLUGIN_ID = "core.sync";
 const BASELINE_KEY = "last-synced-payloads";
 const MEMOS_KEY = "contributor-memos";
+const ACCOUNT_KEY = "account";
 
 /**
  * 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.
+ * Storage failures do not stop sync, but missing merge history can prevent
+ * contributors from recognizing unsynced local edits.
  */
-export function createSyncBaselineStore(pluginState: AppPluginStateStorePort): SyncBaselineStore {
+export function createSyncBaselineStore(pluginState: Pick<AppPluginStateStorePort, "get" | "set">): SyncBaselineStore {
   const load = (key: string) => {
     try {
       return pluginState.get<Record<string, unknown>>(BASELINE_PLUGIN_ID, key)?.value ?? null;
@@ -25,10 +26,15 @@ export function createSyncBaselineStore(pluginState: AppPluginStateStorePort): S
     try {
       pluginState.set(BASELINE_PLUGIN_ID, key, value);
     } catch {
-      // Ignored: a stale baseline or memo only makes the next pull more conservative.
+      // Persistence is best effort; keep the in-memory merge history usable.
     }
   };
   return {
+    loadAccountId: () => {
+      const id = load(ACCOUNT_KEY)?.id;
+      return typeof id === "string" ? id : null;
+    },
+    saveAccountId: (id) => save(ACCOUNT_KEY, { id }),
     load: () => load(BASELINE_KEY),
     save: (payloads) => save(BASELINE_KEY, payloads),
     loadMemos: () => load(MEMOS_KEY),

package/src/sync/controller.ts

@@ -33,11 +33,16 @@ interface SyncRuntime {
   getContributors: () => RegisteredSyncContributor[];
   getTransport: () => RegisteredSyncTransport | null;
   baselineStore?: SyncBaselineStore;
+  /** Retires pending operations when the Cloud session changes; transports decide availability. */
+  getSessionIdentity?: () => object | null;
+  /** Confirmed Cloud account, used to keep persisted merge history scoped across restarts. */
+  getAccountId?: () => string | null;
   /** Sources whose quotes and bars never leave this device (`BrokerAdapter.localMarketData`); none when absent. */
   isLocalMarketData?: LocalMarketDataLookup;
 }
 
-const CLIENT_ID_STORAGE_KEY = "gloomberb.sync.clientId";
+/** Kept in the view's storage; the desktop app also keeps a copy on disk (electrobun/view/view-ids.ts). */
+export const SYNC_CLIENT_ID_STORAGE_KEY = "gloomberb.sync.clientId";
 const PUSH_DEBOUNCE_MS = 2500;
 /** How soon after a change contributors date it, so an edit made just before quitting still is. */
 const OBSERVE_DEBOUNCE_MS = 250;
@@ -56,10 +61,10 @@ function nowIso(): string {
 
 function resolveClientId(): string {
   const storage = globalThis.localStorage;
-  const existing = storage?.getItem(CLIENT_ID_STORAGE_KEY);
+  const existing = storage?.getItem(SYNC_CLIENT_ID_STORAGE_KEY);
   if (existing) return existing;
   const id = `client_${crypto.randomUUID()}`;
-  storage?.setItem(CLIENT_ID_STORAGE_KEY, id);
+  storage?.setItem(SYNC_CLIENT_ID_STORAGE_KEY, id);
   return id;
 }
 
@@ -88,7 +93,9 @@ export class CloudSyncController {
   private memosLoaded = false;
   private inFlight: Promise<void> | null = null;
   private syncQueued = false;
+  private generation = 0;
   private clientId: string | null = null;
+  private accountId: string | null = null;
   private lastSignature: string | null = null;
   /**
    * The content signature of the cloud's copy, with the revision and the
@@ -146,6 +153,7 @@ export class CloudSyncController {
     if (this.runtime !== runtime) {
       this.resetOperations();
       this.runtime = runtime;
+      this.accountId = runtime.baselineStore?.loadAccountId?.() ?? null;
       this.updateAvailability();
     }
     return () => this.clearRuntime(runtime);
@@ -158,6 +166,31 @@ export class CloudSyncController {
     this.setStatus({ phase: "disabled", transportId: null, error: null });
   }
 
+  /** Retires pending session work without losing unsynced edits for the same account. */
+  retireSession(): void {
+    this.generation += 1;
+    if (this.pushTimer) clearTimeout(this.pushTimer);
+    this.pushTimer = null;
+    this.inFlight = null;
+    this.syncQueued = false;
+    this.updateAvailability();
+  }
+
+  /** Account revisions, merge baselines and edit provenance never carry into another account. */
+  resetAccount(accountId?: string): void {
+    this.resetOperations();
+    this.accountId = accountId ?? null;
+    this.baseline = {};
+    this.baselineLoaded = true;
+    this.memos = {};
+    this.memosLoaded = true;
+    this.runtime?.baselineStore?.save({});
+    this.runtime?.baselineStore?.saveMemos?.({});
+    if (accountId) this.runtime?.baselineStore?.saveAccountId?.(accountId);
+    this.setStatus({ phase: "idle", transportId: null, lastSyncAt: null, lastPullAt: null, revision: null, error: null });
+    this.updateAvailability();
+  }
+
   subscribe(listener: () => void): () => void {
     this.listeners.add(listener);
     return () => this.listeners.delete(listener);
@@ -206,6 +239,17 @@ export class CloudSyncController {
   private async syncOnce(options: { reason?: string; force?: boolean }): Promise<void> {
     const runtime = this.runtime;
     if (!runtime) return;
+    const accountId = runtime.getAccountId?.();
+    if (accountId && accountId !== this.accountId) {
+      if (this.accountId !== null) this.resetAccount(accountId);
+      else {
+        // Legacy stores have no owner; retain their offline edits on first validation.
+        this.accountId = accountId;
+        runtime.baselineStore?.saveAccountId?.(accountId);
+      }
+    }
+    const generation = this.generation;
+    const sessionIdentity = runtime.getSessionIdentity?.();
     this.observe(runtime);
     const registration = runtime.getTransport();
     if (!registration?.transport.isAvailable()) {
@@ -222,11 +266,11 @@ export class CloudSyncController {
       // 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.
-      const pulled = await this.runPull(runtime, transport);
-      if (!pulled || !this.isCurrent(runtime, transport)) return;
+      const pulled = await this.runPull(runtime, transport, generation, sessionIdentity);
+      if (!pulled || !this.isCurrent(runtime, transport, generation, sessionIdentity)) return;
 
-      const snapshot = await this.assembleSnapshot(runtime);
-      if (!this.isCurrent(runtime, transport)) return;
+      const snapshot = await this.assembleSnapshot(runtime, generation, sessionIdentity);
+      if (!snapshot || !this.isCurrent(runtime, transport, generation, sessionIdentity)) return;
       const signature = snapshotContentSignature(snapshot);
       if (!options.force && signature === this.lastSignature) return;
       if (!options.force && signature === pulled.signature) {
@@ -242,7 +286,7 @@ export class CloudSyncController {
         // The revision this snapshot was merged with. The cloud refuses the
         // write if another device wrote since, instead of losing that write.
         const result = await transport.pushSnapshot(snapshot, { baseRevision: pulled.revision });
-        if (!this.isCurrent(runtime, transport)) return;
+        if (!this.isCurrent(runtime, transport, generation, sessionIdentity)) return;
         this.lastSignature = signature;
         this.appliedRevision = result.revision;
         this.saveBaseline(runtime, snapshot);
@@ -255,10 +299,10 @@ export class CloudSyncController {
         });
         return;
       } catch (error) {
-        if (!this.isCurrent(runtime, transport)) return;
+        if (!this.isCurrent(runtime, transport, generation, sessionIdentity)) return;
         if (error instanceof SyncRevisionConflictError && attempt < MAX_CONFLICT_RETRIES) {
           // Pull whatever the other device wrote, even an older revision than
-          // this process last saw (an account switch, a restored snapshot).
+          // this process last saw, such as a restored snapshot.
           this.appliedRevision = null;
           continue;
         }
@@ -272,18 +316,18 @@ export class CloudSyncController {
     }
   }
 
-  private async runPull(runtime: SyncRuntime, transport: SyncTransport): Promise<PullResult | null> {
+  private async runPull(runtime: SyncRuntime, transport: SyncTransport, generation: number, sessionIdentity: object | null | undefined): Promise<PullResult | null> {
     const baselineState = runtime.getState();
     this.setStatus({ phase: "syncing", transportId: transport.id, error: null });
     try {
       const response = await transport.pullSnapshot();
-      if (!this.isCurrent(runtime, transport)) return null;
+      if (!this.isCurrent(runtime, transport, generation, sessionIdentity)) return null;
 
       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 null;
+          if (!this.isCurrent(runtime, transport, generation, sessionIdentity)) return null;
           const contributorPayload = response.snapshot.contributors[entry.contributor.id];
           if (!contributorPayload || !entry.contributor.apply) continue;
           await entry.contributor.apply(contributorPayload.payload, {
@@ -292,16 +336,17 @@ export class CloudSyncController {
             baselinePayload: this.loadBaseline(runtime)?.[entry.contributor.id] ?? null,
             state: runtime.getState(),
             getState: runtime.getState,
-            isCurrent: () => this.isCurrent(runtime, transport),
+            isCurrent: () => this.isCurrent(runtime, transport, generation, sessionIdentity),
             dispatch: runtime.dispatch,
             tickerRepository: runtime.tickerRepository,
             memo: this.memoFor(runtime, entry.contributor.id),
           });
+          if (!this.isCurrent(runtime, transport, generation, sessionIdentity)) return null;
         }
         if (response.revision != null) this.appliedRevision = response.revision;
       }
 
-      if (!this.isCurrent(runtime, transport)) return null;
+      if (!this.isCurrent(runtime, transport, generation, sessionIdentity)) return null;
       this.setStatus({
         phase: response.snapshot ? "synced" : "idle",
         transportId: transport.id,
@@ -315,7 +360,7 @@ export class CloudSyncController {
         signature: response.snapshot ? this.pulledSignature(transport, response.revision, response.snapshot) : null,
       };
     } catch (error) {
-      if (!this.isCurrent(runtime, transport)) return null;
+      if (!this.isCurrent(runtime, transport, generation, sessionIdentity)) return null;
       this.setStatus({
         phase: "error",
         transportId: transport.id,
@@ -348,7 +393,7 @@ export class CloudSyncController {
     }
   }
 
-  private async assembleSnapshot(runtime: SyncRuntime): Promise<SyncSnapshot> {
+  private async assembleSnapshot(runtime: SyncRuntime, generation: number, sessionIdentity: object | null | undefined): Promise<SyncSnapshot | null> {
     const contributors = runtime.getContributors();
     const createdAt = nowIso();
     // The snapshot replaces the stored one wholesale, so data owned by a
@@ -356,6 +401,7 @@ export class CloudSyncController {
     // carried over instead of being deleted for every other device.
     const payloads: SyncSnapshot["contributors"] = { ...this.pulledContributors };
     for (const entry of contributors) {
+      if (this.runtime !== runtime || this.generation !== generation || runtime.getSessionIdentity?.() !== sessionIdentity) return null;
       const payload = await entry.contributor.collect({
         state: runtime.getState(),
         baselinePayload: this.loadBaseline(runtime)?.[entry.contributor.id] ?? null,
@@ -415,9 +461,12 @@ export class CloudSyncController {
   }
 
   private memoFor(runtime: SyncRuntime, contributorId: string) {
+    const generation = this.generation;
+    const sessionIdentity = runtime.getSessionIdentity?.();
     return {
       get: () => this.loadMemos(runtime)[contributorId] ?? null,
       set: (value: unknown) => {
+        if (this.runtime !== runtime || this.generation !== generation || runtime.getSessionIdentity?.() !== sessionIdentity) return;
         const memos = { ...this.loadMemos(runtime), [contributorId]: value };
         this.memos = memos;
         runtime.baselineStore?.saveMemos?.(memos);
@@ -442,8 +491,9 @@ export class CloudSyncController {
     runtime.baselineStore?.save(payloads);
   }
 
-  private isCurrent(runtime: SyncRuntime, transport: SyncTransport): boolean {
-    return this.runtime === runtime && runtime.getTransport()?.transport === transport;
+  private isCurrent(runtime: SyncRuntime, transport: SyncTransport, generation: number, sessionIdentity: object | null | undefined): boolean {
+    return this.generation === generation && this.runtime === runtime && runtime.getTransport()?.transport === transport
+      && runtime.getSessionIdentity?.() === sessionIdentity;
   }
 
   private pulledSignature(transport: SyncTransport, revision: number | null, snapshot: SyncSnapshot): string {
@@ -470,6 +520,7 @@ export class CloudSyncController {
   }
 
   private resetOperations(): void {
+    this.generation += 1;
     if (this.pushTimer) clearTimeout(this.pushTimer);
     this.pushTimer = null;
     if (this.observeTimer) clearTimeout(this.observeTimer);