gloomberb 0.17.2 → 0.17.4

package/src/sync/controller.ts

@@ -5,6 +5,7 @@ import { stableStringify } from "../utils/hash";
 import { VERSION } from "../version";
 import {
   SYNC_SNAPSHOT_SCHEMA_VERSION,
+  SyncRevisionConflictError,
   type RegisteredSyncContributor,
   type RegisteredSyncTransport,
   type SyncBaselineStore,
@@ -35,6 +36,16 @@ interface SyncRuntime {
 
 const 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;
+/** Pushes refused because another device wrote first, each followed by a fresh pull, before giving up until the next sync. */
+const MAX_CONFLICT_RETRIES = 3;
+
+/** What one pull left behind: the stored revision it merged with (0 for none) and that copy's content. */
+interface PullResult {
+  revision: number | null;
+  signature: string | null;
+}
 
 function nowIso(): string {
   return new Date().toISOString();
@@ -49,13 +60,17 @@ function resolveClientId(): string {
   return id;
 }
 
+/**
+ * The content of a snapshot as it reads once stored, so one assembled here
+ * (with fields left undefined) compares equal to the same one pulled back.
+ */
 function snapshotContentSignature(snapshot: SyncSnapshot): string {
-  return stableStringify(Object.fromEntries(
+  return stableStringify(JSON.parse(JSON.stringify(Object.fromEntries(
     Object.entries(snapshot.contributors).map(([id, contributor]) => [
       id,
       { schemaVersion: contributor.schemaVersion, payload: contributor.payload },
     ]),
-  ));
+  ))));
 }
 
 export class CloudSyncController {
@@ -64,6 +79,10 @@ export class CloudSyncController {
   private transports = new Map<string, RegisteredSyncTransport>();
   private listeners = new Set<() => void>();
   private pushTimer: ReturnType<typeof setTimeout> | null = null;
+  private observeTimer: ReturnType<typeof setTimeout> | null = null;
+  private observedSinceStart = false;
+  private memos: Record<string, unknown> | null = null;
+  private memosLoaded = false;
   private inFlight: Promise<void> | null = null;
   private syncQueued = false;
   private clientId: string | null = null;
@@ -141,6 +160,7 @@ export class CloudSyncController {
   schedulePush(reason: string): void {
     const runtime = this.runtime;
     if (!runtime) return;
+    this.scheduleObserve(runtime);
     const registration = runtime.getTransport();
     if (!registration?.transport.isAvailable()) {
       this.setStatus({
@@ -176,6 +196,7 @@ export class CloudSyncController {
   private async syncOnce(options: { reason?: string; force?: boolean }): Promise<void> {
     const runtime = this.runtime;
     if (!runtime) return;
+    this.observe(runtime);
     const registration = runtime.getTransport();
     if (!registration?.transport.isAvailable()) {
       this.setStatus({
@@ -187,53 +208,72 @@ export class CloudSyncController {
     }
     const transport = registration.transport;
 
-    // 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;
+    for (let attempt = 0; ; attempt += 1) {
+      // 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 snapshot = await this.assembleSnapshot(runtime);
-    if (!this.isCurrent(runtime, transport)) return;
-    const signature = snapshotContentSignature(snapshot);
-    if (!options.force && signature === this.lastSignature) return;
-
-    this.setStatus({ phase: "syncing", transportId: transport.id, error: null });
-    try {
-      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,
-        revision: result.revision,
-        lastSyncAt: result.updatedAt,
-        error: null,
-      });
-    } catch (error) {
+      const snapshot = await this.assembleSnapshot(runtime);
       if (!this.isCurrent(runtime, transport)) return;
-      this.setStatus({
-        phase: "error",
-        transportId: transport.id,
-        error: error instanceof Error ? error.message : String(error),
-      });
+      const signature = snapshotContentSignature(snapshot);
+      if (!options.force && signature === this.lastSignature) return;
+      if (!options.force && signature === pulled.signature) {
+        // The cloud already holds exactly this: pushing it back would only
+        // bump the revision under another device's next push.
+        this.lastSignature = signature;
+        this.saveBaseline(runtime, snapshot);
+        return;
+      }
+
+      this.setStatus({ phase: "syncing", transportId: transport.id, error: null });
+      try {
+        // 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;
+        this.lastSignature = signature;
+        this.appliedRevision = result.revision;
+        this.saveBaseline(runtime, snapshot);
+        this.setStatus({
+          phase: "synced",
+          transportId: transport.id,
+          revision: result.revision,
+          lastSyncAt: result.updatedAt,
+          error: null,
+        });
+        return;
+      } catch (error) {
+        if (!this.isCurrent(runtime, transport)) 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.appliedRevision = null;
+          continue;
+        }
+        this.setStatus({
+          phase: "error",
+          transportId: transport.id,
+          error: error instanceof Error ? error.message : String(error),
+        });
+        return;
+      }
     }
   }
 
-  private async runPull(runtime: SyncRuntime, transport: SyncTransport): Promise<boolean> {
+  private async runPull(runtime: SyncRuntime, transport: SyncTransport): 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 false;
+      if (!this.isCurrent(runtime, transport)) 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 false;
+          if (!this.isCurrent(runtime, transport)) return null;
           const contributorPayload = response.snapshot.contributors[entry.contributor.id];
           if (!contributorPayload || !entry.contributor.apply) continue;
           await entry.contributor.apply(contributorPayload.payload, {
@@ -245,12 +285,13 @@ export class CloudSyncController {
             isCurrent: () => this.isCurrent(runtime, transport),
             dispatch: runtime.dispatch,
             tickerRepository: runtime.tickerRepository,
+            memo: this.memoFor(runtime, entry.contributor.id),
           });
         }
         if (response.revision != null) this.appliedRevision = response.revision;
       }
 
-      if (!this.isCurrent(runtime, transport)) return false;
+      if (!this.isCurrent(runtime, transport)) return null;
       this.setStatus({
         phase: response.snapshot ? "synced" : "idle",
         transportId: transport.id,
@@ -259,15 +300,18 @@ export class CloudSyncController {
         lastSyncAt: response.updatedAt ?? this.status.lastSyncAt,
         error: null,
       });
-      return true;
+      return {
+        revision: response.snapshot ? response.revision : 0,
+        signature: response.snapshot ? snapshotContentSignature(response.snapshot) : null,
+      };
     } catch (error) {
-      if (!this.isCurrent(runtime, transport)) return false;
+      if (!this.isCurrent(runtime, transport)) return null;
       this.setStatus({
         phase: "error",
         transportId: transport.id,
         error: error instanceof Error ? error.message : String(error),
       });
-      return false;
+      return null;
     }
   }
 
@@ -302,7 +346,11 @@ export class CloudSyncController {
     // 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() });
+      const payload = await entry.contributor.collect({
+        state: runtime.getState(),
+        baselinePayload: this.loadBaseline(runtime)?.[entry.contributor.id] ?? null,
+        memo: this.memoFor(runtime, entry.contributor.id),
+      });
       payloads[entry.contributor.id] = {
         schemaVersion: entry.contributor.schemaVersion,
         updatedAt: createdAt,
@@ -327,6 +375,53 @@ export class CloudSyncController {
     return this.baseline;
   }
 
+  private scheduleObserve(runtime: SyncRuntime): void {
+    if (this.observeTimer) clearTimeout(this.observeTimer);
+    this.observeTimer = setTimeout(() => {
+      this.observeTimer = null;
+      if (this.runtime === runtime) this.observe(runtime);
+    }, OBSERVE_DEBOUNCE_MS);
+  }
+
+  /** Lets contributors date local edits as they happen, whether or not the cloud is reachable. */
+  private observe(runtime: SyncRuntime): void {
+    const launch = !this.observedSinceStart;
+    this.observedSinceStart = true;
+    for (const entry of runtime.getContributors()) {
+      if (!entry.contributor.observe) continue;
+      try {
+        entry.contributor.observe({
+          state: runtime.getState(),
+          baselinePayload: this.loadBaseline(runtime)?.[entry.contributor.id] ?? null,
+          memo: this.memoFor(runtime, entry.contributor.id),
+          launch,
+        });
+      } catch {
+        // A contributor that cannot date an edit leaves it undated, which only
+        // makes it lose a conflict it might have won.
+      }
+    }
+  }
+
+  private memoFor(runtime: SyncRuntime, contributorId: string) {
+    return {
+      get: () => this.loadMemos(runtime)[contributorId] ?? null,
+      set: (value: unknown) => {
+        const memos = { ...this.loadMemos(runtime), [contributorId]: value };
+        this.memos = memos;
+        runtime.baselineStore?.saveMemos?.(memos);
+      },
+    };
+  }
+
+  private loadMemos(runtime: SyncRuntime): Record<string, unknown> {
+    if (!this.memosLoaded) {
+      this.memosLoaded = true;
+      this.memos = runtime.baselineStore?.loadMemos?.() ?? null;
+    }
+    return this.memos ?? {};
+  }
+
   private saveBaseline(runtime: SyncRuntime, snapshot: SyncSnapshot): void {
     const payloads = Object.fromEntries(
       Object.entries(snapshot.contributors).map(([id, contributor]) => [id, contributor.payload]),
@@ -353,6 +448,11 @@ export class CloudSyncController {
   private resetOperations(): void {
     if (this.pushTimer) clearTimeout(this.pushTimer);
     this.pushTimer = null;
+    if (this.observeTimer) clearTimeout(this.observeTimer);
+    this.observeTimer = null;
+    this.observedSinceStart = false;
+    this.memos = null;
+    this.memosLoaded = false;
     this.inFlight = null;
     this.syncQueued = false;
     this.lastSignature = null;

package/src/sync/core-contributors.ts

@@ -1,6 +1,6 @@
 import { scheduleConfigSave } from "../state/config-save-scheduler";
 import { debugLog } from "../utils/debug-log";
-import { stableStringify } from "../utils/hash";
+import { fnv1aHex, stableStringify } from "../utils/hash";
 import type { AppConfig, BrokerInstanceConfig, SavedLayout } from "../types/config";
 import type { PricePoint, TickerFinancials } from "../types/financials";
 import type { Portfolio, TickerMetadata, TickerPosition, TickerRecord, Watchlist } from "../types/ticker";
@@ -40,6 +40,9 @@ import { withoutMissingWatchlists } from "../plugins/builtin/portfolio-list/muta
  */
 const SESSION_SAVED_LAYOUT_KEYS = ["paneState", "focusedPaneId", "activePanel"] as const;
 
+/** Together these are the workspace: the tabs, the one showing, and its arrangement. */
+const LAYOUT_SYNC_KEYS = ["layout", "layouts", "activeLayoutIndex"] as const;
+
 const SENSITIVE_KEY_PATTERN = /(token|secret|password|credential|private|api[_-]?key|access[_-]?key|refresh[_-]?key|session|cookie|dataDir|path|directory|localPath)/i;
 
 const log = debugLog.createLogger("sync");
@@ -351,6 +354,14 @@ function sanitizeTickerMetadata(metadata: TickerMetadata, financials?: TickerFin
   };
 }
 
+function collectLayoutPayload(config: Pick<AppConfig, typeof LAYOUT_SYNC_KEYS[number]>) {
+  return sanitizeUnknown({
+    layout: config.layout,
+    layouts: config.layouts.map(withoutSessionLayoutState),
+    activeLayoutIndex: config.activeLayoutIndex,
+  }) as Record<string, unknown>;
+}
+
 function collectCoreConfigPayload(config: AppConfig) {
   return sanitizeUnknown({
     configVersion: config.configVersion,
@@ -358,9 +369,7 @@ function collectCoreConfigPayload(config: AppConfig) {
     refreshIntervalMinutes: config.refreshIntervalMinutes,
     portfolios: config.portfolios.map(sanitizePortfolio),
     watchlists: config.watchlists.map(sanitizeWatchlist),
-    layout: config.layout,
-    layouts: config.layouts.map(withoutSessionLayoutState),
-    activeLayoutIndex: config.activeLayoutIndex,
+    ...collectLayoutPayload(config),
     brokerInstances: config.brokerInstances.map(sanitizeBrokerInstance),
     // This build merges profiles one by one before it pushes, so a profile
     // missing from its list was removed, not one it never pulled.
@@ -622,11 +631,204 @@ function withLocalSessionLayoutState(
   });
 }
 
+/**
+ * A layout as the user arranged it. Stacking order follows whichever floating
+ * pane was focused last, and a pane in its own desktop window is one a
+ * terminal draws inline as a floating pane, so neither tells two copies apart.
+ */
+function arrangedLayout(layout: unknown): unknown {
+  if (!isRecord(layout)) return layout;
+  const windows = [
+    ...(Array.isArray(layout.floating) ? layout.floating : []),
+    ...(Array.isArray(layout.detached) ? layout.detached : []),
+  ].map((entry) => {
+    if (!isRecord(entry)) return entry;
+    const { zIndex: _zIndex, ...rest } = entry;
+    return rest;
+  });
+  const instanceId = (entry: unknown) => (isRecord(entry) ? String(entry.instanceId) : "");
+  windows.sort((left, right) => instanceId(left).localeCompare(instanceId(right)));
+  return { ...layout, floating: windows, detached: [] };
+}
+
+// Pulled and last synced payloads are compared on every sync and never change.
+const layoutIntents = new WeakMap<object, string | null>();
+
+/**
+ * A key for the workspace a payload describes, equal for two copies that only
+ * differ in what reflects one device, so a real edit can be told from them.
+ * Null when the payload holds no complete workspace.
+ */
+function layoutIntent(payload: unknown): string | null {
+  if (!isRecord(payload) || !Array.isArray(payload.layouts)) return null;
+  if (!LAYOUT_SYNC_KEYS.every((key) => key in payload)) return null;
+  const cached = layoutIntents.get(payload);
+  if (cached !== undefined) return cached;
+  const intent = stableStringify(sanitizeUnknown({
+    layout: arrangedLayout(payload.layout),
+    layouts: payload.layouts.map((entry) => (
+      isRecord(entry)
+        ? { ...withoutSessionLayoutState(entry as unknown as SavedLayout), layout: arrangedLayout(entry.layout) }
+        : entry
+    )),
+    activeLayoutIndex: payload.activeLayoutIndex,
+  }));
+  const key = `${fnv1aHex(intent)}:${intent.length}`;
+  layoutIntents.set(payload, key);
+  return key;
+}
+
+/** The workspace keys of a payload, with the time its layout was last edited when it says. */
+function pickLayoutPayload(payload: Record<string, unknown>): Record<string, unknown> {
+  const picked = Object.fromEntries([...LAYOUT_SYNC_KEYS, "layoutEditedAt"].flatMap((key) => (
+    key in payload ? [[key, payload[key]]] : []
+  )));
+  // An older build still sent the view it was looking at with each layout.
+  if (Array.isArray(picked.layouts)) {
+    picked.layouts = picked.layouts.map((entry) => (isRecord(entry) ? withoutSessionLayoutState(entry as unknown as SavedLayout) : entry));
+  }
+  return picked;
+}
+
+/**
+ * What this device remembers about its workspace between syncs: when it last
+ * edited it (null when that happened while the app was closed, so the time is
+ * unknown), or, when it took the workspace from the cloud, that copy as synced.
+ */
+interface LayoutMemo {
+  intent: string;
+  editedAt: number | null;
+  synced?: Record<string, unknown>;
+}
+
+function readLayoutMemo(value: unknown): LayoutMemo | null {
+  if (!isRecord(value) || typeof value.intent !== "string") return null;
+  return {
+    intent: value.intent,
+    editedAt: typeof value.editedAt === "number" && Number.isFinite(value.editedAt) ? value.editedAt : null,
+    ...(isRecord(value.synced) ? { synced: value.synced } : {}),
+  };
+}
+
+/**
+ * When a pulled workspace was last edited. A copy from a build that did not
+ * date edits counts as edited when it was pushed, which is never earlier.
+ */
+function pulledLayoutEditedAt(payload: Record<string, unknown>, pushedAt: string | undefined): number {
+  if (typeof payload.layoutEditedAt === "number" && Number.isFinite(payload.layoutEditedAt)) return payload.layoutEditedAt;
+  const pushed = pushedAt ? Date.parse(pushedAt) : Number.NaN;
+  return Number.isFinite(pushed) ? pushed : Number.POSITIVE_INFINITY;
+}
+
+/**
+ * Whether a pulled workspace replaces this device's, three ways: against the
+ * copy this device last synced, the one it had when the pull started, and the
+ * pulled one. Only a real edit here keeps the local copy; the pane state,
+ * focus and window stacking that change on every launch never do.
+ */
+function shouldAdoptPulledLayout({
+  local,
+  atPullStart,
+  lastSynced,
+  pulled,
+  memo,
+  pulledEditedAt,
+}: {
+  local: string | null;
+  atPullStart: string | null;
+  lastSynced: string | null;
+  pulled: string | null;
+  memo: LayoutMemo | null;
+  pulledEditedAt: number;
+}): boolean {
+  if (pulled === null || pulled === local) return false;
+  // Edited while the pull was in flight: newer than anything it carries.
+  if (local !== atPullStart) return false;
+  const takenFromCloud = !!memo?.synced && memo.intent === local;
+  const editedHere = lastSynced !== null && local !== lastSynced && !takenFromCloud;
+  if (!editedHere) return true;
+  // The cloud still holds what this device last synced: only this side changed.
+  if (pulled === lastSynced) return false;
+  // Both sides changed since: the later edit wins, and an undated local one loses.
+  const localEditedAt = memo?.intent === local ? memo.editedAt : null;
+  return localEditedAt === null || localEditedAt <= pulledEditedAt;
+}
+
+/**
+ * The workspace as the cloud already has it unless this device really edited
+ * it, so what only reflects this device never replaces another device's copy,
+ * and a real edit goes out dated.
+ */
+function withLayoutProvenance(
+  payload: Record<string, unknown>,
+  lastSyncedPayload: unknown,
+  memoValue: unknown,
+): Record<string, unknown> {
+  const local = layoutIntent(payload);
+  if (local === null) return payload;
+  const memo = readLayoutMemo(memoValue);
+  if (memo?.synced && memo.intent === local) return { ...payload, ...memo.synced };
+  if (isRecord(lastSyncedPayload) && layoutIntent(lastSyncedPayload) === local) {
+    return { ...payload, ...pickLayoutPayload(lastSyncedPayload) };
+  }
+  return {
+    ...payload,
+    layoutEditedAt: memo?.intent === local && memo.editedAt !== null ? memo.editedAt : Date.now(),
+  };
+}
+
+/**
+ * Dates a workspace edit when it happens, online or not, so a later conflict
+ * with another device's edit goes to the newer one.
+ */
+function noteLayoutEdit(config: AppConfig, lastSyncedPayload: unknown, memoValue: unknown, launch: boolean): LayoutMemo | null {
+  const lastSynced = layoutIntent(lastSyncedPayload);
+  if (lastSynced === null) return null;
+  const local = layoutIntent(collectLayoutPayload(config));
+  if (local === null || local === lastSynced) return null;
+  if (readLayoutMemo(memoValue)?.intent === local) return null;
+  // Seen at launch, it was made while the app was closed or just before it
+  // quit; when is unknown, so it gives way to a dated edit elsewhere.
+  return { intent: local, editedAt: launch ? null : Date.now() };
+}
+
+/**
+ * Once this device holds the cloud's workspace, by taking it or because the
+ * two already matched, it remembers that copy as synced, keyed by how it
+ * looks here once applied. The next push then sends the cloud's own copy back
+ * rather than this device's rendering of it.
+ */
+function rememberCloudLayout(
+  payload: Record<string, unknown>,
+  pushedAt: string | undefined,
+  applied: AppConfig,
+  memo: { get(): unknown; set(value: unknown): void },
+  adopted: boolean,
+): void {
+  const local = layoutIntent(collectLayoutPayload(applied));
+  if (local === null || (!adopted && local !== layoutIntent(payload))) return;
+  const current = readLayoutMemo(memo.get());
+  if (!adopted && current?.synced && current.intent === local) return;
+  const editedAt = pulledLayoutEditedAt(payload, pushedAt);
+  memo.set({
+    intent: local,
+    editedAt: Number.isFinite(editedAt) ? editedAt : null,
+    synced: pickLayoutPayload(payload),
+  } satisfies LayoutMemo);
+}
+
+interface LayoutMergeContext {
+  memo?: unknown;
+  /** When the pulled copy was pushed, for one from a build that did not date layout edits. */
+  pushedAt?: string;
+}
+
 function mergeConfigPayload(
   config: AppConfig,
   payload: unknown,
   baselineConfig: AppConfig = config,
   lastSyncedPayload?: unknown,
+  layoutContext: LayoutMergeContext = {},
 ): AppConfig | null {
   if (!isRecord(payload)) return null;
   const next: AppConfig = { ...config };
@@ -634,11 +836,9 @@ function mergeConfigPayload(
   // was in flight; lastSyncedPayload catches edits made while the app was not
   // running at all (CLI writes, offline edits), which otherwise look pristine.
   const lastSynced = isRecord(lastSyncedPayload) ? lastSyncedPayload : null;
-  const localPayload = lastSynced
-    ? collectCoreConfigPayload(config) as Record<string, unknown>
-    : null;
+  const localPayload = collectCoreConfigPayload(config) as Record<string, unknown>;
   const matchesLastSynced = (key: string) => (
-    !lastSynced || valuesEqual(localPayload?.[key], lastSynced[key])
+    !lastSynced || valuesEqual(localPayload[key], lastSynced[key])
   );
   const canApply = <K extends keyof AppConfig>(key: K) => (
     valuesEqual(config[key], baselineConfig[key]) && matchesLastSynced(key as string)
@@ -689,15 +889,20 @@ function mergeConfigPayload(
     );
   }
 
-  const layoutStateUntouched = config.layout === baselineConfig.layout
-    && config.layouts === baselineConfig.layouts
-    && config.activeLayoutIndex === baselineConfig.activeLayoutIndex
-    && ["layout", "layouts", "activeLayoutIndex"].every(matchesLastSynced);
-  if (
-    layoutStateUntouched
-    && ["layout", "layouts", "activeLayoutIndex"].every((key) => key in payload)
-    && Array.isArray(payload.layouts)
-  ) {
+  // Compared by content, not identity: the active layout mirrors pane state,
+  // so a cursor settling at launch replaced it mid-pull, the pulled workspace
+  // was refused, and the push that followed wrote this device's older one
+  // over it on every other device.
+  const localIntent = layoutIntent(localPayload);
+  const adoptLayout = shouldAdoptPulledLayout({
+    local: localIntent,
+    atPullStart: baselineConfig === config ? localIntent : layoutIntent(collectLayoutPayload(baselineConfig)),
+    lastSynced: layoutIntent(lastSynced),
+    pulled: layoutIntent(payload),
+    memo: readLayoutMemo(layoutContext.memo),
+    pulledEditedAt: pulledLayoutEditedAt(payload, layoutContext.pushedAt),
+  });
+  if (adoptLayout) {
     next.layout = payload.layout as unknown as AppConfig["layout"];
     next.layouts = withLocalSessionLayoutState(payload.layouts as AppConfig["layouts"], config.layouts);
     next.activeLayoutIndex = payload.activeLayoutIndex as number;
@@ -872,24 +1077,43 @@ function tickerChangedSinceLastSync(
   return !valuesEqual(withoutQuote(local), withoutQuote(baseline));
 }
 
+const CORE_CONFIG_CONTRIBUTOR_ID = "core.config";
+
 export const coreConfigSyncContributor: SyncContributor = {
-  id: "core.config",
+  id: CORE_CONFIG_CONTRIBUTOR_ID,
   schemaVersion: 1,
-  collect: ({ state }) => collectCoreConfigPayload(state.config),
-  apply: async (payload, { baselinePayload, baselineState, state, getState, isCurrent, dispatch, tickerRepository }) => {
-    const nextConfig = mergeConfigPayload(state.config, payload, baselineState.config, baselinePayload);
-    if (!nextConfig || valuesEqual(nextConfig, state.config)) return;
-    // Adopting another device's workspace rearranges the screen under the
-    // user, so it is worth a line in the log when a report says "my panes
-    // moved on their own".
-    if (nextConfig.layout !== state.config.layout) {
-      log.info("config.layout.adopted", {
-        panes: nextConfig.layout.instances.length,
-        activeLayoutIndex: nextConfig.activeLayoutIndex,
-      });
+  collect: ({ state, baselinePayload, memo }) => withLayoutProvenance(
+    collectCoreConfigPayload(state.config) as Record<string, unknown>,
+    baselinePayload,
+    memo?.get(),
+  ),
+  observe: ({ state, baselinePayload, memo, launch }) => {
+    const edit = noteLayoutEdit(state.config, baselinePayload, memo.get(), launch);
+    if (edit) memo.set(edit);
+  },
+  apply: async (payload, { snapshot, baselinePayload, baselineState, state, getState, isCurrent, dispatch, tickerRepository, memo }) => {
+    const pushedAt = snapshot?.contributors[CORE_CONFIG_CONTRIBUTOR_ID]?.updatedAt;
+    const nextConfig = mergeConfigPayload(state.config, payload, baselineState.config, baselinePayload, {
+      memo: memo?.get(),
+      pushedAt,
+    });
+    if (!nextConfig) return;
+    const configChanged = !valuesEqual(nextConfig, state.config);
+    if (configChanged) {
+      // Adopting another device's workspace rearranges the screen under the
+      // user, so it is worth a line in the log when a report says "my panes
+      // moved on their own".
+      if (nextConfig.layout !== state.config.layout) {
+        log.info("config.layout.adopted", {
+          panes: nextConfig.layout.instances.length,
+          activeLayoutIndex: nextConfig.activeLayoutIndex,
+        });
+      }
+      dispatch({ type: "SET_CONFIG", config: nextConfig });
+      scheduleConfigSave(nextConfig);
     }
-    dispatch({ type: "SET_CONFIG", config: nextConfig });
-    scheduleConfigSave(nextConfig);
+    if (memo && isRecord(payload)) rememberCloudLayout(payload, pushedAt, getState().config, memo, nextConfig.layouts !== state.config.layouts);
+    if (!configChanged) return;
 
     // A profile removed on another device takes its positions with it here
     // too; kept, this device would push them back and recreate the tickers