diff --git a/docs/reference/settings.md b/docs/reference/settings.md
index dfc9e8e..aaede2c 100644
--- a/docs/reference/settings.md
+++ b/docs/reference/settings.md
@@ -64,6 +64,26 @@ Controls display style:
 - `uiAccentColor`
 - `menuFocusStyle`
 
+## Sync Center
+
+The settings hub includes a preview-first sync center for Codex CLI account sync.
+See [upgrade notes](../upgrade.md) for sync workflow changes.
+
+Before applying sync, it shows:
+
+- target path
+- current source path when available
+- last sync result for this session
+- preview summary (adds, updates, destination-only preserved accounts)
+- destination-only preservation behavior
+- backup and rollback context (`.bak`, `.bak.1`, `.bak.2`, `.wal`)
+
+Validation:
+
+- `npm run typecheck`
+- `npm run build`
+- `npm test`
+
 ---
 
 ## Experimental
diff --git a/lib/accounts.ts b/lib/accounts.ts
index 3eae130..d872e51 100644
--- a/lib/accounts.ts
+++ b/lib/accounts.ts
@@ -22,7 +22,11 @@ import {
 	loadCodexCliState,
 	type CodexCliTokenCacheEntry,
 } from "./codex-cli/state.js";
-import { syncAccountStorageFromCodexCli } from "./codex-cli/sync.js";
+import {
+	commitCodexCliSyncRunFailure,
+	commitPendingCodexCliSyncRun,
+	syncAccountStorageFromCodexCli,
+} from "./codex-cli/sync.js";
 import { setCodexCliActiveSelection } from "./codex-cli/writer.js";
 
 export {
@@ -116,7 +120,9 @@ export class AccountManager {
 		if (synced.changed && sourceOfTruthStorage) {
 			try {
 				await saveAccounts(sourceOfTruthStorage);
+				commitPendingCodexCliSyncRun(synced.pendingRun);
 			} catch (error) {
+				commitCodexCliSyncRunFailure(synced.pendingRun, error);
 				log.debug("Failed to persist Codex CLI source-of-truth sync", {
 					error: String(error),
 				});
diff --git a/lib/codex-cli/sync.ts b/lib/codex-cli/sync.ts
index ba0257d..cb56aea 100644
--- a/lib/codex-cli/sync.ts
+++ b/lib/codex-cli/sync.ts
@@ -1,10 +1,36 @@
+import { promises as fs } from "node:fs";
 import { createLogger } from "../logger.js";
 import { MODEL_FAMILIES, type ModelFamily } from "../prompts/codex.js";
-import { type AccountStorageV3 } from "../storage.js";
-import { incrementCodexCliMetric } from "./observability.js";
+import {
+	type AccountMetadataV3,
+	type AccountStorageV3,
+	findMatchingAccountIndex,
+	getLastAccountsSaveTimestamp,
+	getStoragePath,
+	normalizeEmailKey,
+} from "../storage.js";
+import {
+	incrementCodexCliMetric,
+	makeAccountFingerprint,
+} from "./observability.js";
+import {
+	type CodexCliAccountSnapshot,
+	isCodexCliSyncEnabled,
+	loadCodexCliState,
+} from "./state.js";
+import { getLastCodexCliSelectionWriteTimestamp } from "./writer.js";
 
 const log = createLogger("codex-cli-sync");
 
+function createEmptyStorage(): AccountStorageV3 {
+	return {
+		version: 3,
+		accounts: [],
+		activeIndex: 0,
+		activeIndexByFamily: {},
+	};
+}
+
 function cloneStorage(storage: AccountStorageV3): AccountStorageV3 {
 	return {
 		version: 3,
@@ -16,6 +42,94 @@ function cloneStorage(storage: AccountStorageV3): AccountStorageV3 {
 	};
 }
 
+export function formatRollbackPaths(targetPath: string): string[] {
+	return [
+		`${targetPath}.bak`,
+		`${targetPath}.bak.1`,
+		`${targetPath}.bak.2`,
+		`${targetPath}.wal`,
+	];
+}
+
+export interface CodexCliSyncSummary {
+	sourceAccountCount: number;
+	targetAccountCountBefore: number;
+	targetAccountCountAfter: number;
+	addedAccountCount: number;
+	updatedAccountCount: number;
+	unchangedAccountCount: number;
+	destinationOnlyPreservedCount: number;
+	selectionChanged: boolean;
+}
+
+export interface CodexCliSyncBackupContext {
+	enabled: boolean;
+	targetPath: string;
+	rollbackPaths: string[];
+}
+
+export interface CodexCliSyncPreview {
+	status: "ready" | "noop" | "disabled" | "unavailable" | "error";
+	statusDetail: string;
+	sourcePath: string | null;
+	sourceAccountCount: number | null;
+	targetPath: string;
+	summary: CodexCliSyncSummary;
+	backup: CodexCliSyncBackupContext;
+	lastSync: CodexCliSyncRun | null;
+}
+
+export interface CodexCliSyncRun {
+	outcome: "changed" | "noop" | "disabled" | "unavailable" | "error";
+	runAt: number;
+	sourcePath: string | null;
+	targetPath: string;
+	summary: CodexCliSyncSummary;
+	message?: string;
+}
+
+export interface PendingCodexCliSyncRun {
+	revision: number;
+	run: CodexCliSyncRun;
+}
+
+type UpsertAction = "skipped" | "added" | "updated" | "unchanged";
+
+interface UpsertResult {
+	action: UpsertAction;
+	matchedIndex?: number;
+}
+
+interface ReconcileResult {
+	next: AccountStorageV3;
+	changed: boolean;
+	summary: CodexCliSyncSummary;
+}
+
+let lastCodexCliSyncRun: CodexCliSyncRun | null = null;
+let lastCodexCliSyncRunRevision = 0;
+let nextCodexCliSyncRunRevision = 0;
+
+function createEmptySyncSummary(): CodexCliSyncSummary {
+	return {
+		sourceAccountCount: 0,
+		targetAccountCountBefore: 0,
+		targetAccountCountAfter: 0,
+		addedAccountCount: 0,
+		updatedAccountCount: 0,
+		unchangedAccountCount: 0,
+		destinationOnlyPreservedCount: 0,
+		selectionChanged: false,
+	};
+}
+
+function cloneCodexCliSyncRun(run: CodexCliSyncRun): CodexCliSyncRun {
+	return {
+		...run,
+		summary: { ...run.summary },
+	};
+}
+
 function normalizeIndexCandidate(value: number, fallback: number): number {
 	if (!Number.isFinite(value)) {
 		return Number.isFinite(fallback) ? Math.trunc(fallback) : 0;
@@ -23,6 +137,231 @@ function normalizeIndexCandidate(value: number, fallback: number): number {
 	return Math.trunc(value);
 }
 
+function allocateCodexCliSyncRunRevision(): number {
+	nextCodexCliSyncRunRevision += 1;
+	return nextCodexCliSyncRunRevision;
+}
+
+function publishCodexCliSyncRun(
+	run: CodexCliSyncRun,
+	revision: number,
+): boolean {
+	if (revision <= lastCodexCliSyncRunRevision) {
+		return false;
+	}
+	lastCodexCliSyncRunRevision = revision;
+	lastCodexCliSyncRun = cloneCodexCliSyncRun(run);
+	return true;
+}
+
+function buildSyncRunError(
+	run: CodexCliSyncRun,
+	error: unknown,
+): CodexCliSyncRun {
+	return {
+		...run,
+		outcome: "error",
+		message: error instanceof Error ? error.message : String(error),
+	};
+}
+
+function createSyncRun(
+	run: Omit<CodexCliSyncRun, "runAt">,
+): CodexCliSyncRun {
+	return {
+		...run,
+		runAt: Date.now(),
+	};
+}
+
+export function getLastCodexCliSyncRun(): CodexCliSyncRun | null {
+	return lastCodexCliSyncRun ? cloneCodexCliSyncRun(lastCodexCliSyncRun) : null;
+}
+
+export function commitPendingCodexCliSyncRun(
+	pendingRun: PendingCodexCliSyncRun | null | undefined,
+): void {
+	if (!pendingRun) return;
+	publishCodexCliSyncRun(
+		{
+			...pendingRun.run,
+			runAt: Date.now(),
+		},
+		pendingRun.revision,
+	);
+}
+
+export function commitCodexCliSyncRunFailure(
+	pendingRun: PendingCodexCliSyncRun | null | undefined,
+	error: unknown,
+): void {
+	if (!pendingRun) return;
+	publishCodexCliSyncRun(
+		buildSyncRunError(
+			{
+				...pendingRun.run,
+				runAt: Date.now(),
+			},
+			error,
+		),
+		pendingRun.revision,
+	);
+}
+
+export function __resetLastCodexCliSyncRunForTests(): void {
+	lastCodexCliSyncRun = null;
+	lastCodexCliSyncRunRevision = 0;
+	nextCodexCliSyncRunRevision = 0;
+}
+
+function hasConflictingIdentity(
+	accounts: AccountMetadataV3[],
+	snapshot: CodexCliAccountSnapshot,
+): boolean {
+	const normalizedEmail = normalizeEmailKey(snapshot.email);
+	for (const account of accounts) {
+		if (!account) continue;
+		if (snapshot.accountId && account.accountId === snapshot.accountId) {
+			return true;
+		}
+		if (snapshot.refreshToken && account.refreshToken === snapshot.refreshToken) {
+			return true;
+		}
+		if (normalizedEmail && normalizeEmailKey(account.email) === normalizedEmail) {
+			return true;
+		}
+	}
+	return false;
+}
+
+function toStorageAccount(
+	snapshot: CodexCliAccountSnapshot,
+): AccountMetadataV3 | null {
+	if (!snapshot.refreshToken) return null;
+	const now = Date.now();
+	return {
+		accountId: snapshot.accountId,
+		accountIdSource: snapshot.accountId ? "token" : undefined,
+		email: snapshot.email,
+		refreshToken: snapshot.refreshToken,
+		accessToken: snapshot.accessToken,
+		expiresAt: snapshot.expiresAt,
+		enabled: true,
+		addedAt: now,
+		lastUsed: 0,
+	};
+}
+
+function upsertFromSnapshot(
+	accounts: AccountMetadataV3[],
+	snapshot: CodexCliAccountSnapshot,
+): UpsertResult {
+	const nextAccount = toStorageAccount(snapshot);
+	if (!nextAccount) return { action: "skipped" };
+
+	const targetIndex = findMatchingAccountIndex(accounts, snapshot, {
+		allowUniqueAccountIdFallbackWithoutEmail: true,
+	});
+
+	if (targetIndex === undefined) {
+		if (hasConflictingIdentity(accounts, snapshot)) {
+			return { action: "skipped" };
+		}
+		accounts.push(nextAccount);
+		return { action: "added" };
+	}
+
+	const current = accounts[targetIndex];
+	if (!current) return { action: "skipped" };
+
+	const merged: AccountMetadataV3 = {
+		...current,
+		accountId: snapshot.accountId ?? current.accountId,
+		accountIdSource: snapshot.accountId
+			? (current.accountIdSource ?? "token")
+			: current.accountIdSource,
+		email: snapshot.email ?? current.email,
+		refreshToken: snapshot.refreshToken ?? current.refreshToken,
+		accessToken: snapshot.accessToken ?? current.accessToken,
+		expiresAt: snapshot.expiresAt ?? current.expiresAt,
+	};
+
+	const changed = JSON.stringify(current) !== JSON.stringify(merged);
+	if (changed) {
+		accounts[targetIndex] = merged;
+	}
+	return {
+		action: changed ? "updated" : "unchanged",
+		matchedIndex: targetIndex,
+	};
+}
+
+function resolveActiveIndex(
+	accounts: AccountMetadataV3[],
+	activeAccountId: string | undefined,
+	activeEmail: string | undefined,
+): number | undefined {
+	if (accounts.length === 0) return undefined;
+	if (!activeAccountId && !normalizeEmailKey(activeEmail)) return undefined;
+	return findMatchingAccountIndex(
+		accounts,
+		{
+			accountId: activeAccountId,
+			email: activeEmail,
+			refreshToken: undefined,
+		},
+		{
+			allowUniqueAccountIdFallbackWithoutEmail: true,
+		},
+	);
+}
+
+function applyCodexCliSelection(
+	storage: AccountStorageV3,
+	index: number,
+): void {
+	const previousActiveIndex = normalizeIndexCandidate(storage.activeIndex, 0);
+	storage.activeIndex = index;
+	storage.activeIndexByFamily = storage.activeIndexByFamily ?? {};
+	for (const family of MODEL_FAMILIES) {
+		const raw = storage.activeIndexByFamily[family];
+		if (
+			typeof raw === "number" &&
+			normalizeIndexCandidate(raw, previousActiveIndex) === previousActiveIndex
+		) {
+			storage.activeIndexByFamily[family] = index;
+		}
+	}
+}
+
+async function getPersistedLocalSelectionTimestamp(): Promise<number | null> {
+	try {
+		const stats = await fs.stat(getStoragePath());
+		return Number.isFinite(stats.mtimeMs) ? stats.mtimeMs : 0;
+	} catch (error) {
+		const code = (error as NodeJS.ErrnoException).code;
+		if (code === "ENOENT") {
+			return 0;
+		}
+		return null;
+	}
+}
+
+/**
+ * Normalize and clamp the global and per-family active account indexes to valid ranges.
+ *
+ * Mutates `storage` in-place: ensures `activeIndexByFamily` exists, clamps `activeIndex` to
+ * 0..(accounts.length - 1) (or 0 when there are no accounts), and resolves each family entry
+ * to a valid index within the same bounds.
+ *
+ * Concurrency: callers must synchronize externally when multiple threads/processes may write
+ * the same storage object. Filesystem notes: no platform-specific IO is performed here; when
+ * persisted to disk on Windows consumers should still ensure atomic writes. Token handling:
+ * this function does not read or modify authentication tokens and makes no attempt to redact
+ * sensitive fields.
+ *
+ * @param storage - The account storage object whose indexes will be normalized and clamped
+ */
 function normalizeStoredFamilyIndexes(storage: AccountStorageV3): void {
 	const count = storage.accounts.length;
 	const normalizedActiveIndex = normalizeIndexCandidate(storage.activeIndex, 0);
@@ -52,20 +391,388 @@ function normalizeStoredFamilyIndexes(storage: AccountStorageV3): void {
 }
 
 /**
- * Preserves one-way mirror semantics for Codex CLI compatibility state.
+ * Return the `accountId` and `email` from the first snapshot marked active.
  *
- * Multi-auth storage is the canonical source of truth. Codex CLI account files are mirrors only
- * and must never seed, merge into, or restore the canonical account pool. This helper is kept for
- * older call sites that still use the historical reconcile entry point, but it now only normalizes
- * the existing local indexes and never reads or applies Codex CLI account data.
+ * @param snapshots - Array of Codex CLI account snapshots to search
+ * @returns The `accountId` and `email` from the first snapshot whose `isActive` is true; properties are omitted if no active snapshot is found
  *
- * @param current - The current canonical AccountStorageV3, or null when no canonical storage exists.
- * @returns The original storage when no local normalization is needed, a normalized clone when index
- * values need clamping, or null when canonical storage is missing.
+ * Concurrency: pure and side-effect free; safe to call concurrently.
+ * Filesystem: behavior is independent of OS/filesystem semantics (including Windows).
+ * Security: only `accountId` and `email` are returned; other sensitive snapshot fields (for example tokens) are not exposed or returned by this function.
  */
+function readActiveFromSnapshots(snapshots: CodexCliAccountSnapshot[]): {
+	accountId?: string;
+	email?: string;
+} {
+	const active = snapshots.find((snapshot) => snapshot.isActive);
+	return {
+		accountId: active?.accountId,
+		email: active?.email,
+	};
+}
+
+/**
+ * Determines whether the Codex CLI's active-account selection should override the local selection.
+ *
+ * Considers the state's numeric `syncVersion` or `sourceUpdatedAtMs` and compares the derived Codex timestamp
+ * against local timestamps from recent account saves and last Codex selection writes. Concurrent writes or
+ * clock skew can affect this decision; filesystem timestamp granularity on Windows may reduce timestamp precision.
+ * This function only examines timestamps and identifiers in `state` and does not read or expose token values.
+ *
+ * @param state - Persisted Codex CLI state (may be undefined); the function reads `syncVersion` and `sourceUpdatedAtMs` when present
+ * @returns `true` if the Codex CLI selection should be applied (i.e., Codex state is newer or timestamps are unknown), `false` otherwise
+ */
+function shouldApplyCodexCliSelection(
+	state: Awaited<ReturnType<typeof loadCodexCliState>>,
+	persistedLocalTimestamp: number | null = 0,
+): boolean {
+	if (!state) return false;
+	const hasSyncVersion =
+		typeof state.syncVersion === "number" && Number.isFinite(state.syncVersion);
+	const codexVersion = hasSyncVersion
+		? (state.syncVersion as number)
+		: typeof state.sourceUpdatedAtMs === "number" &&
+				Number.isFinite(state.sourceUpdatedAtMs)
+			? state.sourceUpdatedAtMs
+			: 0;
+	const inProcessLocalVersion = Math.max(
+		getLastAccountsSaveTimestamp(),
+		getLastCodexCliSelectionWriteTimestamp(),
+	);
+	const localVersion = Math.max(
+		inProcessLocalVersion,
+		persistedLocalTimestamp ?? 0,
+	);
+	if (codexVersion <= 0) return true;
+	if (localVersion <= 0) {
+		return persistedLocalTimestamp !== null;
+	}
+	// Keep local selection when plugin wrote more recently than Codex state.
+	const toleranceMs = hasSyncVersion ? 0 : 1_000;
+	return codexVersion >= localVersion - toleranceMs;
+}
+
+function reconcileCodexCliState(
+	current: AccountStorageV3 | null,
+	state: NonNullable<Awaited<ReturnType<typeof loadCodexCliState>>>,
+	options: { persistedLocalTimestamp?: number | null } = {},
+): ReconcileResult {
+	const next = current ? cloneStorage(current) : createEmptyStorage();
+	const targetAccountCountBefore = next.accounts.length;
+	const matchedExistingIndexes = new Set<number>();
+	const summary = createEmptySyncSummary();
+	summary.sourceAccountCount = state.accounts.length;
+	summary.targetAccountCountBefore = targetAccountCountBefore;
+
+	let changed = false;
+	for (const snapshot of state.accounts) {
+		const result = upsertFromSnapshot(next.accounts, snapshot);
+		if (result.action === "skipped") continue;
+		if (
+			typeof result.matchedIndex === "number" &&
+			result.matchedIndex >= 0 &&
+			result.matchedIndex < targetAccountCountBefore
+		) {
+			matchedExistingIndexes.add(result.matchedIndex);
+		}
+		if (result.action === "added") {
+			summary.addedAccountCount += 1;
+			changed = true;
+			continue;
+		}
+		if (result.action === "updated") {
+			summary.updatedAccountCount += 1;
+			changed = true;
+			continue;
+		}
+		summary.unchangedAccountCount += 1;
+	}
+
+	summary.destinationOnlyPreservedCount = Math.max(
+		0,
+		targetAccountCountBefore - matchedExistingIndexes.size,
+	);
+
+	if (next.accounts.length > 0) {
+		const activeFromSnapshots = readActiveFromSnapshots(state.accounts);
+		const previousActive = next.activeIndex;
+		const previousFamilies = JSON.stringify(next.activeIndexByFamily ?? {});
+		const applyActiveFromCodex = shouldApplyCodexCliSelection(
+			state,
+			options.persistedLocalTimestamp,
+		);
+		if (applyActiveFromCodex) {
+			const desiredIndex = resolveActiveIndex(
+				next.accounts,
+				state.activeAccountId ?? activeFromSnapshots.accountId,
+				state.activeEmail ?? activeFromSnapshots.email,
+			);
+			if (typeof desiredIndex === "number") {
+				applyCodexCliSelection(next, desiredIndex);
+			} else if (
+				state.activeAccountId ||
+				state.activeEmail ||
+				activeFromSnapshots.accountId ||
+				activeFromSnapshots.email
+			) {
+				log.debug(
+					"Skipped Codex CLI active selection overwrite due to ambiguous source selection",
+					{
+						operation: "reconcile-storage",
+						outcome: "selection-ambiguous",
+					},
+				);
+			}
+		} else {
+			log.debug(
+				"Skipped Codex CLI active selection overwrite due to newer local state",
+				{
+					operation: "reconcile-storage",
+					outcome: "local-newer",
+				},
+			);
+		}
+		normalizeStoredFamilyIndexes(next);
+		const currentFamilies = JSON.stringify(next.activeIndexByFamily ?? {});
+		if (
+			previousActive !== next.activeIndex ||
+			previousFamilies !== currentFamilies
+		) {
+			summary.selectionChanged = true;
+			changed = true;
+		}
+	}
+
+	summary.targetAccountCountAfter = next.accounts.length;
+	return { next, changed, summary };
+}
+
+export async function previewCodexCliSync(
+	current: AccountStorageV3 | null,
+	options: { forceRefresh?: boolean; storageBackupEnabled?: boolean } = {},
+): Promise<CodexCliSyncPreview> {
+	const targetPath = getStoragePath();
+	const syncEnabled = isCodexCliSyncEnabled();
+	const backup = {
+		enabled: options.storageBackupEnabled ?? true,
+		targetPath,
+		rollbackPaths: formatRollbackPaths(targetPath),
+	};
+	const lastSync = getLastCodexCliSyncRun();
+	const emptySummary = createEmptySyncSummary();
+	emptySummary.targetAccountCountBefore = current?.accounts.length ?? 0;
+	emptySummary.targetAccountCountAfter = current?.accounts.length ?? 0;
+	try {
+		if (!syncEnabled) {
+			return {
+				status: "disabled",
+				statusDetail: "Codex CLI sync is disabled by environment override.",
+				sourcePath: null,
+				sourceAccountCount: null,
+				targetPath,
+				summary: emptySummary,
+				backup,
+				lastSync,
+			};
+		}
+		const state = await loadCodexCliState({
+			forceRefresh: options.forceRefresh,
+		});
+		if (!state) {
+			return {
+				status: "unavailable",
+				statusDetail: "No Codex CLI sync source was found.",
+				sourcePath: null,
+				sourceAccountCount: null,
+				targetPath,
+				summary: emptySummary,
+				backup,
+				lastSync,
+			};
+		}
+
+		const reconciled = reconcileCodexCliState(current, state, {
+			persistedLocalTimestamp: await getPersistedLocalSelectionTimestamp(),
+		});
+		const status = reconciled.changed ? "ready" : "noop";
+		const skippedAccountCount = Math.max(
+			0,
+			reconciled.summary.sourceAccountCount -
+				reconciled.summary.addedAccountCount -
+				reconciled.summary.updatedAccountCount -
+				reconciled.summary.unchangedAccountCount,
+		);
+		const statusDetail = reconciled.changed
+			? `Preview ready: ${reconciled.summary.addedAccountCount} add, ${reconciled.summary.updatedAccountCount} update, ${reconciled.summary.destinationOnlyPreservedCount} destination-only preserved${
+					skippedAccountCount > 0 ? `, ${skippedAccountCount} skipped` : ""
+				}.`
+			: skippedAccountCount > 0
+				? `Target already matches the current one-way sync result. ${skippedAccountCount} source account skipped due to conflicting or incomplete identity.`
+				: "Target already matches the current one-way sync result.";
+		return {
+			status,
+			statusDetail,
+			sourcePath: state.path,
+			sourceAccountCount: state.accounts.length,
+			targetPath,
+			summary: reconciled.summary,
+			backup,
+			lastSync,
+		};
+	} catch (error) {
+		return {
+			status: "error",
+			statusDetail: error instanceof Error ? error.message : String(error),
+			sourcePath: null,
+			sourceAccountCount: null,
+			targetPath,
+			summary: emptySummary,
+			backup,
+			lastSync,
+		};
+	}
+}
+
+/**
+ * Reconciles the provided local account storage with the Codex CLI state and returns the resulting storage and whether it changed.
+ *
+ * This operation:
+ * - Merges accounts from the Codex CLI state into a clone of `current` (or into a new empty storage when `current` is null).
+ * - May update the active account selection and per-family active indexes when the Codex CLI selection is considered applicable.
+ * - Preserves secrets and sensitive fields; any tokens written to storage are subject to the project's token-redaction rules and are not exposed in logs or metrics.
+ *
+ * Concurrency assumptions:
+ * - Caller is responsible for serializing concurrent writes to persistent storage; this function only returns an in-memory storage object and does not perform atomic file-level coordination.
+ *
+ * Windows filesystem notes:
+ * - When the caller persists the returned storage to disk on Windows, standard Windows file-locking and path-length semantics apply; this function does not perform Windows-specific path normalization.
+ *
+ * @param current - The current local AccountStorageV3, or `null` to indicate none exists.
+ * @returns An object containing:
+ *   - `storage`: the reconciled AccountStorageV3 to persist (may be the original `current` when no changes were applied).
+ *   - `changed`: `true` if the reconciled storage differs from `current`, `false` otherwise.
+ */
+export async function applyCodexCliSyncToStorage(
+	current: AccountStorageV3 | null,
+	options: { forceRefresh?: boolean } = {},
+): Promise<{
+	storage: AccountStorageV3 | null;
+	changed: boolean;
+	pendingRun: PendingCodexCliSyncRun | null;
+}> {
+	incrementCodexCliMetric("reconcileAttempts");
+	const targetPath = getStoragePath();
+	const revision = allocateCodexCliSyncRunRevision();
+	try {
+		if (!isCodexCliSyncEnabled()) {
+			incrementCodexCliMetric("reconcileNoops");
+			publishCodexCliSyncRun(
+				createSyncRun({
+					outcome: "disabled",
+					sourcePath: null,
+					targetPath,
+					summary: {
+						...createEmptySyncSummary(),
+						targetAccountCountBefore: current?.accounts.length ?? 0,
+						targetAccountCountAfter: current?.accounts.length ?? 0,
+					},
+					message: "Codex CLI sync disabled by environment override.",
+				}),
+				revision,
+			);
+			return { storage: current, changed: false, pendingRun: null };
+		}
+
+		const state = await loadCodexCliState({
+			forceRefresh: options.forceRefresh ?? true,
+		});
+		if (!state) {
+			incrementCodexCliMetric("reconcileNoops");
+			publishCodexCliSyncRun(
+				createSyncRun({
+					outcome: "unavailable",
+					sourcePath: null,
+					targetPath,
+					summary: {
+						...createEmptySyncSummary(),
+						targetAccountCountBefore: current?.accounts.length ?? 0,
+						targetAccountCountAfter: current?.accounts.length ?? 0,
+					},
+					message: "No Codex CLI sync source was available.",
+				}),
+				revision,
+			);
+			return { storage: current, changed: false, pendingRun: null };
+		}
+
+		const reconciled = reconcileCodexCliState(current, state, {
+			persistedLocalTimestamp: await getPersistedLocalSelectionTimestamp(),
+		});
+		const next = reconciled.next;
+		const changed = reconciled.changed;
+		const storage =
+			next.accounts.length === 0 ? (current ?? next) : next;
+		const syncRun = createSyncRun({
+			outcome: changed ? "changed" : "noop",
+			sourcePath: state.path,
+			targetPath,
+			summary: reconciled.summary,
+		});
+
+		if (!changed) {
+			incrementCodexCliMetric("reconcileNoops");
+			publishCodexCliSyncRun(syncRun, revision);
+		} else {
+			incrementCodexCliMetric("reconcileChanges");
+		}
+
+		const activeFromSnapshots = readActiveFromSnapshots(state.accounts);
+		log.debug("Codex CLI reconcile completed", {
+			operation: "reconcile-storage",
+			outcome: changed ? "changed" : "noop",
+			accountCount: next.accounts.length,
+			activeAccountRef: makeAccountFingerprint({
+				accountId: state.activeAccountId ?? activeFromSnapshots.accountId,
+				email: state.activeEmail ?? activeFromSnapshots.email,
+			}),
+		});
+		return {
+			storage,
+			changed,
+			pendingRun: changed ? { revision, run: syncRun } : null,
+		};
+	} catch (error) {
+		incrementCodexCliMetric("reconcileFailures");
+		publishCodexCliSyncRun(
+			createSyncRun({
+				outcome: "error",
+				sourcePath: null,
+				targetPath,
+				summary: {
+					...createEmptySyncSummary(),
+					targetAccountCountBefore: current?.accounts.length ?? 0,
+					targetAccountCountAfter: current?.accounts.length ?? 0,
+				},
+				message: error instanceof Error ? error.message : String(error),
+			}),
+			revision,
+		);
+		log.warn("Codex CLI reconcile failed", {
+			operation: "reconcile-storage",
+			outcome: "error",
+			error: String(error),
+		});
+		return { storage: current, changed: false, pendingRun: null };
+	}
+}
+
 export function syncAccountStorageFromCodexCli(
 	current: AccountStorageV3 | null,
-): Promise<{ storage: AccountStorageV3 | null; changed: boolean }> {
+): Promise<{
+	storage: AccountStorageV3 | null;
+	changed: boolean;
+	pendingRun: PendingCodexCliSyncRun | null;
+}> {
 	incrementCodexCliMetric("reconcileAttempts");
 
 	if (!current) {
@@ -74,7 +781,7 @@ export function syncAccountStorageFromCodexCli(
 			operation: "reconcile-storage",
 			outcome: "canonical-missing",
 		});
-		return Promise.resolve({ storage: null, changed: false });
+		return Promise.resolve({ storage: null, changed: false, pendingRun: null });
 	}
 
 	const next = cloneStorage(current);
@@ -87,15 +794,19 @@ export function syncAccountStorageFromCodexCli(
 		previousFamilies !== JSON.stringify(next.activeIndexByFamily ?? {});
 
 	incrementCodexCliMetric(changed ? "reconcileChanges" : "reconcileNoops");
-	log.debug("Skipped Codex CLI authority import; canonical storage remains authoritative", {
-		operation: "reconcile-storage",
-		outcome: changed ? "normalized-local-indexes" : "canonical-authoritative",
-		accountCount: next.accounts.length,
-	});
+	log.debug(
+		"Skipped Codex CLI authority import; canonical storage remains authoritative",
+		{
+			operation: "reconcile-storage",
+			outcome: changed ? "normalized-local-indexes" : "canonical-authoritative",
+			accountCount: next.accounts.length,
+		},
+	);
 
 	return Promise.resolve({
 		storage: changed ? next : current,
 		changed,
+		pendingRun: null,
 	});
 }
 
diff --git a/lib/codex-manager/settings-hub.ts b/lib/codex-manager/settings-hub.ts
index 172648d..30ca1d3 100644
--- a/lib/codex-manager/settings-hub.ts
+++ b/lib/codex-manager/settings-hub.ts
@@ -1,8 +1,26 @@
 import { promises as fs } from "node:fs";
 import { stdin as input, stdout as output } from "node:process";
 import { createInterface } from "node:readline/promises";
+import {
+	getCodexCliAccountsPath,
+	getCodexCliAuthPath,
+	getCodexCliConfigPath,
+	isCodexCliSyncEnabled,
+} from "../codex-cli/state.js";
+import {
+	applyCodexCliSyncToStorage,
+	commitCodexCliSyncRunFailure,
+	commitPendingCodexCliSyncRun,
+	type CodexCliSyncPreview,
+	type CodexCliSyncRun,
+	type CodexCliSyncSummary,
+	formatRollbackPaths,
+	getLastCodexCliSyncRun,
+	previewCodexCliSync,
+} from "../codex-cli/sync.js";
 import {
 	getDefaultPluginConfig,
+	getStorageBackupEnabled,
 	loadPluginConfig,
 	savePluginConfig,
 } from "../config.js";
@@ -17,13 +35,22 @@ import {
 	loadDashboardDisplaySettings,
 	saveDashboardDisplaySettings,
 } from "../dashboard-settings.js";
+import {
+	getLastLiveAccountSyncSnapshot,
+	type LiveAccountSyncSnapshot,
+} from "../live-account-sync.js";
 import {
 	applyOcChatgptSync,
 	planOcChatgptSync,
 	runNamedBackupExport,
 } from "../oc-chatgpt-orchestrator.js";
 import { detectOcChatgptMultiAuthTarget } from "../oc-chatgpt-target-detection.js";
-import { loadAccounts, normalizeAccountStorage } from "../storage.js";
+import {
+	getStoragePath,
+	loadAccounts,
+	normalizeAccountStorage,
+	saveAccounts,
+} from "../storage.js";
 import type { PluginConfig } from "../types.js";
 import { ANSI } from "../ui/ansi.js";
 import { UI_COPY } from "../ui/copy.js";
@@ -264,6 +291,7 @@ type BackendSettingsHubAction =
 
 type SettingsHubAction =
 	| { type: "account-list" }
+	| { type: "sync-center" }
 	| { type: "summary-fields" }
 	| { type: "behavior" }
 	| { type: "theme" }
@@ -271,6 +299,20 @@ type SettingsHubAction =
 	| { type: "backend" }
 	| { type: "back" };
 
+type SyncCenterAction =
+	| { type: "refresh" }
+	| { type: "apply" }
+	| { type: "back" };
+
+interface SyncCenterOverviewContext {
+	accountsPath: string;
+	authPath: string;
+	configPath: string;
+	sourceAccountCount: number | null;
+	liveSync: LiveAccountSyncSnapshot;
+	syncEnabled: boolean;
+}
+
 type ExperimentalSettingsAction =
 	| { type: "sync" }
 	| { type: "backup" }
@@ -280,7 +322,6 @@ type ExperimentalSettingsAction =
 	| { type: "apply" }
 	| { type: "save" }
 	| { type: "back" };
-
 const BACKEND_TOGGLE_OPTIONS: BackendToggleSettingOption[] = [
 	{
 		key: "liveAccountSync",
@@ -782,7 +823,6 @@ async function readFileWithRetry(path: string): Promise<string> {
 		}
 	}
 }
-
 async function persistBackendConfigSelection(
 	selected: PluginConfig,
 	scope: string,
@@ -1237,6 +1277,163 @@ function formatMenuQuotaTtl(ttlMs: number): string {
 	return `${ttlMs}ms`;
 }
 
+function formatSyncRunTime(run: CodexCliSyncRun | null): string {
+	if (!run) return "No sync applied in this session.";
+	return new Date(run.runAt).toISOString().replace("T", " ");
+}
+
+function formatSyncRunOutcome(run: CodexCliSyncRun | null): string {
+	if (!run) return "none";
+	if (run.outcome === "changed") return "applied changes";
+	if (run.outcome === "noop") return "already aligned";
+	if (run.outcome === "disabled") return "disabled";
+	if (run.outcome === "unavailable") return "source missing";
+	return run.message ? `error: ${run.message}` : "error";
+}
+
+function formatSyncSummary(summary: CodexCliSyncSummary): string {
+	return [
+		`add ${summary.addedAccountCount}`,
+		`update ${summary.updatedAccountCount}`,
+		`preserve ${summary.destinationOnlyPreservedCount}`,
+		`after ${summary.targetAccountCountAfter}`,
+	].join(" | ");
+}
+
+function formatSyncTimestamp(timestamp: number | null | undefined): string {
+	if (
+		typeof timestamp !== "number" ||
+		!Number.isFinite(timestamp) ||
+		timestamp <= 0
+	) {
+		return "none";
+	}
+	return new Date(timestamp).toISOString().replace("T", " ");
+}
+
+function formatSyncMtime(mtimeMs: number | null): string {
+	if (
+		typeof mtimeMs !== "number" ||
+		!Number.isFinite(mtimeMs) ||
+		mtimeMs <= 0
+	) {
+		return "unknown";
+	}
+	return new Date(Math.round(mtimeMs)).toISOString().replace("T", " ");
+}
+
+function resolveSyncCenterContext(
+	sourceAccountCount: number | null,
+): SyncCenterOverviewContext {
+	return {
+		accountsPath: getCodexCliAccountsPath(),
+		authPath: getCodexCliAuthPath(),
+		configPath: getCodexCliConfigPath(),
+		sourceAccountCount,
+		liveSync: getLastLiveAccountSyncSnapshot(),
+		syncEnabled: isCodexCliSyncEnabled(),
+	};
+}
+
+function formatSyncSourceLabel(
+	preview: CodexCliSyncPreview,
+	context: SyncCenterOverviewContext,
+): string {
+	const normalizedSourcePath = normalizePathForComparison(preview.sourcePath);
+	const normalizedAccountsPath = normalizePathForComparison(context.accountsPath);
+	const normalizedAuthPath = normalizePathForComparison(context.authPath);
+	if (!context.syncEnabled) return "disabled by environment override";
+	if (!normalizedSourcePath) return "not available";
+	if (normalizedSourcePath === normalizedAccountsPath)
+		return "accounts.json active";
+	if (normalizedSourcePath === normalizedAuthPath)
+		return "auth.json fallback active";
+	return "custom source path active";
+}
+
+function normalizePathForComparison(
+	path: string | null | undefined,
+): string | null {
+	if (typeof path !== "string" || path.length === 0) {
+		return null;
+	}
+	const normalized = path.replace(/\\/g, "/").replace(/\/+/g, "/");
+	const trimmed =
+		normalized.length > 1 ? normalized.replace(/\/+$/, "") : normalized;
+	const isWindowsPath = path.includes("\\") || /^[a-z]:\//i.test(trimmed);
+	return isWindowsPath ? trimmed.toLowerCase() : trimmed;
+}
+
+function buildSyncCenterOverview(
+	preview: CodexCliSyncPreview,
+	context: SyncCenterOverviewContext = resolveSyncCenterContext(null),
+): Array<{ label: string; hint?: string }> {
+	const lastSync = preview.lastSync;
+	const activeSourceLabel = formatSyncSourceLabel(preview, context);
+	const liveSync = context.liveSync;
+	const liveSyncLabel = liveSync.running ? "running" : "idle";
+	const liveSyncHint = liveSync.running
+		? `Watching ${liveSync.path ?? preview.targetPath}. Reloads ${liveSync.reloadCount}, errors ${liveSync.errorCount}, last reload ${formatSyncTimestamp(liveSync.lastSyncAt)}, last seen mtime ${formatSyncMtime(liveSync.lastKnownMtimeMs)}.`
+		: `No live watcher is active in this process. When plugin mode runs with live sync enabled, it watches ${preview.targetPath} and reloads accounts after file changes.`;
+	const sourceStateHint = [
+		`Active source: ${activeSourceLabel}.`,
+		`Accounts path: ${context.accountsPath}`,
+		`Auth path: ${context.authPath}`,
+		`Config path: ${context.configPath}`,
+		context.sourceAccountCount !== null
+			? `Visible source accounts: ${context.sourceAccountCount}.`
+			: "No readable Codex CLI source is visible right now.",
+	].join("\n");
+	const selectionHint = preview.summary.selectionChanged
+		? "When the Codex CLI source is newer, target selection follows activeAccountId first, then activeEmail or the active snapshot email. If local storage or a local Codex selection write is newer, the target keeps the local selection."
+		: "Selection precedence stays accountId first, then email, with newer local target state preserving its own active selection instead of being overwritten.";
+	return [
+		{
+			label: `Status: ${preview.status}`,
+			hint: `${preview.statusDetail}\nLast sync: ${formatSyncRunOutcome(lastSync)} at ${formatSyncRunTime(lastSync)}`,
+		},
+		{
+			label: `Target path: ${preview.targetPath}`,
+			hint: preview.sourcePath
+				? `Source path: ${preview.sourcePath}`
+				: "Source path: not available",
+		},
+		{
+			label: `Codex CLI source visibility: ${activeSourceLabel}`,
+			hint: sourceStateHint,
+		},
+		{
+			label: `Live watcher: ${liveSyncLabel}`,
+			hint: liveSyncHint,
+		},
+		{
+			label: "Preview mode: read-only until apply",
+			hint: "Refresh only re-reads the Codex CLI source and recomputes the one-way result. Apply writes that preview into the target path; it does not create a bidirectional merge.",
+		},
+		{
+			label: `Preview summary: ${formatSyncSummary(preview.summary)}`,
+			hint: preview.summary.selectionChanged
+				? "Active selection also updates to match the current Codex CLI source when that source is newer."
+				: "Active selection already matches the one-way sync result.",
+		},
+		{
+			label:
+				"Selection precedence: accountId -> email -> preserve newer local choice",
+			hint: selectionHint,
+		},
+		{
+			label: `Destination-only preservation: keep ${preview.summary.destinationOnlyPreservedCount} target-only account(s)`,
+			hint: "One-way sync never deletes accounts that exist only in the target storage.",
+		},
+		{
+			label: `Pre-sync backup and rollback: ${preview.backup.enabled ? "enabled" : "disabled"}`,
+			hint: preview.backup.enabled
+				? `Before apply, target writes can create ${preview.backup.rollbackPaths.join(", ")} so rollback has explicit recovery context if the sync result is not what you expected.`
+				: "Storage backups are currently disabled, so apply writes rely on the direct target write only.",
+		},
+	];
+}
+
 function clampBackendNumberForTests(settingKey: string, value: number): number {
 	const option = BACKEND_NUMBER_OPTION_BY_KEY.get(
 		settingKey as BackendNumberSettingKey,
@@ -1277,6 +1474,7 @@ const __testOnly = {
 	clampBackendNumber: clampBackendNumberForTests,
 	formatMenuLayoutMode,
 	cloneDashboardSettings,
+	buildSyncCenterOverview,
 	withQueuedRetry: withQueuedRetryForTests,
 	loadExperimentalSyncTarget,
 	promptExperimentalSettings,
@@ -2474,6 +2672,205 @@ async function promptBackendSettings(
 	}
 }
 
+async function promptSyncCenter(config: PluginConfig): Promise<void> {
+	if (!input.isTTY || !output.isTTY) return;
+	const ui = getUiRuntimeOptions();
+	const buildPreview = async (
+		forceRefresh = false,
+	): Promise<{
+		preview: CodexCliSyncPreview;
+		context: SyncCenterOverviewContext;
+	}> => {
+		const current = await loadAccounts();
+		const preview = await previewCodexCliSync(current, {
+			forceRefresh,
+			storageBackupEnabled: getStorageBackupEnabled(config),
+		});
+		return {
+			preview,
+			context: resolveSyncCenterContext(preview.sourceAccountCount),
+		};
+	};
+	const buildErrorState = (
+		message: string,
+		previousPreview?: CodexCliSyncPreview,
+	): {
+		preview: CodexCliSyncPreview;
+		context: SyncCenterOverviewContext;
+	} => {
+		if (previousPreview) {
+			return {
+				preview: {
+					...previousPreview,
+					lastSync: getLastCodexCliSyncRun(),
+					status: "error",
+					statusDetail: message,
+				},
+				context: resolveSyncCenterContext(previousPreview.sourceAccountCount),
+			};
+		}
+
+		const targetPath = getStoragePath();
+		const emptySummary: CodexCliSyncSummary = {
+			sourceAccountCount: 0,
+			targetAccountCountBefore: 0,
+			targetAccountCountAfter: 0,
+			addedAccountCount: 0,
+			updatedAccountCount: 0,
+			unchangedAccountCount: 0,
+			destinationOnlyPreservedCount: 0,
+			selectionChanged: false,
+		};
+		return {
+			preview: {
+				status: "error",
+				statusDetail: message,
+				sourcePath: null,
+				sourceAccountCount: null,
+				targetPath,
+				summary: emptySummary,
+				backup: {
+					enabled: getStorageBackupEnabled(config),
+					targetPath,
+					rollbackPaths: formatRollbackPaths(targetPath),
+				},
+				lastSync: getLastCodexCliSyncRun(),
+			},
+			context: resolveSyncCenterContext(null),
+		};
+	};
+	const buildPreviewSafely = async (
+		forceRefresh = false,
+		previousPreview?: CodexCliSyncPreview,
+	): Promise<{
+		preview: CodexCliSyncPreview;
+		context: SyncCenterOverviewContext;
+	}> => {
+		try {
+			return await withQueuedRetry(getStoragePath(), async () =>
+				buildPreview(forceRefresh),
+			);
+		} catch (error) {
+			return buildErrorState(
+				`Failed to refresh sync center: ${
+					error instanceof Error ? error.message : String(error)
+				}`,
+				previousPreview,
+			);
+		}
+	};
+
+	let { preview, context } = await buildPreviewSafely(true);
+	while (true) {
+		const overview = buildSyncCenterOverview(preview, context);
+		const items: MenuItem<SyncCenterAction>[] = [
+			{
+				label: UI_COPY.settings.syncCenterOverviewHeading,
+				value: { type: "back" },
+				kind: "heading",
+			},
+			...overview.map((item) => ({
+				label: item.label,
+				hint: item.hint,
+				value: { type: "back" } as SyncCenterAction,
+				disabled: true,
+				color: "green" as const,
+				hideUnavailableSuffix: true,
+			})),
+			{ label: "", value: { type: "back" }, separator: true },
+			{
+				label: UI_COPY.settings.syncCenterActionsHeading,
+				value: { type: "back" },
+				kind: "heading",
+			},
+			{
+				label: UI_COPY.settings.syncCenterApply,
+				hint: "Applies the current preview to the target storage path.",
+				value: { type: "apply" },
+				color: preview.status === "ready" ? "green" : "yellow",
+				disabled: preview.status !== "ready",
+			},
+			{
+				label: UI_COPY.settings.syncCenterRefresh,
+				hint: "Re-read the source files and rebuild the sync preview.",
+				value: { type: "refresh" },
+				color: "yellow",
+			},
+			{
+				label: UI_COPY.settings.syncCenterBack,
+				value: { type: "back" },
+				color: "red",
+			},
+		];
+
+		const result = await select<SyncCenterAction>(items, {
+			message: UI_COPY.settings.syncCenterTitle,
+			subtitle: UI_COPY.settings.syncCenterSubtitle,
+			help: UI_COPY.settings.syncCenterHelp,
+			clearScreen: true,
+			theme: ui.theme,
+			selectedEmphasis: "minimal",
+			onInput: (raw) => {
+				const lower = raw.toLowerCase();
+				if (lower === "q") return { type: "back" };
+				if (lower === "r") return { type: "refresh" };
+				if (lower === "a" && preview.status === "ready") {
+					return { type: "apply" };
+				}
+				return undefined;
+			},
+		});
+
+		if (!result || result.type === "back") return;
+		if (result.type === "refresh") {
+			({ preview, context } = await buildPreviewSafely(true, preview));
+			continue;
+		}
+
+		try {
+			const current = await withQueuedRetry(preview.targetPath, async () =>
+				loadAccounts(),
+			);
+			const synced = await applyCodexCliSyncToStorage(current, {
+				forceRefresh: true,
+			});
+			const storageBackupEnabled = getStorageBackupEnabled(config);
+			if (synced.changed && synced.storage) {
+				const syncedStorage = synced.storage;
+				try {
+					await withQueuedRetry(preview.targetPath, async () =>
+						saveAccounts(syncedStorage, {
+							backupEnabled: storageBackupEnabled,
+						}),
+					);
+					commitPendingCodexCliSyncRun(synced.pendingRun);
+				} catch (error) {
+					commitCodexCliSyncRunFailure(synced.pendingRun, error);
+					preview = {
+						...preview,
+						lastSync: getLastCodexCliSyncRun(),
+						status: "error",
+						statusDetail: `Failed to save synced storage: ${
+							error instanceof Error ? error.message : String(error)
+						}`,
+					};
+					continue;
+				}
+			}
+			({ preview, context } = await buildPreviewSafely(true, preview));
+		} catch (error) {
+			preview = {
+				...preview,
+				status: "error",
+				lastSync: getLastCodexCliSyncRun(),
+				statusDetail: `Failed to refresh sync center: ${
+					error instanceof Error ? error.message : String(error)
+				}`,
+			};
+		}
+	}
+}
+
 async function loadExperimentalSyncTarget(): Promise<
 	| {
 			kind: "blocked-ambiguous";
@@ -2881,6 +3278,11 @@ async function promptSettingsHub(
 			value: { type: "account-list" },
 			color: "green",
 		},
+		{
+			label: UI_COPY.settings.syncCenter,
+			value: { type: "sync-center" },
+			color: "green",
+		},
 		{
 			label: UI_COPY.settings.summaryFields,
 			value: { type: "summary-fields" },
@@ -2958,6 +3360,10 @@ async function configureUnifiedSettings(
 			current = await configureDashboardDisplaySettings(current);
 			continue;
 		}
+		if (action.type === "sync-center") {
+			await promptSyncCenter(backendConfig);
+			continue;
+		}
 		if (action.type === "summary-fields") {
 			current = await configureStatuslineSettings(current);
 			continue;
diff --git a/lib/live-account-sync.ts b/lib/live-account-sync.ts
index 245be89..c8ccdbc 100644
--- a/lib/live-account-sync.ts
+++ b/lib/live-account-sync.ts
@@ -1,4 +1,4 @@
-import { promises as fs, watch as fsWatch, type FSWatcher } from "node:fs";
+import { type FSWatcher, promises as fs, watch as fsWatch } from "node:fs";
 import { basename, dirname } from "node:path";
 import { createLogger } from "./logger.js";
 
@@ -18,13 +18,40 @@ export interface LiveAccountSyncSnapshot {
 	errorCount: number;
 }
 
+const EMPTY_LIVE_ACCOUNT_SYNC_SNAPSHOT: LiveAccountSyncSnapshot = {
+	path: null,
+	running: false,
+	lastKnownMtimeMs: null,
+	lastSyncAt: null,
+	reloadCount: 0,
+	errorCount: 0,
+};
+
+let lastLiveAccountSyncSnapshot: LiveAccountSyncSnapshot = {
+	...EMPTY_LIVE_ACCOUNT_SYNC_SNAPSHOT,
+};
+let lastLiveAccountSyncSnapshotInstanceId = 0;
+let nextLiveAccountSyncInstanceId = 0;
+
+export function getLastLiveAccountSyncSnapshot(): LiveAccountSyncSnapshot {
+	return { ...lastLiveAccountSyncSnapshot };
+}
+
+export function __resetLastLiveAccountSyncSnapshotForTests(): void {
+	lastLiveAccountSyncSnapshot = { ...EMPTY_LIVE_ACCOUNT_SYNC_SNAPSHOT };
+	lastLiveAccountSyncSnapshotInstanceId = 0;
+	nextLiveAccountSyncInstanceId = 0;
+}
+
 /**
  * Convert an fs.watch filename value to a UTF-8 string or null.
  *
  * @param filename - The value supplied by fs.watch listeners; may be a `string`, `Buffer`, or `null`. Buffers are decoded as UTF-8.
  * @returns `filename` as a UTF-8 string, or `null` when the input is `null`.
  */
-function normalizeFsWatchFilename(filename: string | Buffer | null): string | null {
+function normalizeFsWatchFilename(
+	filename: string | Buffer | null,
+): string | null {
 	if (filename === null) return null;
 	if (typeof filename === "string") return filename;
 	return filename.toString("utf-8");
@@ -63,6 +90,7 @@ function summarizeWatchPath(path: string | null): string {
  * changes. Uses fs.watch + polling fallback for Windows reliability.
  */
 export class LiveAccountSync {
+	private readonly instanceId: number;
 	private readonly reload: () => Promise<void>;
 	private readonly debounceMs: number;
 	private readonly pollIntervalMs: number;
@@ -77,10 +105,17 @@ export class LiveAccountSync {
 	private errorCount = 0;
 	private reloadInFlight: Promise<void> | null = null;
 
-	constructor(reload: () => Promise<void>, options: LiveAccountSyncOptions = {}) {
+	constructor(
+		reload: () => Promise<void>,
+		options: LiveAccountSyncOptions = {},
+	) {
+		this.instanceId = ++nextLiveAccountSyncInstanceId;
 		this.reload = reload;
 		this.debounceMs = Math.max(50, Math.floor(options.debounceMs ?? 250));
-		this.pollIntervalMs = Math.max(500, Math.floor(options.pollIntervalMs ?? 2_000));
+		this.pollIntervalMs = Math.max(
+			500,
+			Math.floor(options.pollIntervalMs ?? 2_000),
+		);
 	}
 
 	async syncToPath(path: string): Promise<void> {
@@ -94,17 +129,21 @@ export class LiveAccountSync {
 		const targetName = basename(path);
 
 		try {
-			this.watcher = fsWatch(targetDir, { persistent: false }, (_eventType, filename) => {
-				const name = normalizeFsWatchFilename(filename);
-				if (!name) {
-					this.scheduleReload("watch");
-					return;
-				}
-
-				if (name === targetName || name.startsWith(`${targetName}.`)) {
-					this.scheduleReload("watch");
-				}
-			});
+			this.watcher = fsWatch(
+				targetDir,
+				{ persistent: false },
+				(_eventType, filename) => {
+					const name = normalizeFsWatchFilename(filename);
+					if (!name) {
+						this.scheduleReload("watch");
+						return;
+					}
+
+					if (name === targetName || name.startsWith(`${targetName}.`)) {
+						this.scheduleReload("watch");
+					}
+				},
+			);
 		} catch (error) {
 			this.errorCount += 1;
 			log.warn("Failed to start fs.watch for account storage", {
@@ -116,11 +155,16 @@ export class LiveAccountSync {
 		this.pollTimer = setInterval(() => {
 			void this.pollOnce();
 		}, this.pollIntervalMs);
-		if (typeof this.pollTimer === "object" && "unref" in this.pollTimer && typeof this.pollTimer.unref === "function") {
+		if (
+			typeof this.pollTimer === "object" &&
+			"unref" in this.pollTimer &&
+			typeof this.pollTimer.unref === "function"
+		) {
 			this.pollTimer.unref();
 		}
 
 		this.running = true;
+		this.publishSnapshot();
 	}
 
 	stop(): void {
@@ -137,6 +181,7 @@ export class LiveAccountSync {
 			clearTimeout(this.debounceTimer);
 			this.debounceTimer = null;
 		}
+		this.publishSnapshot();
 	}
 
 	getSnapshot(): LiveAccountSyncSnapshot {
@@ -150,6 +195,14 @@ export class LiveAccountSync {
 		};
 	}
 
+	private publishSnapshot(): void {
+		if (this.instanceId < lastLiveAccountSyncSnapshotInstanceId) {
+			return;
+		}
+		lastLiveAccountSyncSnapshotInstanceId = this.instanceId;
+		lastLiveAccountSyncSnapshot = this.getSnapshot();
+	}
+
 	private scheduleReload(reason: "watch" | "poll"): void {
 		if (!this.running) return;
 		if (this.debounceTimer) {
@@ -174,6 +227,7 @@ export class LiveAccountSync {
 				path: summarizeWatchPath(this.currentPath),
 				error: error instanceof Error ? error.message : String(error),
 			});
+			this.publishSnapshot();
 		}
 	}
 
@@ -209,6 +263,7 @@ export class LiveAccountSync {
 			await this.reloadInFlight;
 		} finally {
 			this.reloadInFlight = null;
+			this.publishSnapshot();
 		}
 	}
 }
diff --git a/lib/storage.ts b/lib/storage.ts
index 36ee2aa..9aa3def 100644
--- a/lib/storage.ts
+++ b/lib/storage.ts
@@ -291,6 +291,10 @@ export function setStorageBackupEnabled(enabled: boolean): void {
 	storageBackupEnabled = enabled;
 }
 
+export function isStorageBackupEnabled(): boolean {
+	return storageBackupEnabled;
+}
+
 function getAccountsBackupPath(path: string): string {
 	return `${path}${ACCOUNTS_BACKUP_SUFFIX}`;
 }
@@ -1782,12 +1786,20 @@ async function loadAccountsInternal(
 	}
 }
 
-async function saveAccountsUnlocked(storage: AccountStorageV3): Promise<void> {
+interface SaveAccountsOptions {
+	backupEnabled?: boolean;
+}
+
+async function saveAccountsUnlocked(
+	storage: AccountStorageV3,
+	options: SaveAccountsOptions = {},
+): Promise<void> {
 	const path = getStoragePath();
 	const resetMarkerPath = getIntentionalResetMarkerPath(path);
 	const uniqueSuffix = `${Date.now()}.${Math.random().toString(36).slice(2, 8)}`;
 	const tempPath = `${path}.${uniqueSuffix}.tmp`;
 	const walPath = getAccountsWalPath(path);
+	const backupEnabled = options.backupEnabled ?? storageBackupEnabled;
 
 	try {
 		await fs.mkdir(dirname(path), { recursive: true });
@@ -1819,7 +1831,7 @@ async function saveAccountsUnlocked(storage: AccountStorageV3): Promise<void> {
 			}
 		}
 
-		if (storageBackupEnabled && existsSync(path)) {
+		if (backupEnabled && existsSync(path)) {
 			try {
 				await createRotatingAccountsBackup(path);
 			} catch (backupError) {
@@ -1991,9 +2003,12 @@ export async function withAccountAndFlaggedStorageTransaction<T>(
  * @param storage - Account storage data to save
  * @throws StorageError with platform-aware hints on failure
  */
-export async function saveAccounts(storage: AccountStorageV3): Promise<void> {
+export async function saveAccounts(
+	storage: AccountStorageV3,
+	options: SaveAccountsOptions = {},
+): Promise<void> {
 	return withStorageLock(async () => {
-		await saveAccountsUnlocked(storage);
+		await saveAccountsUnlocked(storage, options);
 	});
 }
 
diff --git a/lib/ui/copy.ts b/lib/ui/copy.ts
index b4505e8..1e6f36f 100644
--- a/lib/ui/copy.ts
+++ b/lib/ui/copy.ts
@@ -66,6 +66,7 @@ export const UI_COPY = {
 		advancedTitle: "Advanced",
 		exitTitle: "Back",
 		accountList: "Account List View",
+		syncCenter: "Sync Center",
 		summaryFields: "Summary Line",
 		behavior: "Menu Behavior",
 		theme: "Color Theme",
@@ -109,6 +110,15 @@ export const UI_COPY = {
 		backendSubtitle: "Tune sync, retry, and limit behavior",
 		backendHelp:
 			"Enter Open | 1-4 Category | S Save | R Reset | Q Back (No Save)",
+		syncCenterTitle: "Sync Center",
+		syncCenterSubtitle:
+			"Inspect source paths, watcher status, and one-way preview semantics before applying sync",
+		syncCenterHelp: "Enter Select | A Apply | R Refresh | Q Back",
+		syncCenterOverviewHeading: "Sync Overview",
+		syncCenterActionsHeading: "Actions",
+		syncCenterRefresh: "Refresh Preview",
+		syncCenterApply: "Apply Preview To Target",
+		syncCenterBack: "Back",
 		backendCategoriesHeading: "Categories",
 		backendCategoryTitle: "Backend Category",
 		backendCategoryHelp:
diff --git a/test/accounts-edge.test.ts b/test/accounts-edge.test.ts
index 31c34b0..8bf8895 100644
--- a/test/accounts-edge.test.ts
+++ b/test/accounts-edge.test.ts
@@ -5,6 +5,8 @@ const mockLoadAccounts = vi.fn();
 const mockSaveAccounts = vi.fn();
 const mockLoadCodexCliState = vi.fn();
 const mockSyncAccountStorageFromCodexCli = vi.fn();
+const mockCommitPendingCodexCliSyncRun = vi.fn();
+const mockCommitCodexCliSyncRunFailure = vi.fn();
 const mockSetCodexCliActiveSelection = vi.fn();
 const mockSelectHybridAccount = vi.fn();
 
@@ -27,6 +29,8 @@ vi.mock("../lib/codex-cli/state.js", async (importOriginal) => {
 });
 
 vi.mock("../lib/codex-cli/sync.js", () => ({
+  commitPendingCodexCliSyncRun: mockCommitPendingCodexCliSyncRun,
+  commitCodexCliSyncRunFailure: mockCommitCodexCliSyncRunFailure,
   syncAccountStorageFromCodexCli: mockSyncAccountStorageFromCodexCli,
 }));
 
@@ -79,6 +83,8 @@ async function importAccountsModule() {
 describe("accounts edge branches", () => {
   beforeEach(() => {
     vi.clearAllMocks();
+    mockCommitPendingCodexCliSyncRun.mockReset();
+    mockCommitCodexCliSyncRunFailure.mockReset();
     mockLoadAccounts.mockResolvedValue(null);
     mockSaveAccounts.mockResolvedValue(undefined);
     mockLoadCodexCliState.mockResolvedValue(null);
diff --git a/test/accounts-load-from-disk.test.ts b/test/accounts-load-from-disk.test.ts
index 61c2b8b..defc840 100644
--- a/test/accounts-load-from-disk.test.ts
+++ b/test/accounts-load-from-disk.test.ts
@@ -1,6 +1,14 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
 import { AccountManager } from "../lib/accounts.js";
 
+const {
+  commitPendingCodexCliSyncRunMock,
+  commitCodexCliSyncRunFailureMock,
+} = vi.hoisted(() => ({
+  commitPendingCodexCliSyncRunMock: vi.fn(),
+  commitCodexCliSyncRunFailureMock: vi.fn(),
+}));
+
 vi.mock("../lib/storage.js", async (importOriginal) => {
   const actual = await importOriginal<typeof import("../lib/storage.js")>();
   return {
@@ -11,6 +19,8 @@ vi.mock("../lib/storage.js", async (importOriginal) => {
 });
 
 vi.mock("../lib/codex-cli/sync.js", () => ({
+  commitPendingCodexCliSyncRun: commitPendingCodexCliSyncRunMock,
+  commitCodexCliSyncRunFailure: commitCodexCliSyncRunFailureMock,
   syncAccountStorageFromCodexCli: vi.fn(),
 }));
 
@@ -30,11 +40,14 @@ import { setCodexCliActiveSelection } from "../lib/codex-cli/writer.js";
 describe("AccountManager loadFromDisk", () => {
   beforeEach(() => {
     vi.clearAllMocks();
+    commitPendingCodexCliSyncRunMock.mockReset();
+    commitCodexCliSyncRunFailureMock.mockReset();
     vi.mocked(loadAccounts).mockResolvedValue(null);
     vi.mocked(saveAccounts).mockResolvedValue(undefined);
     vi.mocked(syncAccountStorageFromCodexCli).mockResolvedValue({
       changed: false,
       storage: null,
+      pendingRun: null,
     });
     vi.mocked(loadCodexCliState).mockResolvedValue(null);
     vi.mocked(setCodexCliActiveSelection).mockResolvedValue(undefined);
@@ -60,6 +73,7 @@ describe("AccountManager loadFromDisk", () => {
     vi.mocked(syncAccountStorageFromCodexCli).mockResolvedValue({
       changed: true,
       storage: synced,
+      pendingRun: null,
     });
 
     const manager = await AccountManager.loadFromDisk();
@@ -80,6 +94,7 @@ describe("AccountManager loadFromDisk", () => {
     vi.mocked(syncAccountStorageFromCodexCli).mockResolvedValue({
       changed: true,
       storage: synced,
+      pendingRun: null,
     });
     vi.mocked(saveAccounts).mockRejectedValueOnce(new Error("forced persist failure"));
 
diff --git a/test/accounts.test.ts b/test/accounts.test.ts
index 5cf8f61..444e430 100644
--- a/test/accounts.test.ts
+++ b/test/accounts.test.ts
@@ -1,4 +1,17 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+const {
+  loadAccountsMock,
+  syncAccountStorageFromCodexCliMock,
+  commitPendingCodexCliSyncRunMock,
+  commitCodexCliSyncRunFailureMock,
+  loadCodexCliStateMock,
+} = vi.hoisted(() => ({
+  loadAccountsMock: vi.fn(),
+  syncAccountStorageFromCodexCliMock: vi.fn(),
+  commitPendingCodexCliSyncRunMock: vi.fn(),
+  commitCodexCliSyncRunFailureMock: vi.fn(),
+  loadCodexCliStateMock: vi.fn(),
+}));
 import {
   AccountManager,
   extractAccountEmail,
@@ -17,10 +30,47 @@ vi.mock("../lib/storage.js", async (importOriginal) => {
   const actual = await importOriginal<typeof import("../lib/storage.js")>();
   return {
     ...actual,
+    loadAccounts: loadAccountsMock,
     saveAccounts: vi.fn().mockResolvedValue(undefined),
   };
 });
 
+vi.mock("../lib/codex-cli/sync.js", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("../lib/codex-cli/sync.js")>();
+  return {
+    ...actual,
+    commitCodexCliSyncRunFailure: commitCodexCliSyncRunFailureMock,
+    commitPendingCodexCliSyncRun: commitPendingCodexCliSyncRunMock,
+    syncAccountStorageFromCodexCli: syncAccountStorageFromCodexCliMock,
+  };
+});
+
+vi.mock("../lib/codex-cli/state.js", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("../lib/codex-cli/state.js")>();
+  return {
+    ...actual,
+    loadCodexCliState: loadCodexCliStateMock,
+  };
+});
+
+beforeEach(async () => {
+  const { saveAccounts } = await import("../lib/storage.js");
+  loadAccountsMock.mockReset();
+  syncAccountStorageFromCodexCliMock.mockReset();
+  commitPendingCodexCliSyncRunMock.mockReset();
+  commitCodexCliSyncRunFailureMock.mockReset();
+  loadCodexCliStateMock.mockReset();
+  vi.mocked(saveAccounts).mockReset();
+  vi.mocked(saveAccounts).mockResolvedValue(undefined);
+  loadAccountsMock.mockResolvedValue(null);
+  syncAccountStorageFromCodexCliMock.mockResolvedValue({
+    storage: null,
+    changed: false,
+    pendingRun: null,
+  });
+  loadCodexCliStateMock.mockResolvedValue(null);
+});
+
 describe("parseRateLimitReason", () => {
   it("returns quota for quota-related codes", () => {
     expect(parseRateLimitReason("usage_limit_reached")).toBe("quota");
@@ -190,6 +240,119 @@ describe("getAccountIdCandidates", () => {
 });
 
 describe("AccountManager", () => {
+  it("commits a pending Codex CLI sync run only after loadFromDisk persists storage", async () => {
+    const now = Date.now();
+    const stored = {
+      version: 3 as const,
+      activeIndex: 0,
+      accounts: [
+        { refreshToken: "token-1", addedAt: now, lastUsed: now },
+      ],
+    };
+    const syncedStorage = {
+      ...stored,
+      accounts: [
+        ...stored.accounts,
+        { refreshToken: "token-2", addedAt: now + 1, lastUsed: now + 1 },
+      ],
+    };
+    const pendingRun = {
+      revision: 1,
+      run: {
+        outcome: "changed" as const,
+        runAt: now,
+        sourcePath: "/mock/codex/accounts.json",
+        targetPath: "/mock/openai-codex-accounts.json",
+        summary: {
+          sourceAccountCount: 1,
+          targetAccountCountBefore: 1,
+          targetAccountCountAfter: 2,
+          addedAccountCount: 1,
+          updatedAccountCount: 0,
+          unchangedAccountCount: 0,
+          destinationOnlyPreservedCount: 1,
+          selectionChanged: false,
+        },
+      },
+    };
+    loadAccountsMock.mockResolvedValue(stored);
+    syncAccountStorageFromCodexCliMock.mockResolvedValue({
+      storage: syncedStorage,
+      changed: true,
+      pendingRun,
+    });
+
+    const { saveAccounts } = await import("../lib/storage.js");
+    const mockSaveAccounts = vi.mocked(saveAccounts);
+
+    await AccountManager.loadFromDisk();
+
+    expect(mockSaveAccounts).toHaveBeenCalledTimes(1);
+    expect(mockSaveAccounts).toHaveBeenCalledWith(syncedStorage);
+    expect(commitPendingCodexCliSyncRunMock).toHaveBeenCalledTimes(1);
+    expect(commitPendingCodexCliSyncRunMock).toHaveBeenCalledWith(pendingRun);
+    expect(mockSaveAccounts.mock.invocationCallOrder[0]!).toBeLessThan(
+      commitPendingCodexCliSyncRunMock.mock.invocationCallOrder[0]!,
+    );
+    expect(commitCodexCliSyncRunFailureMock).not.toHaveBeenCalled();
+  });
+
+  it("records loadFromDisk save failures as sync-run failures instead of successes", async () => {
+    const now = Date.now();
+    const stored = {
+      version: 3 as const,
+      activeIndex: 0,
+      accounts: [
+        { refreshToken: "token-1", addedAt: now, lastUsed: now },
+      ],
+    };
+    const syncedStorage = {
+      ...stored,
+      accounts: [
+        ...stored.accounts,
+        { refreshToken: "token-2", addedAt: now + 1, lastUsed: now + 1 },
+      ],
+    };
+    const pendingRun = {
+      revision: 2,
+      run: {
+        outcome: "changed" as const,
+        runAt: now,
+        sourcePath: "/mock/codex/accounts.json",
+        targetPath: "/mock/openai-codex-accounts.json",
+        summary: {
+          sourceAccountCount: 1,
+          targetAccountCountBefore: 1,
+          targetAccountCountAfter: 2,
+          addedAccountCount: 1,
+          updatedAccountCount: 0,
+          unchangedAccountCount: 0,
+          destinationOnlyPreservedCount: 1,
+          selectionChanged: false,
+        },
+      },
+    };
+    const saveError = new Error("save busy");
+    loadAccountsMock.mockResolvedValue(stored);
+    syncAccountStorageFromCodexCliMock.mockResolvedValue({
+      storage: syncedStorage,
+      changed: true,
+      pendingRun,
+    });
+
+    const { saveAccounts } = await import("../lib/storage.js");
+    const mockSaveAccounts = vi.mocked(saveAccounts);
+    mockSaveAccounts.mockRejectedValueOnce(saveError);
+
+    await AccountManager.loadFromDisk();
+
+    expect(commitPendingCodexCliSyncRunMock).not.toHaveBeenCalled();
+    expect(commitCodexCliSyncRunFailureMock).toHaveBeenCalledWith(
+      pendingRun,
+      saveError,
+    );
+  });
+
   it("seeds from fallback auth when no storage exists", () => {
     const auth: OAuthAuthDetails = {
       type: "oauth",
diff --git a/test/codex-cli-sync.test.ts b/test/codex-cli-sync.test.ts
index 7d414a5..5509262 100644
--- a/test/codex-cli-sync.test.ts
+++ b/test/codex-cli-sync.test.ts
@@ -1,14 +1,22 @@
-import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { mkdtemp, readFile, rm, utimes, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import type { AccountStorageV3 } from "../lib/storage.js";
+import * as storageModule from "../lib/storage.js";
 import * as codexCliState from "../lib/codex-cli/state.js";
 import { clearCodexCliStateCache } from "../lib/codex-cli/state.js";
 import {
+	__resetLastCodexCliSyncRunForTests,
+	applyCodexCliSyncToStorage,
+	commitCodexCliSyncRunFailure,
+	commitPendingCodexCliSyncRun,
 	getActiveSelectionForFamily,
+	getLastCodexCliSyncRun,
+	previewCodexCliSync,
 	syncAccountStorageFromCodexCli,
 } from "../lib/codex-cli/sync.js";
+import * as writerModule from "../lib/codex-cli/writer.js";
 import { setCodexCliActiveSelection } from "../lib/codex-cli/writer.js";
 import { MODEL_FAMILIES } from "../lib/prompts/codex.js";
 
@@ -40,6 +48,7 @@ describe("codex-cli sync", () => {
 	let accountsPath: string;
 	let authPath: string;
 	let configPath: string;
+	let targetStoragePath: string;
 	let previousPath: string | undefined;
 	let previousAuthPath: string | undefined;
 	let previousConfigPath: string | undefined;
@@ -57,16 +66,21 @@ describe("codex-cli sync", () => {
 		accountsPath = join(tempDir, "accounts.json");
 		authPath = join(tempDir, "auth.json");
 		configPath = join(tempDir, "config.toml");
+		targetStoragePath = join(tempDir, "openai-codex-accounts.json");
 		process.env.CODEX_CLI_ACCOUNTS_PATH = accountsPath;
 		process.env.CODEX_CLI_AUTH_PATH = authPath;
 		process.env.CODEX_CLI_CONFIG_PATH = configPath;
 		process.env.CODEX_MULTI_AUTH_SYNC_CODEX_CLI = "1";
 		process.env.CODEX_MULTI_AUTH_ENFORCE_CLI_FILE_AUTH_STORE = "1";
+		vi.spyOn(storageModule, "getStoragePath").mockReturnValue(targetStoragePath);
 		clearCodexCliStateCache();
+		__resetLastCodexCliSyncRunForTests();
 	});
 
 	afterEach(async () => {
+		vi.restoreAllMocks();
 		clearCodexCliStateCache();
+		__resetLastCodexCliSyncRunForTests();
 		if (previousPath === undefined) delete process.env.CODEX_CLI_ACCOUNTS_PATH;
 		else process.env.CODEX_CLI_ACCOUNTS_PATH = previousPath;
 		if (previousAuthPath === undefined) delete process.env.CODEX_CLI_AUTH_PATH;
@@ -237,6 +251,1060 @@ describe("codex-cli sync", () => {
 		expect(result.storage?.activeIndex).toBe(0);
 	});
 
+	it("previews one-way manual sync changes without mutating canonical storage", async () => {
+		await writeFile(
+			accountsPath,
+			JSON.stringify(
+				{
+					activeAccountId: "acc_c",
+					accounts: [
+						{
+							accountId: "acc_a",
+							email: "a@example.com",
+							auth: {
+								tokens: {
+									access_token: "access-a-new",
+									refresh_token: "refresh-a",
+								},
+							},
+						},
+						{
+							accountId: "acc_c",
+							email: "c@example.com",
+							auth: {
+								tokens: {
+									access_token: "access-c",
+									refresh_token: "refresh-c",
+								},
+							},
+						},
+					],
+				},
+				null,
+				2,
+			),
+			"utf-8",
+		);
+
+		const current: AccountStorageV3 = {
+			version: 3,
+			accounts: [
+				{
+					accountId: "acc_a",
+					email: "a@example.com",
+					refreshToken: "refresh-a",
+					accessToken: "access-a-old",
+					addedAt: 1,
+					lastUsed: 1,
+				},
+				{
+					accountId: "acc_b",
+					email: "b@example.com",
+					refreshToken: "refresh-b",
+					addedAt: 1,
+					lastUsed: 1,
+				},
+			],
+			activeIndex: 1,
+			activeIndexByFamily: { codex: 1 },
+		};
+
+		const preview = await previewCodexCliSync(current, {
+			forceRefresh: true,
+			storageBackupEnabled: true,
+		});
+
+		expect(preview.status).toBe("ready");
+		expect(preview.sourcePath).toBe(accountsPath);
+		expect(preview.summary.addedAccountCount).toBe(1);
+		expect(preview.summary.updatedAccountCount).toBe(1);
+		expect(preview.summary.destinationOnlyPreservedCount).toBe(1);
+		expect(preview.summary.selectionChanged).toBe(true);
+		expect(preview.backup.enabled).toBe(true);
+		expect(preview.backup.rollbackPaths).toContain(`${preview.targetPath}.bak`);
+		expect(preview.backup.rollbackPaths).toContain(`${preview.targetPath}.wal`);
+		expect(current.accounts).toHaveLength(2);
+	});
+
+	it("skips ambiguous duplicate-email source matches instead of overwriting a local account", async () => {
+		await writeFile(
+			accountsPath,
+			JSON.stringify(
+				{
+					accounts: [
+						{
+							email: "dup@example.com",
+							auth: {
+								tokens: {
+									access_token: "access-new",
+									refresh_token: "refresh-new",
+								},
+							},
+						},
+					],
+				},
+				null,
+				2,
+			),
+			"utf-8",
+		);
+
+		const current: AccountStorageV3 = {
+			version: 3,
+			accounts: [
+				{
+					accountId: "acc_a",
+					email: "dup@example.com",
+					refreshToken: "refresh-a",
+					accessToken: "access-a",
+					addedAt: 1,
+					lastUsed: 1,
+				},
+				{
+					accountId: "acc_b",
+					email: "dup@example.com",
+					refreshToken: "refresh-b",
+					accessToken: "access-b",
+					addedAt: 1,
+					lastUsed: 1,
+				},
+			],
+			activeIndex: 1,
+			activeIndexByFamily: { codex: 1 },
+		};
+
+		const result = await applyCodexCliSyncToStorage(current, {
+			forceRefresh: true,
+		});
+
+		expect(result.changed).toBe(false);
+		expect(result.pendingRun).toBeNull();
+		expect(result.storage?.accounts).toEqual(current.accounts);
+	});
+
+	it("skips ambiguous duplicate-accountId source matches instead of overwriting a local account", async () => {
+		await writeFile(
+			accountsPath,
+			JSON.stringify(
+				{
+					accounts: [
+						{
+							accountId: "shared-id",
+							auth: {
+								tokens: {
+									access_token: "access-new",
+									refresh_token: "refresh-new",
+								},
+							},
+						},
+					],
+				},
+				null,
+				2,
+			),
+			"utf-8",
+		);
+
+		const current: AccountStorageV3 = {
+			version: 3,
+			accounts: [
+				{
+					accountId: "shared-id",
+					email: "a@example.com",
+					refreshToken: "refresh-a",
+					accessToken: "access-a",
+					addedAt: 1,
+					lastUsed: 1,
+				},
+				{
+					accountId: "shared-id",
+					email: "b@example.com",
+					refreshToken: "refresh-b",
+					accessToken: "access-b",
+					addedAt: 1,
+					lastUsed: 1,
+				},
+			],
+			activeIndex: 1,
+			activeIndexByFamily: { codex: 1 },
+		};
+
+		const result = await applyCodexCliSyncToStorage(current, {
+			forceRefresh: true,
+		});
+
+		expect(result.changed).toBe(false);
+		expect(result.pendingRun).toBeNull();
+		expect(result.storage?.accounts).toEqual(current.accounts);
+	});
+
+	it("reports skipped ambiguous source snapshots in the preview summary", async () => {
+		await writeFile(
+			accountsPath,
+			JSON.stringify(
+				{
+					accounts: [
+						{
+							accountId: "shared-id",
+							auth: {
+								tokens: {
+									access_token: "access-new",
+									refresh_token: "refresh-new",
+								},
+							},
+						},
+					],
+				},
+				null,
+				2,
+			),
+			"utf-8",
+		);
+
+		const current: AccountStorageV3 = {
+			version: 3,
+			accounts: [
+				{
+					accountId: "shared-id",
+					email: "first@example.com",
+					refreshToken: "refresh-first",
+					addedAt: 1,
+					lastUsed: 1,
+				},
+				{
+					accountId: "shared-id",
+					email: "second@example.com",
+					refreshToken: "refresh-second",
+					addedAt: 1,
+					lastUsed: 1,
+				},
+			],
+			activeIndex: 0,
+			activeIndexByFamily: { codex: 0 },
+		};
+
+		const preview = await previewCodexCliSync(current, {
+			forceRefresh: true,
+		});
+
+		expect(preview.status).toBe("noop");
+		expect(preview.summary.sourceAccountCount).toBe(1);
+		expect(preview.statusDetail).toContain("1 source account skipped");
+	});
+
+	it("preserves the current selection when Codex CLI source has no active marker", async () => {
+		await writeFile(
+			accountsPath,
+			JSON.stringify(
+				{
+					accounts: [
+						{
+							accountId: "acc_a",
+							email: "a@example.com",
+							auth: {
+								tokens: {
+									access_token: "access-a",
+									refresh_token: "refresh-a",
+								},
+							},
+						},
+					],
+				},
+				null,
+				2,
+			),
+			"utf-8",
+		);
+
+		const current: AccountStorageV3 = {
+			version: 3,
+			accounts: [
+				{
+					accountId: "acc_a",
+					accountIdSource: "token",
+					email: "a@example.com",
+					refreshToken: "refresh-a",
+					accessToken: "access-a",
+					addedAt: 1,
+					lastUsed: 1,
+				},
+				{
+					accountId: "acc_b",
+					accountIdSource: "token",
+					email: "b@example.com",
+					refreshToken: "refresh-b",
+					accessToken: "access-b",
+					addedAt: 1,
+					lastUsed: 1,
+				},
+			],
+			activeIndex: 1,
+			activeIndexByFamily: { codex: 1 },
+		};
+
+		const preview = await previewCodexCliSync(current, {
+			forceRefresh: true,
+		});
+
+		expect(preview.status).toBe("noop");
+		expect(preview.summary.selectionChanged).toBe(false);
+	});
+
+	it("preserves a newer persisted local selection after restart", async () => {
+		await writeFile(
+			accountsPath,
+			JSON.stringify(
+				{
+					activeAccountId: "acc_a",
+					accounts: [
+						{
+							accountId: "acc_a",
+							email: "a@example.com",
+							auth: {
+								tokens: {
+									access_token: "access-a",
+									refresh_token: "refresh-a",
+								},
+							},
+						},
+						{
+							accountId: "acc_b",
+							email: "b@example.com",
+							auth: {
+								tokens: {
+									access_token: "access-b",
+									refresh_token: "refresh-b",
+								},
+							},
+						},
+					],
+				},
+				null,
+				2,
+			),
+			"utf-8",
+		);
+
+		const sourceTime = new Date("2026-03-13T00:00:00.000Z");
+		const targetTime = new Date("2026-03-13T00:00:05.000Z");
+		await utimes(accountsPath, sourceTime, sourceTime);
+		await writeFile(targetStoragePath, "{\"version\":3}", "utf-8");
+		await utimes(targetStoragePath, targetTime, targetTime);
+
+		vi.spyOn(storageModule, "getLastAccountsSaveTimestamp").mockReturnValue(0);
+		vi.spyOn(writerModule, "getLastCodexCliSelectionWriteTimestamp").mockReturnValue(
+			0,
+		);
+
+		const current: AccountStorageV3 = {
+			version: 3,
+			accounts: [
+				{
+					accountId: "acc_a",
+					accountIdSource: "token",
+					email: "a@example.com",
+					refreshToken: "refresh-a",
+					accessToken: "access-a",
+					addedAt: 1,
+					lastUsed: 1,
+				},
+				{
+					accountId: "acc_b",
+					accountIdSource: "token",
+					email: "b@example.com",
+					refreshToken: "refresh-b",
+					accessToken: "access-b",
+					addedAt: 1,
+					lastUsed: 1,
+				},
+			],
+			activeIndex: 1,
+			activeIndexByFamily: { codex: 1 },
+		};
+
+		const preview = await previewCodexCliSync(current, {
+			forceRefresh: true,
+		});
+
+		expect(preview.status).toBe("noop");
+		expect(preview.summary.selectionChanged).toBe(false);
+	});
+
+	it("preserves the local selection when the persisted target timestamp is temporarily unreadable", async () => {
+		await writeFile(
+			accountsPath,
+			JSON.stringify(
+				{
+					activeAccountId: "acc_a",
+					accounts: [
+						{
+							accountId: "acc_a",
+							email: "a@example.com",
+							auth: {
+								tokens: {
+									access_token: "access-a",
+									refresh_token: "refresh-a",
+								},
+							},
+						},
+						{
+							accountId: "acc_b",
+							email: "b@example.com",
+							auth: {
+								tokens: {
+									access_token: "access-b",
+									refresh_token: "refresh-b",
+								},
+							},
+						},
+					],
+				},
+				null,
+				2,
+			),
+			"utf-8",
+		);
+
+		vi.spyOn(storageModule, "getLastAccountsSaveTimestamp").mockReturnValue(0);
+		vi.spyOn(writerModule, "getLastCodexCliSelectionWriteTimestamp").mockReturnValue(
+			0,
+		);
+		vi.spyOn(storageModule, "getStoragePath").mockReturnValue("\0busy-target");
+
+		const current: AccountStorageV3 = {
+			version: 3,
+			accounts: [
+				{
+					accountId: "acc_a",
+					accountIdSource: "token",
+					email: "a@example.com",
+					refreshToken: "refresh-a",
+					accessToken: "access-a",
+					addedAt: 1,
+					lastUsed: 1,
+				},
+				{
+					accountId: "acc_b",
+					accountIdSource: "token",
+					email: "b@example.com",
+					refreshToken: "refresh-b",
+					accessToken: "access-b",
+					addedAt: 1,
+					lastUsed: 1,
+				},
+			],
+			activeIndex: 1,
+			activeIndexByFamily: { codex: 1 },
+		};
+
+		const preview = await previewCodexCliSync(current, {
+			forceRefresh: true,
+		});
+
+		expect(preview.status).toBe("noop");
+		expect(preview.summary.selectionChanged).toBe(false);
+	});
+
+	it.each(["EBUSY", "EPERM"] as const)(
+		"preserves the local selection when reading the persisted target timestamp fails with %s",
+		async (code) => {
+			await writeFile(
+				accountsPath,
+				JSON.stringify(
+					{
+						activeAccountId: "acc_a",
+						accounts: [
+							{
+								accountId: "acc_a",
+								email: "a@example.com",
+								auth: {
+									tokens: {
+										access_token: "access-a",
+										refresh_token: "refresh-a",
+									},
+								},
+							},
+							{
+								accountId: "acc_b",
+								email: "b@example.com",
+								auth: {
+									tokens: {
+										access_token: "access-b",
+										refresh_token: "refresh-b",
+									},
+								},
+							},
+						],
+					},
+					null,
+					2,
+				),
+				"utf-8",
+			);
+
+			vi.spyOn(storageModule, "getLastAccountsSaveTimestamp").mockReturnValue(0);
+			vi.spyOn(
+				writerModule,
+				"getLastCodexCliSelectionWriteTimestamp",
+			).mockReturnValue(0);
+			vi.spyOn(storageModule, "getStoragePath").mockReturnValue(targetStoragePath);
+			const statError = new Error(`${code.toLowerCase()} target`) as NodeJS.ErrnoException;
+			statError.code = code;
+			const nodeFs = await import("node:fs");
+			const originalStat = nodeFs.promises.stat.bind(nodeFs.promises);
+			const statSpy = vi
+				.spyOn(nodeFs.promises, "stat")
+				.mockImplementation(async (...args: Parameters<typeof originalStat>) => {
+					if (args[0] === targetStoragePath) {
+						throw statError;
+					}
+					return originalStat(...args);
+				});
+
+			const current: AccountStorageV3 = {
+				version: 3,
+				accounts: [
+					{
+						accountId: "acc_a",
+						accountIdSource: "token",
+						email: "a@example.com",
+						refreshToken: "refresh-a",
+						accessToken: "access-a",
+						addedAt: 1,
+						lastUsed: 1,
+					},
+					{
+						accountId: "acc_b",
+						accountIdSource: "token",
+						email: "b@example.com",
+						refreshToken: "refresh-b",
+						accessToken: "access-b",
+						addedAt: 1,
+						lastUsed: 1,
+					},
+				],
+				activeIndex: 1,
+				activeIndexByFamily: { codex: 1 },
+			};
+
+			try {
+				const preview = await previewCodexCliSync(current, {
+					forceRefresh: true,
+				});
+
+				expect(preview.status).toBe("noop");
+				expect(preview.summary.selectionChanged).toBe(false);
+			} finally {
+				statSpy.mockRestore();
+			}
+		},
+	);
+
+	it("records a changed manual sync only after the caller commits persistence", async () => {
+		await writeFile(
+			accountsPath,
+			JSON.stringify(
+				{
+					activeAccountId: "acc_b",
+					accounts: [
+						{
+							accountId: "acc_b",
+							email: "b@example.com",
+							auth: {
+								tokens: {
+									access_token: "access-b",
+									refresh_token: "refresh-b",
+								},
+							},
+						},
+					],
+				},
+				null,
+				2,
+			),
+			"utf-8",
+		);
+
+		const current: AccountStorageV3 = {
+			version: 3,
+			accounts: [
+				{
+					accountId: "acc_a",
+					email: "a@example.com",
+					refreshToken: "refresh-a",
+					addedAt: 1,
+					lastUsed: 1,
+				},
+			],
+			activeIndex: 0,
+			activeIndexByFamily: { codex: 0 },
+		};
+
+		const result = await applyCodexCliSyncToStorage(current);
+		expect(result.changed).toBe(true);
+		expect(result.pendingRun).not.toBeNull();
+		expect(result.storage?.accounts).toHaveLength(2);
+		expect(getLastCodexCliSyncRun()).toBeNull();
+
+		commitPendingCodexCliSyncRun(result.pendingRun);
+
+		const lastRun = getLastCodexCliSyncRun();
+		expect(lastRun?.outcome).toBe("changed");
+		expect(lastRun?.sourcePath).toBe(accountsPath);
+		expect(lastRun?.summary.addedAccountCount).toBe(1);
+		expect(lastRun?.summary.destinationOnlyPreservedCount).toBe(1);
+	});
+
+	it("re-reads Codex CLI state on apply when forceRefresh is requested", async () => {
+		await writeFile(
+			accountsPath,
+			JSON.stringify(
+				{
+					activeAccountId: "acc_b",
+					accounts: [
+						{
+							accountId: "acc_b",
+							email: "b@example.com",
+							auth: {
+								tokens: {
+									access_token: "access-b",
+									refresh_token: "refresh-b",
+								},
+							},
+						},
+					],
+				},
+				null,
+				2,
+			),
+			"utf-8",
+		);
+
+		const current: AccountStorageV3 = {
+			version: 3,
+			accounts: [
+				{
+					accountId: "acc_a",
+					email: "a@example.com",
+					refreshToken: "refresh-a",
+					addedAt: 1,
+					lastUsed: 1,
+				},
+			],
+			activeIndex: 0,
+			activeIndexByFamily: { codex: 0 },
+		};
+
+		await previewCodexCliSync(current, { forceRefresh: true });
+
+		await writeFile(
+			accountsPath,
+			JSON.stringify(
+				{
+					activeAccountId: "acc_c",
+					accounts: [
+						{
+							accountId: "acc_b",
+							email: "b@example.com",
+							auth: {
+								tokens: {
+									access_token: "access-b",
+									refresh_token: "refresh-b",
+								},
+							},
+						},
+						{
+							accountId: "acc_c",
+							email: "c@example.com",
+							auth: {
+								tokens: {
+									access_token: "access-c",
+									refresh_token: "refresh-c",
+								},
+							},
+						},
+					],
+				},
+				null,
+				2,
+			),
+			"utf-8",
+		);
+
+		const loadSpy = vi.spyOn(codexCliState, "loadCodexCliState");
+		try {
+			const result = await applyCodexCliSyncToStorage(current, {
+				forceRefresh: true,
+			});
+			expect(loadSpy).toHaveBeenCalledWith(
+				expect.objectContaining({ forceRefresh: true }),
+			);
+			expect(result.changed).toBe(true);
+			expect(result.storage?.accounts.map((account) => account.accountId)).toEqual([
+				"acc_a",
+				"acc_b",
+				"acc_c",
+			]);
+			expect(result.storage?.activeIndex).toBe(2);
+		} finally {
+			loadSpy.mockRestore();
+		}
+	});
+
+	it("preserves explicit per-family selections when Codex CLI updates the global selection", async () => {
+		const alternateFamily = MODEL_FAMILIES.find((family) => family !== "codex");
+		expect(alternateFamily).toBeDefined();
+		if (!alternateFamily) {
+			return;
+		}
+
+		await writeFile(
+			accountsPath,
+			JSON.stringify(
+				{
+					activeAccountId: "acc_b",
+					accounts: [
+						{
+							accountId: "acc_a",
+							email: "a@example.com",
+							auth: {
+								tokens: {
+									access_token: "access-a",
+									refresh_token: "refresh-a",
+								},
+							},
+						},
+						{
+							accountId: "acc_b",
+							email: "b@example.com",
+							auth: {
+								tokens: {
+									access_token: "access-b",
+									refresh_token: "refresh-b",
+								},
+							},
+						},
+						{
+							accountId: "acc_c",
+							email: "c@example.com",
+							auth: {
+								tokens: {
+									access_token: "access-c",
+									refresh_token: "refresh-c",
+								},
+							},
+						},
+					],
+				},
+				null,
+				2,
+			),
+			"utf-8",
+		);
+
+		const current: AccountStorageV3 = {
+			version: 3,
+			accounts: [
+				{
+					accountId: "acc_a",
+					email: "a@example.com",
+					refreshToken: "refresh-a",
+					addedAt: 1,
+					lastUsed: 1,
+				},
+				{
+					accountId: "acc_b",
+					email: "b@example.com",
+					refreshToken: "refresh-b",
+					addedAt: 1,
+					lastUsed: 1,
+				},
+				{
+					accountId: "acc_c",
+					email: "c@example.com",
+					refreshToken: "refresh-c",
+					addedAt: 1,
+					lastUsed: 1,
+				},
+			],
+			activeIndex: 0,
+			activeIndexByFamily: {
+				codex: 0,
+				[alternateFamily]: 2,
+			},
+		};
+
+		const result = await applyCodexCliSyncToStorage(current, {
+			forceRefresh: true,
+		});
+
+		expect(result.changed).toBe(true);
+		expect(result.storage?.activeIndex).toBe(1);
+		expect(result.storage?.activeIndexByFamily?.codex).toBe(1);
+		expect(result.storage?.activeIndexByFamily?.[alternateFamily]).toBe(2);
+	});
+
+	it("forces a fresh Codex CLI state read on apply when forceRefresh is omitted", async () => {
+		await writeFile(
+			accountsPath,
+			JSON.stringify(
+				{
+					activeAccountId: "acc_b",
+					accounts: [
+						{
+							accountId: "acc_b",
+							email: "b@example.com",
+							auth: {
+								tokens: {
+									access_token: "access-b",
+									refresh_token: "refresh-b",
+								},
+							},
+						},
+					],
+				},
+				null,
+				2,
+			),
+			"utf-8",
+		);
+
+		const current: AccountStorageV3 = {
+			version: 3,
+			accounts: [
+				{
+					accountId: "acc_a",
+					email: "a@example.com",
+					refreshToken: "refresh-a",
+					addedAt: 1,
+					lastUsed: 1,
+				},
+			],
+			activeIndex: 0,
+			activeIndexByFamily: { codex: 0 },
+		};
+
+		await previewCodexCliSync(current, { forceRefresh: true });
+
+		await writeFile(
+			accountsPath,
+			JSON.stringify(
+				{
+					activeAccountId: "acc_c",
+					accounts: [
+						{
+							accountId: "acc_b",
+							email: "b@example.com",
+							auth: {
+								tokens: {
+									access_token: "access-b",
+									refresh_token: "refresh-b",
+								},
+							},
+						},
+						{
+							accountId: "acc_c",
+							email: "c@example.com",
+							auth: {
+								tokens: {
+									access_token: "access-c",
+									refresh_token: "refresh-c",
+								},
+							},
+						},
+					],
+				},
+				null,
+				2,
+			),
+			"utf-8",
+		);
+
+		const loadSpy = vi.spyOn(codexCliState, "loadCodexCliState");
+		try {
+			const result = await applyCodexCliSyncToStorage(current);
+			expect(loadSpy).toHaveBeenCalledWith(
+				expect.objectContaining({ forceRefresh: true }),
+			);
+			expect(result.changed).toBe(true);
+			expect(result.storage?.accounts.map((account) => account.accountId)).toEqual([
+				"acc_a",
+				"acc_b",
+				"acc_c",
+			]);
+			expect(result.storage?.activeIndex).toBe(2);
+		} finally {
+			loadSpy.mockRestore();
+		}
+	});
+
+	it("returns isolated pending runs for concurrent apply attempts", async () => {
+		await writeFile(
+			accountsPath,
+			JSON.stringify(
+				{
+					activeAccountId: "acc_b",
+					accounts: [
+						{
+							accountId: "acc_b",
+							email: "b@example.com",
+							auth: {
+								tokens: {
+									access_token: "access-b",
+									refresh_token: "refresh-b",
+								},
+							},
+						},
+					],
+				},
+				null,
+				2,
+			),
+			"utf-8",
+		);
+
+		const current: AccountStorageV3 = {
+			version: 3,
+			accounts: [
+				{
+					accountId: "acc_a",
+					email: "a@example.com",
+					refreshToken: "refresh-a",
+					addedAt: 1,
+					lastUsed: 1,
+				},
+			],
+			activeIndex: 0,
+			activeIndexByFamily: { codex: 0 },
+		};
+
+		const [first, second] = await Promise.all([
+			applyCodexCliSyncToStorage(current),
+			applyCodexCliSyncToStorage(current),
+		]);
+
+		expect(first.changed).toBe(true);
+		expect(second.changed).toBe(true);
+		expect(first.pendingRun).not.toBeNull();
+		expect(second.pendingRun).not.toBeNull();
+		expect(first.pendingRun?.revision).not.toBe(second.pendingRun?.revision);
+		expect(first.storage?.accounts.map((account) => account.accountId)).toEqual([
+			"acc_a",
+			"acc_b",
+		]);
+		expect(second.storage?.accounts.map((account) => account.accountId)).toEqual([
+			"acc_a",
+			"acc_b",
+		]);
+		expect(getLastCodexCliSyncRun()).toBeNull();
+	});
+
+	it("records a manual sync save failure over a pending changed run", async () => {
+		await writeFile(
+			accountsPath,
+			JSON.stringify(
+				{
+					activeAccountId: "acc_b",
+					accounts: [
+						{
+							accountId: "acc_b",
+							email: "b@example.com",
+							auth: {
+								tokens: {
+									access_token: "access-b",
+									refresh_token: "refresh-b",
+								},
+							},
+						},
+					],
+				},
+				null,
+				2,
+			),
+			"utf-8",
+		);
+
+		const current: AccountStorageV3 = {
+			version: 3,
+			accounts: [
+				{
+					accountId: "acc_a",
+					email: "a@example.com",
+					refreshToken: "refresh-a",
+					addedAt: 1,
+					lastUsed: 1,
+				},
+			],
+			activeIndex: 0,
+			activeIndexByFamily: { codex: 0 },
+		};
+
+		const result = await applyCodexCliSyncToStorage(current);
+		expect(result.pendingRun).not.toBeNull();
+
+		commitCodexCliSyncRunFailure(result.pendingRun, new Error("save busy"));
+
+		const lastRun = getLastCodexCliSyncRun();
+		expect(lastRun?.outcome).toBe("error");
+		expect(lastRun?.message).toBe("save busy");
+		expect(lastRun?.summary.addedAccountCount).toBe(1);
+	});
+
+	it("ignores a duplicate sync-run publish for the same revision", async () => {
+		await writeFile(
+			accountsPath,
+			JSON.stringify(
+				{
+					activeAccountId: "acc_b",
+					accounts: [
+						{
+							accountId: "acc_b",
+							email: "b@example.com",
+							auth: {
+								tokens: {
+									access_token: "access-b",
+									refresh_token: "refresh-b",
+								},
+							},
+						},
+					],
+				},
+				null,
+				2,
+			),
+			"utf-8",
+		);
+
+		const current: AccountStorageV3 = {
+			version: 3,
+			accounts: [
+				{
+					accountId: "acc_a",
+					email: "a@example.com",
+					refreshToken: "refresh-a",
+					addedAt: 1,
+					lastUsed: 1,
+				},
+			],
+			activeIndex: 0,
+			activeIndexByFamily: { codex: 0 },
+		};
+
+		const result = await applyCodexCliSyncToStorage(current);
+		expect(result.pendingRun).not.toBeNull();
+
+		commitPendingCodexCliSyncRun(result.pendingRun);
+		const committedRun = getLastCodexCliSyncRun();
+
+		commitCodexCliSyncRunFailure(
+			result.pendingRun,
+			new Error("should not overwrite committed run"),
+		);
+
+		expect(getLastCodexCliSyncRun()).toEqual(committedRun);
+		expect(getLastCodexCliSyncRun()?.outcome).toBe("changed");
+	});
+
 	it("serializes concurrent active-selection writes to keep accounts/auth aligned", async () => {
 		await writeFile(
 			accountsPath,
diff --git a/test/codex-manager-cli.test.ts b/test/codex-manager-cli.test.ts
index 30d4c8c..7e187cc 100644
--- a/test/codex-manager-cli.test.ts
+++ b/test/codex-manager-cli.test.ts
@@ -15,8 +15,27 @@ const loadDashboardDisplaySettingsMock = vi.fn();
 const saveDashboardDisplaySettingsMock = vi.fn();
 const loadQuotaCacheMock = vi.fn();
 const saveQuotaCacheMock = vi.fn();
+const clearQuotaCacheMock = vi.fn();
 const loadPluginConfigMock = vi.fn();
 const savePluginConfigMock = vi.fn();
+const previewCodexCliSyncMock = vi.fn();
+const applyCodexCliSyncToStorageMock = vi.fn();
+const commitPendingCodexCliSyncRunMock = vi.fn();
+const commitCodexCliSyncRunFailureMock = vi.fn();
+const formatRollbackPathsMock = vi.fn((targetPath: string) => [
+	`${targetPath}.bak`,
+	`${targetPath}.bak.1`,
+	`${targetPath}.bak.2`,
+	`${targetPath}.wal`,
+]);
+const getLastCodexCliSyncRunMock = vi.fn();
+const getCodexCliAccountsPathMock = vi.fn(() => "/mock/codex/accounts.json");
+const getCodexCliAuthPathMock = vi.fn(() => "/mock/codex/auth.json");
+const getCodexCliConfigPathMock = vi.fn(() => "/mock/codex/config.toml");
+const clearCodexCliStateCacheMock = vi.fn();
+const isCodexCliSyncEnabledMock = vi.fn(() => true);
+const loadCodexCliStateMock = vi.fn();
+const getLastLiveAccountSyncSnapshotMock = vi.fn();
 const selectMock = vi.fn();
 const deleteSavedAccountsMock = vi.fn();
 const resetLocalStateMock = vi.fn();
@@ -116,6 +135,28 @@ vi.mock("../lib/codex-cli/writer.js", () => ({
 	setCodexCliActiveSelection: setCodexCliActiveSelectionMock,
 }));
 
+vi.mock("../lib/codex-cli/sync.js", () => ({
+	applyCodexCliSyncToStorage: applyCodexCliSyncToStorageMock,
+	commitCodexCliSyncRunFailure: commitCodexCliSyncRunFailureMock,
+	commitPendingCodexCliSyncRun: commitPendingCodexCliSyncRunMock,
+	formatRollbackPaths: formatRollbackPathsMock,
+	getLastCodexCliSyncRun: getLastCodexCliSyncRunMock,
+	previewCodexCliSync: previewCodexCliSyncMock,
+}));
+
+vi.mock("../lib/codex-cli/state.js", () => ({
+	clearCodexCliStateCache: clearCodexCliStateCacheMock,
+	getCodexCliAccountsPath: getCodexCliAccountsPathMock,
+	getCodexCliAuthPath: getCodexCliAuthPathMock,
+	getCodexCliConfigPath: getCodexCliConfigPathMock,
+	isCodexCliSyncEnabled: isCodexCliSyncEnabledMock,
+	loadCodexCliState: loadCodexCliStateMock,
+}));
+
+vi.mock("../lib/live-account-sync.js", () => ({
+	getLastLiveAccountSyncSnapshot: getLastLiveAccountSyncSnapshotMock,
+}));
+
 vi.mock("../lib/quota-probe.js", () => ({
 	fetchCodexQuotaSnapshot: fetchCodexQuotaSnapshotMock,
 	formatQuotaSnapshotLine: vi.fn(() => "probe-ok"),
@@ -149,6 +190,7 @@ vi.mock("../lib/config.js", async () => {
 });
 
 vi.mock("../lib/quota-cache.js", () => ({
+	clearQuotaCache: clearQuotaCacheMock,
 	loadQuotaCache: loadQuotaCacheMock,
 	saveQuotaCache: saveQuotaCacheMock,
 }));
@@ -289,6 +331,7 @@ type SettingsHubMenuItem = {
 
 const SETTINGS_HUB_MENU_ORDER = [
 	"account-list",
+	"sync-center",
 	"summary-fields",
 	"behavior",
 	"theme",
@@ -450,9 +493,37 @@ describe("codex manager cli commands", () => {
 		saveDashboardDisplaySettingsMock.mockReset();
 		loadQuotaCacheMock.mockReset();
 		saveQuotaCacheMock.mockReset();
+		clearQuotaCacheMock.mockReset();
 		loadPluginConfigMock.mockReset();
 		savePluginConfigMock.mockReset();
+		previewCodexCliSyncMock.mockReset();
+		applyCodexCliSyncToStorageMock.mockReset();
+		commitPendingCodexCliSyncRunMock.mockReset();
+		commitCodexCliSyncRunFailureMock.mockReset();
+		formatRollbackPathsMock.mockReset();
+		formatRollbackPathsMock.mockImplementation((targetPath: string) => [
+			`${targetPath}.bak`,
+			`${targetPath}.bak.1`,
+			`${targetPath}.bak.2`,
+			`${targetPath}.wal`,
+		]);
+		getLastCodexCliSyncRunMock.mockReset();
+		getCodexCliAccountsPathMock.mockReset();
+		getCodexCliAuthPathMock.mockReset();
+		getCodexCliConfigPathMock.mockReset();
+		isCodexCliSyncEnabledMock.mockReset();
+		loadCodexCliStateMock.mockReset();
+		clearCodexCliStateCacheMock.mockReset();
+		getLastLiveAccountSyncSnapshotMock.mockReset();
 		selectMock.mockReset();
+		planOcChatgptSyncMock.mockReset();
+		applyOcChatgptSyncMock.mockReset();
+		runNamedBackupExportMock.mockReset();
+		exportNamedBackupMock.mockReset();
+		promptQuestionMock.mockReset();
+		detectOcChatgptMultiAuthTargetMock.mockReset();
+		normalizeAccountStorageMock.mockReset();
+		normalizeAccountStorageMock.mockImplementation((value) => value);
 		deleteSavedAccountsMock.mockReset();
 		resetLocalStateMock.mockReset();
 		deleteAccountAtIndexMock.mockReset();
@@ -539,7 +610,69 @@ describe("codex manager cli commands", () => {
 		});
 		loadPluginConfigMock.mockReturnValue({});
 		savePluginConfigMock.mockResolvedValue(undefined);
+		getLastCodexCliSyncRunMock.mockReturnValue(null);
+		previewCodexCliSyncMock.mockResolvedValue({
+			status: "unavailable",
+			statusDetail: "No Codex CLI sync source was found.",
+			sourcePath: null,
+			sourceAccountCount: null,
+			targetPath: "/mock/openai-codex-accounts.json",
+			summary: {
+				sourceAccountCount: 0,
+				targetAccountCountBefore: 0,
+				targetAccountCountAfter: 0,
+				addedAccountCount: 0,
+				updatedAccountCount: 0,
+				unchangedAccountCount: 0,
+				destinationOnlyPreservedCount: 0,
+				selectionChanged: false,
+			},
+			backup: {
+				enabled: true,
+				targetPath: "/mock/openai-codex-accounts.json",
+				rollbackPaths: [
+					"/mock/openai-codex-accounts.json.bak",
+					"/mock/openai-codex-accounts.json.wal",
+				],
+			},
+			lastSync: null,
+		});
+		applyCodexCliSyncToStorageMock.mockResolvedValue({
+			changed: false,
+			storage: null,
+			pendingRun: null,
+		});
+		getCodexCliAccountsPathMock.mockReturnValue("/mock/codex/accounts.json");
+		getCodexCliAuthPathMock.mockReturnValue("/mock/codex/auth.json");
+		getCodexCliConfigPathMock.mockReturnValue("/mock/codex/config.toml");
+		isCodexCliSyncEnabledMock.mockReturnValue(true);
+		loadCodexCliStateMock.mockResolvedValue(null);
+		getLastLiveAccountSyncSnapshotMock.mockReturnValue({
+			path: null,
+			running: false,
+			lastKnownMtimeMs: null,
+			lastSyncAt: null,
+			reloadCount: 0,
+			errorCount: 0,
+		});
 		selectMock.mockResolvedValue(undefined);
+		planOcChatgptSyncMock.mockResolvedValue({
+			kind: "blocked-none",
+			detection: { kind: "none", reason: "No oc-chatgpt target found." },
+		});
+		applyOcChatgptSyncMock.mockResolvedValue({
+			kind: "blocked-none",
+			detection: { kind: "none", reason: "No oc-chatgpt target found." },
+		});
+		runNamedBackupExportMock.mockResolvedValue({
+			kind: "exported",
+			path: "/mock/backups/demo.json",
+		});
+		promptQuestionMock.mockResolvedValue("demo");
+		detectOcChatgptMultiAuthTargetMock.mockReturnValue({
+			kind: "none",
+			reason: "No oc-chatgpt target found.",
+		});
 		restoreTTYDescriptors();
 		setStoragePathMock.mockReset();
 		getStoragePathMock.mockReturnValue("/mock/openai-codex-accounts.json");
@@ -2496,6 +2629,762 @@ describe("codex manager cli commands", () => {
 		expect(selectSequence.remaining()).toBe(0);
 		expect(runNamedBackupExportMock).not.toHaveBeenCalled();
 	});
+
+	it("honors the disabled sync-center apply hotkey", async () => {
+		setInteractiveTTY(true);
+		const now = Date.now();
+		loadAccountsMock.mockResolvedValue({
+			version: 3,
+			activeIndex: 0,
+			activeIndexByFamily: { codex: 0 },
+			accounts: [
+				{
+					email: "sync@example.com",
+					accountId: "acc_sync",
+					refreshToken: "refresh-sync",
+					accessToken: "access-sync",
+					expiresAt: now + 3_600_000,
+					addedAt: now - 1_000,
+					lastUsed: now - 1_000,
+					enabled: true,
+				},
+			],
+		});
+		promptLoginModeMock
+			.mockResolvedValueOnce({ mode: "settings" })
+			.mockResolvedValueOnce({ mode: "cancel" });
+
+		let selectCall = 0;
+		selectMock.mockImplementation(async (_items, options) => {
+			selectCall += 1;
+			if (selectCall === 1) return { type: "sync-center" };
+			if (selectCall === 2) {
+				const onInput = (
+					options as { onInput?: (raw: string) => unknown } | undefined
+				)?.onInput;
+				expect(onInput?.("a")).toBeUndefined();
+				return { type: "back" };
+			}
+			return { type: "back" };
+		});
+
+		const { runCodexMultiAuthCli } = await import("../lib/codex-manager.js");
+		const exitCode = await runCodexMultiAuthCli(["auth", "login"]);
+
+		expect(exitCode).toBe(0);
+		expect(applyCodexCliSyncToStorageMock).not.toHaveBeenCalled();
+		expect(saveAccountsMock).not.toHaveBeenCalled();
+	});
+
+	it("keeps sync-center recoverable when its initial preview load fails", async () => {
+		setInteractiveTTY(true);
+		const storage = createSettingsStorage(Date.now());
+		loadAccountsMock.mockResolvedValue(storage);
+		promptLoginModeMock
+			.mockResolvedValueOnce({ mode: "settings" })
+			.mockResolvedValueOnce({ mode: "cancel" });
+		previewCodexCliSyncMock.mockRejectedValue(makeErrnoError("busy", "EBUSY"));
+
+		let selectCall = 0;
+		selectMock.mockImplementation(async (items) => {
+			selectCall += 1;
+			if (selectCall === 1) return { type: "sync-center" };
+			if (selectCall === 2) {
+				const text = (items as Array<{ label?: string; hint?: string }>)
+					.map((item) => `${item.label ?? ""}\n${item.hint ?? ""}`)
+					.join("\n");
+				expect(text).toContain("Status: error");
+				expect(text).toContain("Failed to refresh sync center: busy");
+				return { type: "back" };
+			}
+			return { type: "back" };
+		});
+
+		const { runCodexMultiAuthCli } = await import("../lib/codex-manager.js");
+		const exitCode = await runCodexMultiAuthCli(["auth", "login"]);
+
+		expect(exitCode).toBe(0);
+		expect(previewCodexCliSyncMock).toHaveBeenCalledTimes(4);
+	});
+
+	it("keeps sync-center recoverable when refresh preview rebuild fails", async () => {
+		setInteractiveTTY(true);
+		const now = Date.now();
+		const storage = createSettingsStorage(now);
+		loadAccountsMock.mockResolvedValue(storage);
+		promptLoginModeMock
+			.mockResolvedValueOnce({ mode: "settings" })
+			.mockResolvedValueOnce({ mode: "cancel" });
+		previewCodexCliSyncMock
+			.mockResolvedValueOnce({
+				status: "ready",
+				statusDetail: "Preview ready.",
+				sourcePath: "/mock/codex/accounts.json",
+				sourceAccountCount: null,
+				targetPath: "/mock/openai-codex-accounts.json",
+				summary: {
+					sourceAccountCount: 1,
+					targetAccountCountBefore: 1,
+					targetAccountCountAfter: 1,
+					addedAccountCount: 0,
+					updatedAccountCount: 0,
+					unchangedAccountCount: 1,
+					destinationOnlyPreservedCount: 0,
+					selectionChanged: false,
+				},
+				backup: {
+					enabled: true,
+					targetPath: "/mock/openai-codex-accounts.json",
+					rollbackPaths: ["/mock/openai-codex-accounts.json.bak"],
+				},
+				lastSync: null,
+			})
+			.mockRejectedValue(makeErrnoError("busy", "EBUSY"));
+
+		let selectCall = 0;
+		selectMock.mockImplementation(async (items) => {
+			selectCall += 1;
+			if (selectCall === 1) return { type: "sync-center" };
+			if (selectCall === 2) return { type: "refresh" };
+			if (selectCall === 3) {
+				const text = (items as Array<{ label?: string; hint?: string }>)
+					.map((item) => `${item.label ?? ""}\n${item.hint ?? ""}`)
+					.join("\n");
+				expect(text).toContain("Status: error");
+				expect(text).toContain("Failed to refresh sync center: busy");
+				return { type: "back" };
+			}
+			return { type: "back" };
+		});
+
+		const { runCodexMultiAuthCli } = await import("../lib/codex-manager.js");
+		const exitCode = await runCodexMultiAuthCli(["auth", "login"]);
+
+		expect(exitCode).toBe(0);
+		expect(previewCodexCliSyncMock).toHaveBeenCalledTimes(5);
+	});
+
+	it("applies sync-center writes with storage backups disabled when configured", async () => {
+		setInteractiveTTY(true);
+		const now = Date.now();
+		const storage = {
+			version: 3,
+			activeIndex: 0,
+			activeIndexByFamily: { codex: 0 },
+			accounts: [
+				{
+					email: "sync@example.com",
+					accountId: "acc_sync",
+					refreshToken: "refresh-sync",
+					accessToken: "access-sync",
+					expiresAt: now + 3_600_000,
+					addedAt: now - 1_000,
+					lastUsed: now - 1_000,
+					enabled: true,
+				},
+			],
+		};
+		loadAccountsMock.mockResolvedValue(storage);
+		loadPluginConfigMock.mockReturnValue({ storageBackupEnabled: false });
+		promptLoginModeMock
+			.mockResolvedValueOnce({ mode: "settings" })
+			.mockResolvedValueOnce({ mode: "cancel" });
+		previewCodexCliSyncMock
+			.mockResolvedValueOnce({
+				status: "ready",
+				statusDetail: "Preview ready.",
+				sourcePath: "/mock/codex/accounts.json",
+				sourceAccountCount: null,
+				targetPath: "/mock/openai-codex-accounts.json",
+				summary: {
+					sourceAccountCount: 1,
+					targetAccountCountBefore: 1,
+					targetAccountCountAfter: 2,
+					addedAccountCount: 1,
+					updatedAccountCount: 0,
+					unchangedAccountCount: 0,
+					destinationOnlyPreservedCount: 1,
+					selectionChanged: false,
+				},
+				backup: {
+					enabled: false,
+					targetPath: "/mock/openai-codex-accounts.json",
+					rollbackPaths: ["/mock/openai-codex-accounts.json.bak"],
+				},
+				lastSync: null,
+			})
+			.mockResolvedValueOnce({
+				status: "noop",
+				statusDetail: "Target already matches the current one-way sync result.",
+				sourcePath: "/mock/codex/accounts.json",
+				sourceAccountCount: null,
+				targetPath: "/mock/openai-codex-accounts.json",
+				summary: {
+					sourceAccountCount: 1,
+					targetAccountCountBefore: 2,
+					targetAccountCountAfter: 2,
+					addedAccountCount: 0,
+					updatedAccountCount: 0,
+					unchangedAccountCount: 1,
+					destinationOnlyPreservedCount: 1,
+					selectionChanged: false,
+				},
+				backup: {
+					enabled: false,
+					targetPath: "/mock/openai-codex-accounts.json",
+					rollbackPaths: ["/mock/openai-codex-accounts.json.bak"],
+				},
+				lastSync: null,
+			});
+		applyCodexCliSyncToStorageMock.mockResolvedValueOnce({
+			changed: true,
+			storage: {
+				...storage,
+				accounts: [
+					...storage.accounts,
+					{
+						email: "codex@example.com",
+						accountId: "acc_codex",
+						refreshToken: "refresh-codex",
+						addedAt: now,
+						lastUsed: now,
+					},
+				],
+			},
+			pendingRun: {
+				revision: 2,
+				run: {
+					outcome: "changed",
+					runAt: now,
+					sourcePath: "/mock/codex/accounts.json",
+					targetPath: "/mock/openai-codex-accounts.json",
+					summary: {
+						sourceAccountCount: 1,
+						targetAccountCountBefore: 1,
+						targetAccountCountAfter: 2,
+						addedAccountCount: 1,
+						updatedAccountCount: 0,
+						unchangedAccountCount: 0,
+						destinationOnlyPreservedCount: 1,
+						selectionChanged: false,
+					},
+				},
+			},
+		});
+		let selectCall = 0;
+		selectMock.mockImplementation(async () => {
+			selectCall += 1;
+			if (selectCall === 1) return { type: "sync-center" };
+			if (selectCall === 2) return { type: "apply" };
+			return { type: "back" };
+		});
+
+		const { runCodexMultiAuthCli } = await import("../lib/codex-manager.js");
+		const exitCode = await runCodexMultiAuthCli(["auth", "login"]);
+
+		expect(exitCode).toBe(0);
+		expect(applyCodexCliSyncToStorageMock).toHaveBeenCalledWith(
+			storage,
+			expect.objectContaining({ forceRefresh: true }),
+		);
+		expect(saveAccountsMock).toHaveBeenCalledTimes(1);
+		expect(saveAccountsMock).toHaveBeenCalledWith(
+			expect.anything(),
+			expect.objectContaining({ backupEnabled: false }),
+		);
+		expect(commitPendingCodexCliSyncRunMock).toHaveBeenCalledTimes(1);
+		expect(commitCodexCliSyncRunFailureMock).not.toHaveBeenCalled();
+		expect(previewCodexCliSyncMock).toHaveBeenCalledTimes(2);
+	});
+
+	it("rebuilds the sync-center preview from reloaded disk storage after apply", async () => {
+		setInteractiveTTY(true);
+		const now = Date.now();
+		const storage = createSettingsStorage(now);
+		const syncedStorage = {
+			...storage,
+			accounts: [
+				...storage.accounts,
+				{
+					email: "codex@example.com",
+					accountId: "acc_codex",
+					refreshToken: "refresh-codex",
+					addedAt: now,
+					lastUsed: now,
+				},
+			],
+		};
+		const persistedStorage = {
+			...syncedStorage,
+			activeIndex: 1,
+			activeIndexByFamily: { codex: 1 },
+		};
+
+		loadAccountsMock.mockImplementation(async () =>
+			saveAccountsMock.mock.calls.length > 0 ? persistedStorage : storage,
+		);
+		promptLoginModeMock
+			.mockResolvedValueOnce({ mode: "settings" })
+			.mockResolvedValueOnce({ mode: "cancel" });
+		previewCodexCliSyncMock
+			.mockResolvedValueOnce({
+				status: "ready",
+				statusDetail: "Preview ready.",
+				sourcePath: "/mock/codex/accounts.json",
+				sourceAccountCount: 1,
+				targetPath: "/mock/openai-codex-accounts.json",
+				summary: {
+					sourceAccountCount: 1,
+					targetAccountCountBefore: 1,
+					targetAccountCountAfter: 2,
+					addedAccountCount: 1,
+					updatedAccountCount: 0,
+					unchangedAccountCount: 0,
+					destinationOnlyPreservedCount: 1,
+					selectionChanged: true,
+				},
+				backup: {
+					enabled: true,
+					targetPath: "/mock/openai-codex-accounts.json",
+					rollbackPaths: ["/mock/openai-codex-accounts.json.bak"],
+				},
+				lastSync: null,
+			})
+			.mockResolvedValueOnce({
+				status: "noop",
+				statusDetail: "Target already matches the current one-way sync result.",
+				sourcePath: "/mock/codex/accounts.json",
+				sourceAccountCount: 1,
+				targetPath: "/mock/openai-codex-accounts.json",
+				summary: {
+					sourceAccountCount: 1,
+					targetAccountCountBefore: 2,
+					targetAccountCountAfter: 2,
+					addedAccountCount: 0,
+					updatedAccountCount: 0,
+					unchangedAccountCount: 1,
+					destinationOnlyPreservedCount: 1,
+					selectionChanged: false,
+				},
+				backup: {
+					enabled: true,
+					targetPath: "/mock/openai-codex-accounts.json",
+					rollbackPaths: ["/mock/openai-codex-accounts.json.bak"],
+				},
+				lastSync: null,
+			});
+		applyCodexCliSyncToStorageMock.mockResolvedValueOnce({
+			changed: true,
+			storage: syncedStorage,
+			pendingRun: {
+				revision: 6,
+				run: {
+					outcome: "changed",
+					runAt: now,
+					sourcePath: "/mock/codex/accounts.json",
+					targetPath: "/mock/openai-codex-accounts.json",
+					summary: {
+						sourceAccountCount: 1,
+						targetAccountCountBefore: 1,
+						targetAccountCountAfter: 2,
+						addedAccountCount: 1,
+						updatedAccountCount: 0,
+						unchangedAccountCount: 0,
+						destinationOnlyPreservedCount: 1,
+						selectionChanged: true,
+					},
+				},
+			},
+		});
+
+		let selectCall = 0;
+		selectMock.mockImplementation(async () => {
+			selectCall += 1;
+			if (selectCall === 1) return { type: "sync-center" };
+			if (selectCall === 2) return { type: "apply" };
+			return { type: "back" };
+		});
+
+		const { runCodexMultiAuthCli } = await import("../lib/codex-manager.js");
+		const exitCode = await runCodexMultiAuthCli(["auth", "login"]);
+
+		expect(exitCode).toBe(0);
+		expect(loadAccountsMock.mock.calls.length).toBeGreaterThanOrEqual(3);
+		expect(saveAccountsMock).toHaveBeenCalledWith(
+			syncedStorage,
+			expect.objectContaining({ backupEnabled: true }),
+		);
+		expect(previewCodexCliSyncMock).toHaveBeenCalledTimes(2);
+		expect(previewCodexCliSyncMock.mock.calls[1]?.[0]).toBe(persistedStorage);
+		expect(previewCodexCliSyncMock.mock.calls[1]?.[0]).not.toBe(syncedStorage);
+	});
+
+	it("retries transient sync-center save failures before committing the sync run", async () => {
+		setInteractiveTTY(true);
+		const now = Date.now();
+		const storage = createSettingsStorage(now);
+		loadAccountsMock.mockResolvedValue(storage);
+		promptLoginModeMock
+			.mockResolvedValueOnce({ mode: "settings" })
+			.mockResolvedValueOnce({ mode: "cancel" });
+		previewCodexCliSyncMock
+			.mockResolvedValueOnce({
+				status: "ready",
+				statusDetail: "Preview ready.",
+				sourcePath: "/mock/codex/accounts.json",
+				sourceAccountCount: null,
+				targetPath: "/mock/openai-codex-accounts.json",
+				summary: {
+					sourceAccountCount: 1,
+					targetAccountCountBefore: 1,
+					targetAccountCountAfter: 2,
+					addedAccountCount: 1,
+					updatedAccountCount: 0,
+					unchangedAccountCount: 0,
+					destinationOnlyPreservedCount: 1,
+					selectionChanged: false,
+				},
+				backup: {
+					enabled: true,
+					targetPath: "/mock/openai-codex-accounts.json",
+					rollbackPaths: ["/mock/openai-codex-accounts.json.bak"],
+				},
+				lastSync: null,
+			})
+			.mockResolvedValueOnce({
+				status: "noop",
+				statusDetail: "Target already matches the current one-way sync result.",
+				sourcePath: "/mock/codex/accounts.json",
+				sourceAccountCount: null,
+				targetPath: "/mock/openai-codex-accounts.json",
+				summary: {
+					sourceAccountCount: 1,
+					targetAccountCountBefore: 2,
+					targetAccountCountAfter: 2,
+					addedAccountCount: 0,
+					updatedAccountCount: 0,
+					unchangedAccountCount: 1,
+					destinationOnlyPreservedCount: 1,
+					selectionChanged: false,
+				},
+				backup: {
+					enabled: true,
+					targetPath: "/mock/openai-codex-accounts.json",
+					rollbackPaths: ["/mock/openai-codex-accounts.json.bak"],
+				},
+				lastSync: null,
+			});
+		applyCodexCliSyncToStorageMock.mockResolvedValueOnce({
+			changed: true,
+			storage: {
+				...storage,
+				accounts: [
+					...storage.accounts,
+					{
+						email: "codex@example.com",
+						accountId: "acc_codex",
+						refreshToken: "refresh-codex",
+						addedAt: now,
+						lastUsed: now,
+					},
+				],
+			},
+			pendingRun: {
+				revision: 4,
+				run: {
+					outcome: "changed",
+					runAt: now,
+					sourcePath: "/mock/codex/accounts.json",
+					targetPath: "/mock/openai-codex-accounts.json",
+					summary: {
+						sourceAccountCount: 1,
+						targetAccountCountBefore: 1,
+						targetAccountCountAfter: 2,
+						addedAccountCount: 1,
+						updatedAccountCount: 0,
+						unchangedAccountCount: 0,
+						destinationOnlyPreservedCount: 1,
+						selectionChanged: false,
+					},
+				},
+			},
+		});
+		saveAccountsMock
+			.mockRejectedValueOnce(makeErrnoError("busy", "EBUSY"))
+			.mockResolvedValueOnce(undefined);
+
+		let selectCall = 0;
+		selectMock.mockImplementation(async () => {
+			selectCall += 1;
+			if (selectCall === 1) return { type: "sync-center" };
+			if (selectCall === 2) return { type: "apply" };
+			return { type: "back" };
+		});
+
+		const { runCodexMultiAuthCli } = await import("../lib/codex-manager.js");
+		const exitCode = await runCodexMultiAuthCli(["auth", "login"]);
+
+		expect(exitCode).toBe(0);
+		expect(saveAccountsMock).toHaveBeenCalledTimes(2);
+		expect(commitPendingCodexCliSyncRunMock).toHaveBeenCalledTimes(1);
+		expect(commitCodexCliSyncRunFailureMock).not.toHaveBeenCalled();
+		expect(previewCodexCliSyncMock).toHaveBeenCalledTimes(2);
+	});
+
+	it("retries transient sync-center apply-time reads before running the sync", async () => {
+		setInteractiveTTY(true);
+		const now = Date.now();
+		const storage = createSettingsStorage(now);
+		let failNextApplyRead = false;
+		loadAccountsMock.mockImplementation(async () => {
+			if (failNextApplyRead) {
+				failNextApplyRead = false;
+				throw makeErrnoError("busy", "EBUSY");
+			}
+			return structuredClone(storage);
+		});
+		promptLoginModeMock
+			.mockResolvedValueOnce({ mode: "settings" })
+			.mockResolvedValueOnce({ mode: "cancel" });
+		previewCodexCliSyncMock
+			.mockResolvedValueOnce({
+				status: "ready",
+				statusDetail: "Preview ready.",
+				sourcePath: "/mock/codex/accounts.json",
+				sourceAccountCount: null,
+				targetPath: "/mock/openai-codex-accounts.json",
+				summary: {
+					sourceAccountCount: 1,
+					targetAccountCountBefore: 1,
+					targetAccountCountAfter: 2,
+					addedAccountCount: 1,
+					updatedAccountCount: 0,
+					unchangedAccountCount: 0,
+					destinationOnlyPreservedCount: 1,
+					selectionChanged: false,
+				},
+				backup: {
+					enabled: true,
+					targetPath: "/mock/openai-codex-accounts.json",
+					rollbackPaths: ["/mock/openai-codex-accounts.json.bak"],
+				},
+				lastSync: null,
+			})
+			.mockResolvedValueOnce({
+				status: "noop",
+				statusDetail: "Target already matches the current one-way sync result.",
+				sourcePath: "/mock/codex/accounts.json",
+				sourceAccountCount: null,
+				targetPath: "/mock/openai-codex-accounts.json",
+				summary: {
+					sourceAccountCount: 1,
+					targetAccountCountBefore: 2,
+					targetAccountCountAfter: 2,
+					addedAccountCount: 0,
+					updatedAccountCount: 0,
+					unchangedAccountCount: 1,
+					destinationOnlyPreservedCount: 1,
+					selectionChanged: false,
+				},
+				backup: {
+					enabled: true,
+					targetPath: "/mock/openai-codex-accounts.json",
+					rollbackPaths: ["/mock/openai-codex-accounts.json.bak"],
+				},
+				lastSync: null,
+			});
+		applyCodexCliSyncToStorageMock.mockResolvedValueOnce({
+			changed: true,
+			storage: {
+				...storage,
+				accounts: [
+					...storage.accounts,
+					{
+						email: "codex@example.com",
+						accountId: "acc_codex",
+						refreshToken: "refresh-codex",
+						addedAt: now,
+						lastUsed: now,
+					},
+				],
+			},
+			pendingRun: {
+				revision: 5,
+				run: {
+					outcome: "changed",
+					runAt: now,
+					sourcePath: "/mock/codex/accounts.json",
+					targetPath: "/mock/openai-codex-accounts.json",
+					summary: {
+						sourceAccountCount: 1,
+						targetAccountCountBefore: 1,
+						targetAccountCountAfter: 2,
+						addedAccountCount: 1,
+						updatedAccountCount: 0,
+						unchangedAccountCount: 0,
+						destinationOnlyPreservedCount: 1,
+						selectionChanged: false,
+					},
+				},
+			},
+		});
+
+		let selectCall = 0;
+		selectMock.mockImplementation(async () => {
+			selectCall += 1;
+			if (selectCall === 1) return { type: "sync-center" };
+			if (selectCall === 2) {
+				failNextApplyRead = true;
+				return { type: "apply" };
+			}
+			return { type: "back" };
+		});
+
+		const { runCodexMultiAuthCli } = await import("../lib/codex-manager.js");
+		const exitCode = await runCodexMultiAuthCli(["auth", "login"]);
+
+		expect(exitCode).toBe(0);
+		expect(loadAccountsMock.mock.calls.length).toBeGreaterThanOrEqual(3);
+		expect(applyCodexCliSyncToStorageMock).toHaveBeenCalledWith(
+			storage,
+			expect.objectContaining({ forceRefresh: true }),
+		);
+		expect(saveAccountsMock).toHaveBeenCalledTimes(1);
+		expect(commitPendingCodexCliSyncRunMock).toHaveBeenCalledTimes(1);
+		expect(commitCodexCliSyncRunFailureMock).not.toHaveBeenCalled();
+		expect(previewCodexCliSyncMock).toHaveBeenCalledTimes(2);
+	});
+
+	it("surfaces sync-center save failures distinctly from reconcile failures", async () => {
+		setInteractiveTTY(true);
+		const now = Date.now();
+		const storage = {
+			version: 3,
+			activeIndex: 0,
+			activeIndexByFamily: { codex: 0 },
+			accounts: [
+				{
+					email: "sync@example.com",
+					accountId: "acc_sync",
+					refreshToken: "refresh-sync",
+					accessToken: "access-sync",
+					expiresAt: now + 3_600_000,
+					addedAt: now - 1_000,
+					lastUsed: now - 1_000,
+					enabled: true,
+				},
+			],
+		};
+		loadAccountsMock.mockResolvedValue(storage);
+		promptLoginModeMock
+			.mockResolvedValueOnce({ mode: "settings" })
+			.mockResolvedValueOnce({ mode: "cancel" });
+		previewCodexCliSyncMock.mockResolvedValueOnce({
+			status: "ready",
+			statusDetail: "Preview ready.",
+			sourcePath: "/mock/codex/accounts.json",
+			sourceAccountCount: null,
+			targetPath: "/mock/openai-codex-accounts.json",
+			summary: {
+				sourceAccountCount: 1,
+				targetAccountCountBefore: 1,
+				targetAccountCountAfter: 2,
+				addedAccountCount: 1,
+				updatedAccountCount: 0,
+				unchangedAccountCount: 0,
+				destinationOnlyPreservedCount: 1,
+				selectionChanged: false,
+			},
+			backup: {
+				enabled: true,
+				targetPath: "/mock/openai-codex-accounts.json",
+				rollbackPaths: ["/mock/openai-codex-accounts.json.bak"],
+			},
+			lastSync: null,
+		});
+		applyCodexCliSyncToStorageMock.mockResolvedValueOnce({
+			changed: true,
+			storage: {
+				...storage,
+				accounts: [
+					...storage.accounts,
+					{
+						email: "codex@example.com",
+						accountId: "acc_codex",
+						refreshToken: "refresh-codex",
+						addedAt: now,
+						lastUsed: now,
+					},
+				],
+			},
+			pendingRun: {
+				revision: 3,
+				run: {
+					outcome: "changed",
+					runAt: now,
+					sourcePath: "/mock/codex/accounts.json",
+					targetPath: "/mock/openai-codex-accounts.json",
+					summary: {
+						sourceAccountCount: 1,
+						targetAccountCountBefore: 1,
+						targetAccountCountAfter: 2,
+						addedAccountCount: 1,
+						updatedAccountCount: 0,
+						unchangedAccountCount: 0,
+						destinationOnlyPreservedCount: 1,
+						selectionChanged: false,
+					},
+				},
+			},
+		});
+		getLastCodexCliSyncRunMock.mockReturnValue({
+			outcome: "error",
+			runAt: now,
+			sourcePath: "/mock/codex/accounts.json",
+			targetPath: "/mock/openai-codex-accounts.json",
+			summary: {
+				sourceAccountCount: 1,
+				targetAccountCountBefore: 1,
+				targetAccountCountAfter: 2,
+				addedAccountCount: 1,
+				updatedAccountCount: 0,
+				unchangedAccountCount: 0,
+				destinationOnlyPreservedCount: 1,
+				selectionChanged: false,
+			},
+			message: "busy",
+		});
+		saveAccountsMock.mockRejectedValue(makeErrnoError("busy", "EBUSY"));
+
+		let selectCall = 0;
+		selectMock.mockImplementation(async (items) => {
+			selectCall += 1;
+			if (selectCall === 1) return { type: "sync-center" };
+			if (selectCall === 2) return { type: "apply" };
+			if (selectCall === 3) {
+				const text = (items as Array<{ label?: string; hint?: string }>)
+					.map((item) => `${item.label ?? ""}\n${item.hint ?? ""}`)
+					.join("\n");
+				expect(text).toContain("Failed to save synced storage: busy");
+				return { type: "back" };
+			}
+			return { type: "back" };
+		});
+
+		const { runCodexMultiAuthCli } = await import("../lib/codex-manager.js");
+		const exitCode = await runCodexMultiAuthCli(["auth", "login"]);
+
+		expect(exitCode).toBe(0);
+		expect(applyCodexCliSyncToStorageMock).toHaveBeenCalledWith(
+			storage,
+			expect.objectContaining({ forceRefresh: true }),
+		);
+		expect(saveAccountsMock).toHaveBeenCalledTimes(4);
+		expect(commitPendingCodexCliSyncRunMock).not.toHaveBeenCalled();
+		expect(commitCodexCliSyncRunFailureMock).toHaveBeenCalledTimes(1);
+		expect(previewCodexCliSyncMock).toHaveBeenCalledTimes(1);
+	});
+
 	it("drives current settings panels through representative hotkeys and persists each section", async () => {
 		const now = Date.now();
 		setupInteractiveSettingsLogin(
@@ -3206,31 +4095,6 @@ describe("codex manager cli commands", () => {
 		promptLoginModeMock
 			.mockResolvedValueOnce({ mode: "manage", deleteAccountIndex: 1 })
 			.mockResolvedValueOnce({ mode: "cancel" });
-		deleteAccountAtIndexMock.mockResolvedValueOnce({
-			storage: {
-				version: 3,
-				activeIndex: 0,
-				activeIndexByFamily: { codex: 0 },
-				accounts: [
-					{
-						email: "first@example.com",
-						refreshToken: "refresh-first",
-						addedAt: now - 2_000,
-						lastUsed: now - 2_000,
-						enabled: true,
-					},
-				],
-			},
-			flagged: { version: 1, accounts: [] },
-			removedAccount: {
-				refreshToken: "refresh-second",
-				addedAt: now - 1_000,
-				lastUsed: now - 1_000,
-				accountIdSource: undefined,
-				enabled: true,
-			},
-			removedFlaggedCount: 0,
-		});
 
 		const { runCodexMultiAuthCli } = await import("../lib/codex-manager.js");
 		const exitCode = await runCodexMultiAuthCli(["auth", "login"]);
diff --git a/test/live-account-sync.test.ts b/test/live-account-sync.test.ts
index fa51e52..a4cefbb 100644
--- a/test/live-account-sync.test.ts
+++ b/test/live-account-sync.test.ts
@@ -1,8 +1,41 @@
-import { describe, expect, it, beforeEach, afterEach, vi } from "vitest";
 import { promises as fs } from "node:fs";
-import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { LiveAccountSync } from "../lib/live-account-sync.js";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+	__resetLastLiveAccountSyncSnapshotForTests,
+	getLastLiveAccountSyncSnapshot,
+	LiveAccountSync,
+} from "../lib/live-account-sync.js";
+
+const RETRYABLE_REMOVE_CODES = new Set([
+	"EBUSY",
+	"EPERM",
+	"ENOTEMPTY",
+	"EACCES",
+	"ETIMEDOUT",
+]);
+
+async function removeWithRetry(
+	targetPath: string,
+	options: { recursive?: boolean; force?: boolean },
+): Promise<void> {
+	for (let attempt = 0; attempt < 6; attempt += 1) {
+		try {
+			await fs.rm(targetPath, options);
+			return;
+		} catch (error) {
+			const code = (error as NodeJS.ErrnoException).code;
+			if (code === "ENOENT") {
+				return;
+			}
+			if (!code || !RETRYABLE_REMOVE_CODES.has(code) || attempt === 5) {
+				throw error;
+			}
+			await new Promise((resolve) => setTimeout(resolve, 25 * 2 ** attempt));
+		}
+	}
+}
 
 describe("live-account-sync", () => {
 	let workDir = "";
@@ -11,23 +44,117 @@ describe("live-account-sync", () => {
 	beforeEach(async () => {
 		vi.useFakeTimers();
 		vi.setSystemTime(new Date("2026-02-26T12:00:00.000Z"));
-		workDir = join(tmpdir(), `codex-live-sync-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+		__resetLastLiveAccountSyncSnapshotForTests();
+		workDir = join(
+			tmpdir(),
+			`codex-live-sync-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+		);
 		storagePath = join(workDir, "openai-codex-accounts.json");
 		await fs.mkdir(workDir, { recursive: true });
-		await fs.writeFile(storagePath, JSON.stringify({ version: 3, activeIndex: 0, accounts: [] }), "utf-8");
+		await fs.writeFile(
+			storagePath,
+			JSON.stringify({ version: 3, activeIndex: 0, accounts: [] }),
+			"utf-8",
+		);
 	});
 
 	afterEach(async () => {
 		vi.useRealTimers();
-		await fs.rm(workDir, { recursive: true, force: true });
+		__resetLastLiveAccountSyncSnapshotForTests();
+		await removeWithRetry(workDir, { recursive: true, force: true });
+	});
+
+	it("publishes watcher state for sync-center status surfaces", async () => {
+		const reload = vi.fn(async () => undefined);
+		const sync = new LiveAccountSync(reload, {
+			pollIntervalMs: 500,
+			debounceMs: 50,
+		});
+
+		expect(getLastLiveAccountSyncSnapshot().running).toBe(false);
+		await sync.syncToPath(storagePath);
+		expect(getLastLiveAccountSyncSnapshot()).toEqual(
+			expect.objectContaining({
+				path: storagePath,
+				running: true,
+			}),
+		);
+
+		sync.stop();
+		expect(getLastLiveAccountSyncSnapshot()).toEqual(
+			expect.objectContaining({
+				path: storagePath,
+				running: false,
+			}),
+		);
+	});
+
+	it("keeps the newest watcher snapshot published when older instances stop later", async () => {
+		const secondStoragePath = join(workDir, "openai-codex-accounts-secondary.json");
+		await fs.writeFile(
+			secondStoragePath,
+			JSON.stringify({ version: 3, activeIndex: 0, accounts: [] }),
+			"utf-8",
+		);
+		const first = new LiveAccountSync(async () => undefined, {
+			pollIntervalMs: 500,
+			debounceMs: 50,
+		});
+		const second = new LiveAccountSync(async () => undefined, {
+			pollIntervalMs: 500,
+			debounceMs: 50,
+		});
+
+		await first.syncToPath(storagePath);
+		expect(getLastLiveAccountSyncSnapshot()).toEqual(
+			expect.objectContaining({
+				path: storagePath,
+				running: true,
+			}),
+		);
+
+		await second.syncToPath(secondStoragePath);
+		expect(getLastLiveAccountSyncSnapshot()).toEqual(
+			expect.objectContaining({
+				path: secondStoragePath,
+				running: true,
+			}),
+		);
+
+		first.stop();
+		expect(getLastLiveAccountSyncSnapshot()).toEqual(
+			expect.objectContaining({
+				path: secondStoragePath,
+				running: true,
+			}),
+		);
+
+		second.stop();
+		expect(getLastLiveAccountSyncSnapshot()).toEqual(
+			expect.objectContaining({
+				path: secondStoragePath,
+				running: false,
+			}),
+		);
 	});
 
 	it("reloads when file changes are detected by polling", async () => {
 		const reload = vi.fn(async () => undefined);
-		const sync = new LiveAccountSync(reload, { pollIntervalMs: 500, debounceMs: 50 });
+		const sync = new LiveAccountSync(reload, {
+			pollIntervalMs: 500,
+			debounceMs: 50,
+		});
 
 		await sync.syncToPath(storagePath);
-		await fs.writeFile(storagePath, JSON.stringify({ version: 3, activeIndex: 0, accounts: [{ refreshToken: "a" }] }), "utf-8");
+		await fs.writeFile(
+			storagePath,
+			JSON.stringify({
+				version: 3,
+				activeIndex: 0,
+				accounts: [{ refreshToken: "a" }],
+			}),
+			"utf-8",
+		);
 		const bumped = new Date(Date.now() + 1_000);
 		await fs.utimes(storagePath, bumped, bumped);
 
@@ -44,10 +171,21 @@ describe("live-account-sync", () => {
 		const reload = vi.fn(async () => {
 			throw new Error("reload failed");
 		});
-		const sync = new LiveAccountSync(reload, { pollIntervalMs: 500, debounceMs: 50 });
+		const sync = new LiveAccountSync(reload, {
+			pollIntervalMs: 500,
+			debounceMs: 50,
+		});
 
 		await sync.syncToPath(storagePath);
-		await fs.writeFile(storagePath, JSON.stringify({ version: 3, activeIndex: 0, accounts: [{ refreshToken: "b" }] }), "utf-8");
+		await fs.writeFile(
+			storagePath,
+			JSON.stringify({
+				version: 3,
+				activeIndex: 0,
+				accounts: [{ refreshToken: "b" }],
+			}),
+			"utf-8",
+		);
 		const bumped = new Date(Date.now() + 2_000);
 		await fs.utimes(storagePath, bumped, bumped);
 
@@ -61,11 +199,22 @@ describe("live-account-sync", () => {
 
 	it("stops watching cleanly and prevents further reloads", async () => {
 		const reload = vi.fn(async () => undefined);
-		const sync = new LiveAccountSync(reload, { pollIntervalMs: 500, debounceMs: 50 });
+		const sync = new LiveAccountSync(reload, {
+			pollIntervalMs: 500,
+			debounceMs: 50,
+		});
 
 		await sync.syncToPath(storagePath);
 		sync.stop();
-		await fs.writeFile(storagePath, JSON.stringify({ version: 3, activeIndex: 0, accounts: [{ refreshToken: "c" }] }), "utf-8");
+		await fs.writeFile(
+			storagePath,
+			JSON.stringify({
+				version: 3,
+				activeIndex: 0,
+				accounts: [{ refreshToken: "c" }],
+			}),
+			"utf-8",
+		);
 		const bumped = new Date(Date.now() + 3_000);
 		await fs.utimes(storagePath, bumped, bumped);
 
@@ -77,11 +226,16 @@ describe("live-account-sync", () => {
 
 	it("counts poll errors when stat throws non-retryable errors", async () => {
 		const reload = vi.fn(async () => undefined);
-		const sync = new LiveAccountSync(reload, { pollIntervalMs: 500, debounceMs: 50 });
+		const sync = new LiveAccountSync(reload, {
+			pollIntervalMs: 500,
+			debounceMs: 50,
+		});
 
 		await sync.syncToPath(storagePath);
 		const statSpy = vi.spyOn(fs, "stat");
-		statSpy.mockRejectedValueOnce(Object.assign(new Error("disk fault"), { code: "EIO" }));
+		statSpy.mockRejectedValueOnce(
+			Object.assign(new Error("disk fault"), { code: "EIO" }),
+		);
 
 		await vi.advanceTimersByTimeAsync(600);
 
@@ -96,12 +250,21 @@ describe("live-account-sync", () => {
 			resolveReload = resolve;
 		});
 		const reload = vi.fn(async () => reloadStarted);
-		const sync = new LiveAccountSync(reload, { pollIntervalMs: 500, debounceMs: 50 });
+		const sync = new LiveAccountSync(reload, {
+			pollIntervalMs: 500,
+			debounceMs: 50,
+		});
 		await sync.syncToPath(storagePath);
 
-		const runReload = Reflect.get(sync, "runReload") as (reason: "watch" | "poll") => Promise<void>;
+		const runReload = Reflect.get(sync, "runReload") as (
+			reason: "watch" | "poll",
+		) => Promise<void>;
 		const invoke = (reason: "watch" | "poll") =>
-			Reflect.apply(runReload as (...args: unknown[]) => unknown, sync as object, [reason]) as Promise<void>;
+			Reflect.apply(
+				runReload as (...args: unknown[]) => unknown,
+				sync as object,
+				[reason],
+			) as Promise<void>;
 		const first = invoke("poll");
 		const second = invoke("watch");
 		resolveReload?.();
@@ -111,4 +274,3 @@ describe("live-account-sync", () => {
 		sync.stop();
 	});
 });
-
diff --git a/test/settings-hub-utils.test.ts b/test/settings-hub-utils.test.ts
index 2c56244..55048c4 100644
--- a/test/settings-hub-utils.test.ts
+++ b/test/settings-hub-utils.test.ts
@@ -16,6 +16,47 @@ import {
 import type { MenuItem } from "../lib/ui/select.js";
 
 type SettingsHubTestApi = {
+	buildSyncCenterOverview: (
+		preview: {
+			status: "ready" | "noop" | "disabled" | "unavailable" | "error";
+			statusDetail: string;
+			sourcePath: string | null;
+			targetPath: string;
+			summary: {
+				addedAccountCount: number;
+				updatedAccountCount: number;
+				destinationOnlyPreservedCount: number;
+				targetAccountCountAfter: number;
+				selectionChanged: boolean;
+			};
+			backup: {
+				enabled: boolean;
+				rollbackPaths: string[];
+			};
+			lastSync: {
+				outcome: "changed" | "noop" | "disabled" | "unavailable" | "error";
+				runAt: number;
+				message?: string;
+			} | null;
+		},
+		context?: {
+			accountsPath: string;
+			authPath: string;
+			configPath: string;
+			state: {
+				accounts: unknown[];
+			} | null;
+			liveSync: {
+				path: string | null;
+				running: boolean;
+				lastKnownMtimeMs: number | null;
+				lastSyncAt: number | null;
+				reloadCount: number;
+				errorCount: number;
+			};
+			syncEnabled: boolean;
+		},
+	) => Array<{ label: string; hint?: string }>;
 	clampBackendNumber: (settingKey: string, value: number) => number;
 	formatMenuLayoutMode: (mode: "compact-details" | "expanded-rows") => string;
 	cloneDashboardSettings: (
@@ -205,6 +246,108 @@ describe("settings-hub utility coverage", () => {
 		);
 	});
 
+	it("builds sync-center overview text with preservation and rollback details", async () => {
+		const api = await loadSettingsHubTestApi();
+		const overview = api.buildSyncCenterOverview(
+			{
+				status: "ready",
+				statusDetail: "Preview ready",
+				sourcePath: "/tmp/source/accounts.json",
+				targetPath: "/tmp/target/openai-codex-accounts.json",
+				summary: {
+					addedAccountCount: 1,
+					updatedAccountCount: 2,
+					destinationOnlyPreservedCount: 3,
+					targetAccountCountAfter: 6,
+					selectionChanged: true,
+				},
+				backup: {
+					enabled: true,
+					rollbackPaths: [
+						"/tmp/target/openai-codex-accounts.json.bak",
+						"/tmp/target/openai-codex-accounts.json.wal",
+					],
+				},
+				lastSync: {
+					outcome: "changed",
+					runAt: Date.parse("2026-03-01T00:00:00.000Z"),
+				},
+			},
+			{
+				accountsPath: "/tmp/source/accounts.json",
+				authPath: "/tmp/source/auth.json",
+				configPath: "/tmp/source/config.toml",
+				sourceAccountCount: 1,
+				liveSync: {
+					path: "/tmp/target/openai-codex-accounts.json",
+					running: true,
+					lastKnownMtimeMs: Date.parse("2026-03-01T00:01:00.000Z"),
+					lastSyncAt: Date.parse("2026-03-01T00:02:00.000Z"),
+					reloadCount: 2,
+					errorCount: 0,
+				},
+				syncEnabled: true,
+			},
+		);
+
+		expect(overview[0]?.label).toContain("Status: ready");
+		expect(overview[1]?.hint).toContain("/tmp/source/accounts.json");
+		expect(overview[2]?.hint).toContain("/tmp/source/auth.json");
+		expect(overview[2]?.hint).toContain("/tmp/source/config.toml");
+		expect(overview[3]?.label).toContain("Live watcher: running");
+		expect(overview[4]?.label).toContain("Preview mode: read-only until apply");
+		expect(overview[5]?.label).toContain(
+			"add 1 | update 2 | preserve 3 | after 6",
+		);
+		expect(overview[6]?.hint).toContain("activeAccountId first");
+		expect(overview[7]?.hint).toContain("never deletes");
+		expect(overview[8]?.hint).toContain(".bak");
+		expect(overview[8]?.hint).toContain(".wal");
+	});
+
+	it("matches windows-style source paths when labeling the active sync source", async () => {
+		const api = await loadSettingsHubTestApi();
+		const overview = api.buildSyncCenterOverview(
+			{
+				status: "ready",
+				statusDetail: "Preview ready",
+				sourcePath: "C:\\Users\\Neil\\.codex\\Accounts.json",
+				targetPath: "C:\\Users\\Neil\\.codex\\openai-codex-accounts.json",
+				summary: {
+					addedAccountCount: 0,
+					updatedAccountCount: 0,
+					destinationOnlyPreservedCount: 1,
+					targetAccountCountAfter: 1,
+					selectionChanged: false,
+				},
+				backup: {
+					enabled: true,
+					rollbackPaths: [
+						"C:\\Users\\Neil\\.codex\\openai-codex-accounts.json.bak",
+					],
+				},
+				lastSync: null,
+			},
+			{
+				accountsPath: "c:/users/neil/.codex/accounts.json",
+				authPath: "c:/users/neil/.codex/auth.json",
+				configPath: "c:/users/neil/.codex/config.toml",
+				sourceAccountCount: 1,
+				liveSync: {
+					path: null,
+					running: false,
+					lastKnownMtimeMs: null,
+					lastSyncAt: null,
+					reloadCount: 0,
+					errorCount: 0,
+				},
+				syncEnabled: true,
+			},
+		);
+
+		expect(overview[2]?.label).toContain("accounts.json active");
+	});
+
 	it("formats layout mode labels", async () => {
 		const api = await loadSettingsHubTestApi();
 		expect(api.formatMenuLayoutMode("expanded-rows")).toBe("Expanded Rows");