Fix overlap cleanup rollback on persist failure

Author: ndycode

lib/codex-multi-auth-sync.ts

@@ -1294,14 +1294,33 @@ export async function cleanupCodexMultiAuthSyncedOverlaps(
 						.map((account) => normalizeTrimmedIdentity(account.refreshToken))
 						.filter((refreshToken): refreshToken is string => refreshToken !== undefined),
 				);
-				await persist.flagged({
-					version: 1,
+				const nextFlaggedStorage = {
+					version: 1 as const,
 					accounts: currentFlaggedStorage.accounts.filter((flaggedAccount) => {
 						const refreshToken = normalizeTrimmedIdentity(flaggedAccount.refreshToken);
 						return refreshToken !== undefined && remainingRefreshTokens.has(refreshToken);
 					}),
-				});
-				await persist.accounts(plan.nextStorage);
+				};
+				await persist.flagged(nextFlaggedStorage);
+				try {
+					await persist.accounts(plan.nextStorage);
+				} catch (accountsError) {
+					try {
+						await persist.flagged(currentFlaggedStorage);
+					} catch (restoreFlaggedError) {
+						const accountsMessage =
+							accountsError instanceof Error ? accountsError.message : String(accountsError);
+						const restoreFlaggedMessage =
+							restoreFlaggedError instanceof Error
+								? restoreFlaggedError.message
+								: String(restoreFlaggedError);
+						throw new Error(
+							`Failed to persist overlap cleanup accounts: ${accountsMessage}; ` +
+								`failed to restore flagged storage: ${restoreFlaggedMessage}`,
+						);
+					}
+					throw accountsError;
+				}
 			}
 			return plan.result;
 		} catch (error) {

test/codex-multi-auth-sync.test.ts

@@ -1996,6 +1996,63 @@ describe("codex-multi-auth sync", () => {
 		}
 	});
 
+	it("rolls back flagged storage when overlap cleanup account persistence fails", async () => {
+		const originalFlaggedStorage: FlaggedAccountStorageV1 = {
+			version: 1,
+			accounts: [
+				{
+					accountId: "flagged-sync",
+					organizationId: "org-sync",
+					refreshToken: "rt-sync",
+					flaggedAt: 123,
+					addedAt: 4,
+					lastUsed: 4,
+				},
+			],
+		};
+		const persist = await mockOverlapCleanupTransaction(
+			{
+				version: 3,
+				activeIndex: 0,
+				activeIndexByFamily: {},
+				accounts: [
+					{
+						accountId: "org-local",
+						organizationId: "org-local",
+						accountIdSource: "org",
+						email: "shared@example.com",
+						refreshToken: "rt-local",
+						addedAt: 5,
+						lastUsed: 5,
+					},
+					{
+						accountTags: ["codex-multi-auth-sync"],
+						email: "shared@example.com",
+						refreshToken: "rt-sync",
+						addedAt: 4,
+						lastUsed: 4,
+					},
+				],
+			},
+			{
+				flagged: originalFlaggedStorage,
+				persistAccounts: async () => {
+					throw new Error("persist failed");
+				},
+			},
+		);
+
+		const { cleanupCodexMultiAuthSyncedOverlaps } = await import("../lib/codex-multi-auth-sync.js");
+		await expect(cleanupCodexMultiAuthSyncedOverlaps()).rejects.toThrow("persist failed");
+
+		expect(persist.flagged).toHaveBeenCalledTimes(2);
+		expect(persist.flagged).toHaveBeenNthCalledWith(1, {
+			version: 1,
+			accounts: [],
+		});
+		expect(persist.flagged).toHaveBeenNthCalledWith(2, originalFlaggedStorage);
+	});
+
 
 	it("limits overlap cleanup to accounts tagged from codex-multi-auth sync", async () => {
 		await mockOverlapCleanupTransaction({