codex-multi-auth 0.1.7 → 0.1.9

package/dist/lib/storage.js

@@ -1,12 +1,14 @@
-import { promises as fs, existsSync } from "node:fs";
-import { basename, dirname, join } from "node:path";
+import { AsyncLocalStorage } from "node:async_hooks";
 import { createHash } from "node:crypto";
+import { existsSync, promises as fs } from "node:fs";
+import { basename, dirname, join } from "node:path";
 import { ACCOUNT_LIMITS } from "./constants.js";
 import { createLogger } from "./logger.js";
+import { exportNamedBackupFile, resolveNamedBackupPath, } from "./named-backup-export.js";
 import { MODEL_FAMILIES } from "./prompts/codex.js";
 import { AnyAccountStorageSchema, getValidationErrors } from "./schemas.js";
-import { getConfigDir, getProjectConfigDir, getProjectGlobalConfigDir, findProjectRoot, resolvePath, resolveProjectStorageIdentityRoot, } from "./storage/paths.js";
 import { migrateV1ToV3, } from "./storage/migrations.js";
+import { findProjectRoot, getConfigDir, getProjectConfigDir, getProjectGlobalConfigDir, resolvePath, resolveProjectStorageIdentityRoot, } from "./storage/paths.js";
 const log = createLogger("storage");
 const ACCOUNTS_FILE_NAME = "openai-codex-accounts.json";
 const FLAGGED_ACCOUNTS_FILE_NAME = "openai-codex-flagged-accounts.json";
@@ -16,6 +18,7 @@ const ACCOUNTS_WAL_SUFFIX = ".wal";
 const ACCOUNTS_BACKUP_HISTORY_DEPTH = 3;
 const BACKUP_COPY_MAX_ATTEMPTS = 5;
 const BACKUP_COPY_BASE_DELAY_MS = 10;
+const RESET_MARKER_SUFFIX = ".reset-intent";
 let storageBackupEnabled = true;
 let lastAccountsSaveTimestamp = 0;
 /**
@@ -59,6 +62,7 @@ export function formatStorageErrorHint(error, path) {
     }
 }
 let storageMutex = Promise.resolve();
+const transactionSnapshotContext = new AsyncLocalStorage();
 function withStorageLock(fn) {
     const previousMutex = storageMutex;
     let releaseLock;
@@ -69,8 +73,12 @@ function withStorageLock(fn) {
 }
 function looksLikeSyntheticFixtureAccount(account) {
     const email = typeof account.email === "string" ? account.email.trim().toLowerCase() : "";
-    const refreshToken = typeof account.refreshToken === "string" ? account.refreshToken.trim().toLowerCase() : "";
-    const accountId = typeof account.accountId === "string" ? account.accountId.trim().toLowerCase() : "";
+    const refreshToken = typeof account.refreshToken === "string"
+        ? account.refreshToken.trim().toLowerCase()
+        : "";
+    const accountId = typeof account.accountId === "string"
+        ? account.accountId.trim().toLowerCase()
+        : "";
     if (!/^account\d+@example\.com$/.test(email)) {
         return false;
     }
@@ -104,7 +112,10 @@ async function ensureGitignore(storagePath) {
         if (existsSync(gitignorePath)) {
             content = await fs.readFile(gitignorePath, "utf-8");
             const lines = content.split("\n").map((l) => l.trim());
-            if (lines.includes(".codex") || lines.includes(".codex/") || lines.includes("/.codex") || lines.includes("/.codex/")) {
+            if (lines.includes(".codex") ||
+                lines.includes(".codex/") ||
+                lines.includes("/.codex") ||
+                lines.includes("/.codex/")) {
                 return;
             }
         }
@@ -152,6 +163,10 @@ async function getAccountsBackupRecoveryCandidatesWithDiscovery(path) {
                 continue;
             if (!entry.name.startsWith(candidatePrefix))
                 continue;
+            if (isCacheLikeBackupArtifactName(entry.name))
+                continue;
+            if (entry.name.endsWith(RESET_MARKER_SUFFIX))
+                continue;
             if (entry.name.endsWith(".tmp"))
                 continue;
             if (entry.name.includes(".rotate."))
@@ -232,7 +247,9 @@ async function createRotatingAccountsBackup(path) {
                 continue;
             }
             const stagedPath = buildStagedPath(currentPath, `slot-${i}`);
-            await copyFileWithRetry(previousPath, stagedPath, { allowMissingSource: true });
+            await copyFileWithRetry(previousPath, stagedPath, {
+                allowMissingSource: true,
+            });
             if (existsSync(stagedPath)) {
                 stagedWrites.push({ targetPath: currentPath, stagedPath });
             }
@@ -244,7 +261,10 @@ async function createRotatingAccountsBackup(path) {
         const latestStagedPath = buildStagedPath(latestBackupPath, "latest");
         await copyFileWithRetry(path, latestStagedPath);
         if (existsSync(latestStagedPath)) {
-            stagedWrites.push({ targetPath: latestBackupPath, stagedPath: latestStagedPath });
+            stagedWrites.push({
+                targetPath: latestBackupPath,
+                stagedPath: latestStagedPath,
+            });
         }
         for (const stagedWrite of stagedWrites) {
             await renameFileWithRetry(stagedWrite.stagedPath, stagedWrite.targetPath);
@@ -266,7 +286,8 @@ async function createRotatingAccountsBackup(path) {
 }
 function isRotatingBackupTempArtifact(storagePath, candidatePath) {
     const backupPrefix = `${storagePath}${ACCOUNTS_BACKUP_SUFFIX}`;
-    if (!candidatePath.startsWith(backupPrefix) || !candidatePath.endsWith(".tmp")) {
+    if (!candidatePath.startsWith(backupPrefix) ||
+        !candidatePath.endsWith(".tmp")) {
         return false;
     }
     const suffix = candidatePath.slice(backupPrefix.length);
@@ -283,7 +304,9 @@ function isRotatingBackupTempArtifact(storagePath, candidatePath) {
 async function cleanupStaleRotatingBackupArtifacts(path) {
     const directoryPath = dirname(path);
     try {
-        const directoryEntries = await fs.readdir(directoryPath, { withFileTypes: true });
+        const directoryEntries = await fs.readdir(directoryPath, {
+            withFileTypes: true,
+        });
         const staleArtifacts = directoryEntries
             .filter((entry) => entry.isFile())
             .map((entry) => join(directoryPath, entry.name))
@@ -316,6 +339,198 @@ async function cleanupStaleRotatingBackupArtifacts(path) {
 function computeSha256(value) {
     return createHash("sha256").update(value).digest("hex");
 }
+function getIntentionalResetMarkerPath(path) {
+    return `${path}${RESET_MARKER_SUFFIX}`;
+}
+function createEmptyStorageWithMetadata(restoreEligible, restoreReason) {
+    return {
+        version: 3,
+        accounts: [],
+        activeIndex: 0,
+        activeIndexByFamily: {},
+        restoreEligible,
+        restoreReason,
+    };
+}
+function withRestoreMetadata(storage, restoreEligible, restoreReason) {
+    return {
+        ...storage,
+        restoreEligible,
+        restoreReason,
+    };
+}
+function isCacheLikeBackupArtifactName(entryName) {
+    return entryName.toLowerCase().includes(".cache");
+}
+async function statSnapshot(path) {
+    try {
+        const stats = await fs.stat(path);
+        return { exists: true, bytes: stats.size, mtimeMs: stats.mtimeMs };
+    }
+    catch (error) {
+        const code = error.code;
+        if (code !== "ENOENT") {
+            log.warn("Failed to stat backup candidate", {
+                path,
+                error: String(error),
+            });
+        }
+        return { exists: false };
+    }
+}
+async function describeAccountSnapshot(path, kind, index) {
+    const stats = await statSnapshot(path);
+    if (!stats.exists) {
+        return { kind, path, index, exists: false, valid: false };
+    }
+    try {
+        const { normalized, schemaErrors, storedVersion } = await loadAccountsFromPath(path);
+        return {
+            kind,
+            path,
+            index,
+            exists: true,
+            valid: !!normalized,
+            bytes: stats.bytes,
+            mtimeMs: stats.mtimeMs,
+            version: typeof storedVersion === "number" ? storedVersion : undefined,
+            accountCount: normalized?.accounts.length,
+            schemaErrors: schemaErrors.length > 0 ? schemaErrors : undefined,
+        };
+    }
+    catch (error) {
+        const code = error.code;
+        if (code !== "ENOENT") {
+            log.warn("Failed to inspect account snapshot", {
+                path,
+                error: String(error),
+            });
+        }
+        return {
+            kind,
+            path,
+            index,
+            exists: true,
+            valid: false,
+            bytes: stats.bytes,
+            mtimeMs: stats.mtimeMs,
+        };
+    }
+}
+async function describeAccountsWalSnapshot(path) {
+    const stats = await statSnapshot(path);
+    if (!stats.exists) {
+        return { kind: "accounts-wal", path, exists: false, valid: false };
+    }
+    try {
+        const raw = await fs.readFile(path, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (!isRecord(parsed)) {
+            return {
+                kind: "accounts-wal",
+                path,
+                exists: true,
+                valid: false,
+                bytes: stats.bytes,
+                mtimeMs: stats.mtimeMs,
+            };
+        }
+        const entry = parsed;
+        if (entry.version !== 1 ||
+            typeof entry.content !== "string" ||
+            typeof entry.checksum !== "string" ||
+            computeSha256(entry.content) !== entry.checksum) {
+            return {
+                kind: "accounts-wal",
+                path,
+                exists: true,
+                valid: false,
+                bytes: stats.bytes,
+                mtimeMs: stats.mtimeMs,
+            };
+        }
+        const { normalized, storedVersion, schemaErrors } = parseAndNormalizeStorage(JSON.parse(entry.content));
+        return {
+            kind: "accounts-wal",
+            path,
+            exists: true,
+            valid: !!normalized,
+            bytes: stats.bytes,
+            mtimeMs: stats.mtimeMs,
+            version: typeof storedVersion === "number" ? storedVersion : undefined,
+            accountCount: normalized?.accounts.length,
+            schemaErrors: schemaErrors.length > 0 ? schemaErrors : undefined,
+        };
+    }
+    catch {
+        return {
+            kind: "accounts-wal",
+            path,
+            exists: true,
+            valid: false,
+            bytes: stats.bytes,
+            mtimeMs: stats.mtimeMs,
+        };
+    }
+}
+async function loadFlaggedAccountsFromPath(path) {
+    const content = await fs.readFile(path, "utf-8");
+    const data = JSON.parse(content);
+    return normalizeFlaggedStorage(data);
+}
+async function describeFlaggedSnapshot(path, kind, index) {
+    const stats = await statSnapshot(path);
+    if (!stats.exists) {
+        return { kind, path, index, exists: false, valid: false };
+    }
+    try {
+        const storage = await loadFlaggedAccountsFromPath(path);
+        return {
+            kind,
+            path,
+            index,
+            exists: true,
+            valid: true,
+            bytes: stats.bytes,
+            mtimeMs: stats.mtimeMs,
+            version: storage.version,
+            flaggedCount: storage.accounts.length,
+        };
+    }
+    catch (error) {
+        const code = error.code;
+        if (code !== "ENOENT") {
+            log.warn("Failed to inspect flagged snapshot", {
+                path,
+                error: String(error),
+            });
+        }
+        return {
+            kind,
+            path,
+            index,
+            exists: true,
+            valid: false,
+            bytes: stats.bytes,
+            mtimeMs: stats.mtimeMs,
+        };
+    }
+}
+function latestValidSnapshot(snapshots) {
+    return snapshots
+        .filter((snapshot) => snapshot.valid)
+        .sort((left, right) => (right.mtimeMs ?? 0) - (left.mtimeMs ?? 0))[0];
+}
+function buildMetadataSection(storagePath, snapshots) {
+    const latestValid = latestValidSnapshot(snapshots);
+    return {
+        storagePath,
+        latestValidPath: latestValid?.path,
+        snapshotCount: snapshots.length,
+        validSnapshotCount: snapshots.filter((snapshot) => snapshot.valid).length,
+        snapshots,
+    };
+}
 export function getLastAccountsSaveTimestamp() {
     return lastAccountsSaveTimestamp;
 }
@@ -335,7 +550,9 @@ export function setStoragePath(projectPath) {
         currentLegacyProjectStoragePath = join(getProjectConfigDir(projectRoot), ACCOUNTS_FILE_NAME);
         const previousWorktreeScopedPath = join(getProjectGlobalConfigDir(projectRoot), ACCOUNTS_FILE_NAME);
         currentLegacyWorktreeStoragePath =
-            previousWorktreeScopedPath !== currentStoragePath ? previousWorktreeScopedPath : null;
+            previousWorktreeScopedPath !== currentStoragePath
+                ? previousWorktreeScopedPath
+                : null;
     }
     else {
         currentStoragePath = null;
@@ -360,6 +577,15 @@ export function getStoragePath() {
     }
     return join(getConfigDir(), ACCOUNTS_FILE_NAME);
 }
+export function buildNamedBackupPath(name) {
+    return resolveNamedBackupPath(name, getStoragePath());
+}
+export async function exportNamedBackup(name, options) {
+    return exportNamedBackupFile(name, {
+        getStoragePath,
+        exportAccounts,
+    }, options);
+}
 export function getFlaggedAccountsPath() {
     return join(dirname(getStoragePath()), FLAGGED_ACCOUNTS_FILE_NAME);
 }
@@ -370,8 +596,13 @@ async function migrateLegacyProjectStorageIfNeeded(persist = saveAccounts) {
     if (!currentStoragePath) {
         return null;
     }
-    const candidatePaths = [currentLegacyWorktreeStoragePath, currentLegacyProjectStoragePath]
-        .filter((path) => typeof path === "string" && path.length > 0 && path !== currentStoragePath)
+    const candidatePaths = [
+        currentLegacyWorktreeStoragePath,
+        currentLegacyProjectStoragePath,
+    ]
+        .filter((path) => typeof path === "string" &&
+        path.length > 0 &&
+        path !== currentStoragePath)
         .filter((path, index, all) => all.indexOf(path) === index);
     if (candidatePaths.length === 0) {
         return null;
@@ -482,106 +713,224 @@ function selectNewestAccount(current, candidate) {
     const candidateAddedAt = candidate.addedAt || 0;
     return candidateAddedAt >= currentAddedAt ? candidate : current;
 }
-function deduplicateAccountsByKey(accounts) {
-    const keyToIndex = new Map();
-    const indicesToKeep = new Set();
+function normalizeAccountIdKey(accountId) {
+    if (!accountId)
+        return undefined;
+    const trimmed = accountId.trim();
+    return trimmed || undefined;
+}
+/**
+ * Normalize email keys for case-insensitive account identity matching.
+ */
+export function normalizeEmailKey(email) {
+    if (!email)
+        return undefined;
+    const trimmed = email.trim();
+    if (!trimmed)
+        return undefined;
+    return trimmed.toLowerCase();
+}
+function normalizeRefreshTokenKey(refreshToken) {
+    if (!refreshToken)
+        return undefined;
+    const trimmed = refreshToken.trim();
+    return trimmed || undefined;
+}
+function toAccountIdentityRef(account) {
+    return {
+        accountId: normalizeAccountIdKey(account?.accountId),
+        emailKey: normalizeEmailKey(account?.email),
+        refreshToken: normalizeRefreshTokenKey(account?.refreshToken),
+    };
+}
+function collectDistinctIdentityValues(values) {
+    const distinct = new Set();
+    for (const value of values) {
+        if (value)
+            distinct.add(value);
+    }
+    return distinct;
+}
+export function getAccountIdentityKey(account) {
+    const ref = toAccountIdentityRef(account);
+    if (ref.accountId && ref.emailKey) {
+        return `account:${ref.accountId}::email:${ref.emailKey}`;
+    }
+    if (ref.accountId)
+        return `account:${ref.accountId}`;
+    if (ref.emailKey)
+        return `email:${ref.emailKey}`;
+    if (ref.refreshToken)
+        return `refresh:${ref.refreshToken}`;
+    return undefined;
+}
+function findNewestMatchingIndex(accounts, predicate) {
+    let matchIndex;
+    let match;
     for (let i = 0; i < accounts.length; i += 1) {
         const account = accounts[i];
         if (!account)
             continue;
-        const key = account.accountId || account.refreshToken;
-        if (!key)
+        const ref = toAccountIdentityRef(account);
+        if (!predicate(ref))
             continue;
-        const existingIndex = keyToIndex.get(key);
-        if (existingIndex === undefined) {
-            keyToIndex.set(key, i);
+        if (matchIndex === undefined) {
+            matchIndex = i;
+            match = account;
             continue;
         }
-        const existing = accounts[existingIndex];
-        const newest = selectNewestAccount(existing, account);
-        keyToIndex.set(key, newest === account ? i : existingIndex);
-    }
-    for (const idx of keyToIndex.values()) {
-        indicesToKeep.add(idx);
-    }
-    const result = [];
-    for (let i = 0; i < accounts.length; i += 1) {
-        if (indicesToKeep.has(i)) {
-            const account = accounts[i];
-            if (account)
-                result.push(account);
+        const newest = selectNewestAccount(match, account);
+        if (newest === account) {
+            matchIndex = i;
+            match = account;
         }
     }
-    return result;
+    return matchIndex;
 }
-/**
- * Removes duplicate accounts, keeping the most recently used entry for each unique key.
- * Deduplication is based on accountId or refreshToken.
- * @param accounts - Array of accounts to deduplicate
- * @returns New array with duplicates removed
- */
-export function deduplicateAccounts(accounts) {
-    return deduplicateAccountsByKey(accounts);
+function findCompositeAccountMatchIndex(accounts, candidateRef) {
+    if (!candidateRef.accountId || !candidateRef.emailKey)
+        return undefined;
+    return findNewestMatchingIndex(accounts, (ref) => ref.accountId === candidateRef.accountId &&
+        ref.emailKey === candidateRef.emailKey);
 }
-/**
- * Removes duplicate accounts by email, keeping the most recently used entry.
- * Accounts without email are always preserved.
- * @param accounts - Array of accounts to deduplicate
- * @returns New array with email duplicates removed
- */
-export function normalizeEmailKey(email) {
-    if (!email)
+function findSafeEmailMatchIndex(accounts, candidateRef) {
+    if (!candidateRef.emailKey)
         return undefined;
-    const trimmed = email.trim();
-    if (!trimmed)
+    const emailAccountIds = [candidateRef.accountId];
+    let foundAny = false;
+    for (let i = 0; i < accounts.length; i += 1) {
+        const account = accounts[i];
+        if (!account)
+            continue;
+        const ref = toAccountIdentityRef(account);
+        if (ref.emailKey !== candidateRef.emailKey)
+            continue;
+        foundAny = true;
+        emailAccountIds.push(ref.accountId);
+    }
+    if (!foundAny)
         return undefined;
-    return trimmed.toLowerCase();
+    if (collectDistinctIdentityValues(emailAccountIds).size > 1) {
+        return undefined;
+    }
+    return findNewestMatchingIndex(accounts, (ref) => ref.emailKey === candidateRef.emailKey);
 }
-export function deduplicateAccountsByEmail(accounts) {
-    const emailToNewestIndex = new Map();
-    const indicesToKeep = new Set();
+function findCompatibleRefreshTokenMatchIndex(accounts, candidateRef) {
+    if (!candidateRef.refreshToken)
+        return undefined;
+    let matchingIndex;
+    let matchingAccount = null;
     for (let i = 0; i < accounts.length; i += 1) {
         const account = accounts[i];
         if (!account)
             continue;
-        const email = normalizeEmailKey(account.email);
-        if (!email) {
-            indicesToKeep.add(i);
+        const ref = toAccountIdentityRef(account);
+        if (ref.refreshToken !== candidateRef.refreshToken)
             continue;
+        if ((candidateRef.accountId &&
+            ref.accountId &&
+            ref.accountId !== candidateRef.accountId) ||
+            (candidateRef.emailKey &&
+                ref.emailKey &&
+                ref.emailKey !== candidateRef.emailKey)) {
+            return undefined;
         }
-        const existingIndex = emailToNewestIndex.get(email);
-        if (existingIndex === undefined) {
-            emailToNewestIndex.set(email, i);
-            continue;
+        if (matchingIndex !== undefined &&
+            !candidateRef.accountId &&
+            !candidateRef.emailKey) {
+            return undefined;
         }
-        const existing = accounts[existingIndex];
-        // istanbul ignore next -- defensive code: existingIndex always refers to valid account
-        if (!existing) {
-            emailToNewestIndex.set(email, i);
+        if (matchingIndex === undefined || matchingAccount === null) {
+            matchingIndex = i;
+            matchingAccount = account;
             continue;
         }
-        const existingLastUsed = existing.lastUsed || 0;
-        const candidateLastUsed = account.lastUsed || 0;
-        const existingAddedAt = existing.addedAt || 0;
-        const candidateAddedAt = account.addedAt || 0;
-        const isNewer = candidateLastUsed > existingLastUsed ||
-            (candidateLastUsed === existingLastUsed && candidateAddedAt > existingAddedAt);
-        if (isNewer) {
-            emailToNewestIndex.set(email, i);
+        const newest = selectNewestAccount(matchingAccount, account);
+        if (newest === account) {
+            matchingIndex = i;
+            matchingAccount = account;
         }
     }
-    for (const idx of emailToNewestIndex.values()) {
-        indicesToKeep.add(idx);
+    return matchingIndex;
+}
+function findUniqueAccountIdMatchIndex(accounts, candidateRef, options) {
+    if (!candidateRef.accountId)
+        return undefined;
+    if (!candidateRef.emailKey &&
+        !options.allowUniqueAccountIdFallbackWithoutEmail) {
+        return undefined;
     }
-    const result = [];
+    let matchingIndex;
+    let matchingEmailKey;
     for (let i = 0; i < accounts.length; i += 1) {
-        if (indicesToKeep.has(i)) {
-            const account = accounts[i];
-            if (account)
-                result.push(account);
+        const account = accounts[i];
+        if (!account)
+            continue;
+        const ref = toAccountIdentityRef(account);
+        if (ref.accountId !== candidateRef.accountId)
+            continue;
+        if (matchingIndex !== undefined) {
+            return undefined;
+        }
+        matchingIndex = i;
+        matchingEmailKey = ref.emailKey;
+    }
+    if (matchingIndex !== undefined &&
+        matchingEmailKey &&
+        candidateRef.emailKey &&
+        matchingEmailKey !== candidateRef.emailKey) {
+        return undefined;
+    }
+    return matchingIndex;
+}
+export function findMatchingAccountIndex(accounts, candidate, options = {}) {
+    const candidateRef = toAccountIdentityRef(candidate);
+    const byComposite = findCompositeAccountMatchIndex(accounts, candidateRef);
+    if (byComposite !== undefined)
+        return byComposite;
+    const byEmail = findSafeEmailMatchIndex(accounts, candidateRef);
+    if (byEmail !== undefined)
+        return byEmail;
+    if (candidateRef.refreshToken) {
+        const byRefresh = findCompatibleRefreshTokenMatchIndex(accounts, candidateRef);
+        if (byRefresh !== undefined)
+            return byRefresh;
+    }
+    return findUniqueAccountIdMatchIndex(accounts, candidateRef, options);
+}
+export function resolveAccountSelectionIndex(accounts, candidate, fallbackIndex = 0) {
+    if (accounts.length === 0)
+        return 0;
+    const matchedIndex = findMatchingAccountIndex(accounts, candidate, {
+        allowUniqueAccountIdFallbackWithoutEmail: true,
+    });
+    if (matchedIndex !== undefined)
+        return matchedIndex;
+    return clampIndex(fallbackIndex, accounts.length);
+}
+function deduplicateAccountsByIdentity(accounts) {
+    const deduplicated = [];
+    for (const account of accounts) {
+        if (!account)
+            continue;
+        const existingIndex = findMatchingAccountIndex(deduplicated, account);
+        if (existingIndex === undefined) {
+            deduplicated.push(account);
+            continue;
         }
+        deduplicated[existingIndex] = selectNewestAccount(deduplicated[existingIndex], account);
     }
-    return result;
+    return deduplicated;
+}
+/**
+ * Removes duplicate accounts, keeping the most recently used entry for each
+ * safely matched identity.
+ */
+export function deduplicateAccounts(accounts) {
+    return deduplicateAccountsByIdentity(accounts);
+}
+export function deduplicateAccountsByEmail(accounts) {
+    return deduplicateAccountsByIdentity(accounts);
 }
 function isRecord(value) {
     return !!value && typeof value === "object" && !Array.isArray(value);
@@ -591,20 +940,17 @@ function clampIndex(index, length) {
         return 0;
     return Math.max(0, Math.min(index, length - 1));
 }
-function toAccountKey(account) {
-    return account.accountId || account.refreshToken;
-}
-function extractActiveKey(accounts, activeIndex) {
+function extractActiveAccountRef(accounts, activeIndex) {
     const candidate = accounts[activeIndex];
     if (!isRecord(candidate))
-        return undefined;
-    const accountId = typeof candidate.accountId === "string" && candidate.accountId.trim()
-        ? candidate.accountId
-        : undefined;
-    const refreshToken = typeof candidate.refreshToken === "string" && candidate.refreshToken.trim()
-        ? candidate.refreshToken
-        : undefined;
-    return accountId || refreshToken;
+        return {};
+    return toAccountIdentityRef({
+        accountId: typeof candidate.accountId === "string" ? candidate.accountId : undefined,
+        email: typeof candidate.email === "string" ? candidate.email : undefined,
+        refreshToken: typeof candidate.refreshToken === "string"
+            ? candidate.refreshToken
+            : undefined,
+    });
 }
 /**
  * Normalizes and validates account storage data, migrating from v1 to v3 if needed.
@@ -632,22 +978,23 @@ export function normalizeAccountStorage(data) {
         ? data.activeIndex
         : 0;
     const rawActiveIndex = clampIndex(activeIndexValue, rawAccounts.length);
-    const activeKey = extractActiveKey(rawAccounts, rawActiveIndex);
+    const activeRef = extractActiveAccountRef(rawAccounts, rawActiveIndex);
     const fromVersion = data.version;
     const baseStorage = fromVersion === 1
         ? migrateV1ToV3(data)
         : data;
-    const validAccounts = rawAccounts.filter((account) => isRecord(account) && typeof account.refreshToken === "string" && !!account.refreshToken.trim());
-    const deduplicatedAccounts = deduplicateAccountsByEmail(deduplicateAccountsByKey(validAccounts));
+    const validAccounts = rawAccounts.filter((account) => isRecord(account) &&
+        typeof account.refreshToken === "string" &&
+        !!account.refreshToken.trim());
+    const deduplicatedAccounts = deduplicateAccounts(validAccounts);
     const activeIndex = (() => {
         if (deduplicatedAccounts.length === 0)
             return 0;
-        if (activeKey) {
-            const mappedIndex = deduplicatedAccounts.findIndex((account) => toAccountKey(account) === activeKey);
-            if (mappedIndex >= 0)
-                return mappedIndex;
-        }
-        return clampIndex(rawActiveIndex, deduplicatedAccounts.length);
+        return resolveAccountSelectionIndex(deduplicatedAccounts, {
+            accountId: activeRef.accountId,
+            email: activeRef.emailKey,
+            refreshToken: activeRef.refreshToken,
+        }, rawActiveIndex);
     })();
     const activeIndexByFamily = {};
     const rawFamilyIndices = isRecord(baseStorage.activeIndexByFamily)
@@ -659,15 +1006,12 @@ export function normalizeAccountStorage(data) {
             ? rawIndexValue
             : rawActiveIndex;
         const clampedRawIndex = clampIndex(rawIndex, rawAccounts.length);
-        const familyKey = extractActiveKey(rawAccounts, clampedRawIndex);
-        let mappedIndex = clampIndex(rawIndex, deduplicatedAccounts.length);
-        if (familyKey && deduplicatedAccounts.length > 0) {
-            const idx = deduplicatedAccounts.findIndex((account) => toAccountKey(account) === familyKey);
-            if (idx >= 0) {
-                mappedIndex = idx;
-            }
-        }
-        activeIndexByFamily[family] = mappedIndex;
+        const familyRef = extractActiveAccountRef(rawAccounts, clampedRawIndex);
+        activeIndexByFamily[family] = resolveAccountSelectionIndex(deduplicatedAccounts, {
+            accountId: familyRef.accountId,
+            email: familyRef.emailKey,
+            refreshToken: familyRef.refreshToken,
+        }, rawIndex);
     }
     return {
         version: 3,
@@ -684,10 +1028,88 @@ export function normalizeAccountStorage(data) {
 export async function loadAccounts() {
     return loadAccountsInternal(saveAccounts);
 }
+export async function getBackupMetadata() {
+    const storagePath = getStoragePath();
+    const walPath = getAccountsWalPath(storagePath);
+    const accountCandidates = await getAccountsBackupRecoveryCandidatesWithDiscovery(storagePath);
+    const accountSnapshots = [
+        await describeAccountSnapshot(storagePath, "accounts-primary"),
+        await describeAccountsWalSnapshot(walPath),
+    ];
+    for (const [index, candidate] of accountCandidates.entries()) {
+        const kind = candidate === `${storagePath}.bak`
+            ? "accounts-backup"
+            : candidate.startsWith(`${storagePath}.bak.`)
+                ? "accounts-backup-history"
+                : "accounts-discovered-backup";
+        accountSnapshots.push(await describeAccountSnapshot(candidate, kind, index));
+    }
+    const flaggedPath = getFlaggedAccountsPath();
+    const flaggedCandidates = await getAccountsBackupRecoveryCandidatesWithDiscovery(flaggedPath);
+    const flaggedSnapshots = [
+        await describeFlaggedSnapshot(flaggedPath, "flagged-primary"),
+    ];
+    for (const [index, candidate] of flaggedCandidates.entries()) {
+        const kind = candidate === `${flaggedPath}.bak`
+            ? "flagged-backup"
+            : candidate.startsWith(`${flaggedPath}.bak.`)
+                ? "flagged-backup-history"
+                : "flagged-discovered-backup";
+        flaggedSnapshots.push(await describeFlaggedSnapshot(candidate, kind, index));
+    }
+    return {
+        accounts: buildMetadataSection(storagePath, accountSnapshots),
+        flaggedAccounts: buildMetadataSection(flaggedPath, flaggedSnapshots),
+    };
+}
+export async function getRestoreAssessment() {
+    const storagePath = getStoragePath();
+    const resetMarkerPath = getIntentionalResetMarkerPath(storagePath);
+    const backupMetadata = await getBackupMetadata();
+    if (existsSync(resetMarkerPath)) {
+        return {
+            storagePath,
+            restoreEligible: false,
+            restoreReason: "intentional-reset",
+            backupMetadata,
+        };
+    }
+    const primarySnapshot = backupMetadata.accounts.snapshots.find((snapshot) => snapshot.kind === "accounts-primary");
+    if (!primarySnapshot?.exists) {
+        return {
+            storagePath,
+            restoreEligible: true,
+            restoreReason: "missing-storage",
+            latestSnapshot: backupMetadata.accounts.latestValidPath
+                ? backupMetadata.accounts.snapshots.find((snapshot) => snapshot.path === backupMetadata.accounts.latestValidPath)
+                : undefined,
+            backupMetadata,
+        };
+    }
+    if (primarySnapshot.valid && primarySnapshot.accountCount === 0) {
+        return {
+            storagePath,
+            restoreEligible: true,
+            restoreReason: "empty-storage",
+            latestSnapshot: primarySnapshot,
+            backupMetadata,
+        };
+    }
+    return {
+        storagePath,
+        restoreEligible: false,
+        latestSnapshot: backupMetadata.accounts.latestValidPath
+            ? backupMetadata.accounts.snapshots.find((snapshot) => snapshot.path === backupMetadata.accounts.latestValidPath)
+            : undefined,
+        backupMetadata,
+    };
+}
 function parseAndNormalizeStorage(data) {
     const schemaErrors = getValidationErrors(AnyAccountStorageSchema, data);
     const normalized = normalizeAccountStorage(data);
-    const storedVersion = isRecord(data) ? data.version : undefined;
+    const storedVersion = isRecord(data)
+        ? data.version
+        : undefined;
     return { normalized, storedVersion, schemaErrors };
 }
 async function loadAccountsFromPath(path) {
@@ -697,8 +1119,15 @@ async function loadAccountsFromPath(path) {
 }
 async function loadAccountsFromJournal(path) {
     const walPath = getAccountsWalPath(path);
+    const resetMarkerPath = getIntentionalResetMarkerPath(path);
+    if (existsSync(resetMarkerPath)) {
+        return null;
+    }
     try {
         const raw = await fs.readFile(walPath, "utf-8");
+        if (existsSync(resetMarkerPath)) {
+            return null;
+        }
         const parsed = JSON.parse(raw);
         if (!isRecord(parsed))
             return null;
@@ -722,13 +1151,17 @@ async function loadAccountsFromJournal(path) {
     catch (error) {
         const code = error.code;
         if (code !== "ENOENT") {
-            log.warn("Failed to load account WAL journal", { path: walPath, error: String(error) });
+            log.warn("Failed to load account WAL journal", {
+                path: walPath,
+                error: String(error),
+            });
         }
         return null;
     }
 }
 async function loadAccountsInternal(persistMigration) {
     const path = getStoragePath();
+    const resetMarkerPath = getIntentionalResetMarkerPath(path);
     await cleanupStaleRotatingBackupArtifacts(path);
     const migratedLegacyStorage = persistMigration
         ? await migrateLegacyProjectStorageIfNeeded(persistMigration)
@@ -736,19 +1169,32 @@ async function loadAccountsInternal(persistMigration) {
     try {
         const { normalized, storedVersion, schemaErrors } = await loadAccountsFromPath(path);
         if (schemaErrors.length > 0) {
-            log.warn("Account storage schema validation warnings", { errors: schemaErrors.slice(0, 5) });
+            log.warn("Account storage schema validation warnings", {
+                errors: schemaErrors.slice(0, 5),
+            });
         }
         if (normalized && storedVersion !== normalized.version) {
-            log.info("Migrating account storage to v3", { from: storedVersion, to: normalized.version });
+            log.info("Migrating account storage to v3", {
+                from: storedVersion,
+                to: normalized.version,
+            });
             if (persistMigration) {
                 try {
                     await persistMigration(normalized);
                 }
                 catch (saveError) {
-                    log.warn("Failed to persist migrated storage", { error: String(saveError) });
+                    log.warn("Failed to persist migrated storage", {
+                        error: String(saveError),
+                    });
                 }
             }
         }
+        if (existsSync(resetMarkerPath)) {
+            return createEmptyStorageWithMetadata(false, "intentional-reset");
+        }
+        if (normalized && normalized.accounts.length === 0) {
+            return withRestoreMetadata(normalized, true, "empty-storage");
+        }
         const primaryLooksSynthetic = looksLikeSyntheticFixtureStorage(normalized);
         if (storageBackupEnabled && normalized && primaryLooksSynthetic) {
             const backupCandidates = await getAccountsBackupRecoveryCandidatesWithDiscovery(path);
@@ -797,6 +1243,9 @@ async function loadAccountsInternal(persistMigration) {
     }
     catch (error) {
         const code = error.code;
+        if (existsSync(resetMarkerPath)) {
+            return createEmptyStorageWithMetadata(false, "intentional-reset");
+        }
         if (code === "ENOENT" && migratedLegacyStorage) {
             return migratedLegacyStorage;
         }
@@ -815,6 +1264,9 @@ async function loadAccountsInternal(persistMigration) {
             }
             return recoveredFromWal;
         }
+        if (existsSync(resetMarkerPath)) {
+            return createEmptyStorageWithMetadata(false, "intentional-reset");
+        }
         if (storageBackupEnabled) {
             const backupCandidates = await getAccountsBackupRecoveryCandidatesWithDiscovery(path);
             for (const backupPath of backupCandidates) {
@@ -827,7 +1279,10 @@ async function loadAccountsInternal(persistMigration) {
                         });
                     }
                     if (backup.normalized) {
-                        log.warn("Recovered account storage from backup file", { path, backupPath });
+                        log.warn("Recovered account storage from backup file", {
+                            path,
+                            backupPath,
+                        });
                         if (persistMigration) {
                             try {
                                 await persistMigration(backup.normalized);
@@ -856,11 +1311,15 @@ async function loadAccountsInternal(persistMigration) {
         if (code !== "ENOENT") {
             log.error("Failed to load account storage", { error: String(error) });
         }
+        if (code === "ENOENT") {
+            return createEmptyStorageWithMetadata(true, "missing-storage");
+        }
         return null;
     }
 }
 async function saveAccountsUnlocked(storage) {
     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);
@@ -870,7 +1329,9 @@ async function saveAccountsUnlocked(storage) {
         if (looksLikeSyntheticFixtureStorage(storage)) {
             try {
                 const existing = await loadNormalizedStorageFromPath(path, "existing account storage");
-                if (existing && existing.accounts.length > 0 && !looksLikeSyntheticFixtureStorage(existing)) {
+                if (existing &&
+                    existing.accounts.length > 0 &&
+                    !looksLikeSyntheticFixtureStorage(existing)) {
                     throw new StorageError("Refusing to overwrite non-synthetic account storage with synthetic fixture payload", "EINVALID", path, "Detected synthetic fixture-like account payload. Use explicit account import/login commands instead.");
                 }
             }
@@ -916,6 +1377,12 @@ async function saveAccountsUnlocked(storage) {
         for (let attempt = 0; attempt < 5; attempt++) {
             try {
                 await fs.rename(tempPath, path);
+                try {
+                    await fs.unlink(resetMarkerPath);
+                }
+                catch {
+                    // Best effort cleanup.
+                }
                 lastAccountsSaveTimestamp = Date.now();
                 try {
                     await fs.unlink(walPath);
@@ -929,7 +1396,7 @@ async function saveAccountsUnlocked(storage) {
                 const code = renameError.code;
                 if (code === "EPERM" || code === "EBUSY") {
                     lastError = renameError;
-                    await new Promise(r => setTimeout(r, 10 * Math.pow(2, attempt)));
+                    await new Promise((r) => setTimeout(r, 10 * 2 ** attempt));
                     continue;
                 }
                 throw renameError;
@@ -957,10 +1424,63 @@ async function saveAccountsUnlocked(storage) {
         throw new StorageError(`Failed to save accounts: ${err?.message || "Unknown error"}`, code, path, hint, err instanceof Error ? err : undefined);
     }
 }
+function cloneAccountStorageForPersistence(storage) {
+    return {
+        version: 3,
+        accounts: structuredClone(storage?.accounts ?? []),
+        activeIndex: typeof storage?.activeIndex === "number" &&
+            Number.isFinite(storage.activeIndex)
+            ? storage.activeIndex
+            : 0,
+        activeIndexByFamily: structuredClone(storage?.activeIndexByFamily ?? {}),
+    };
+}
 export async function withAccountStorageTransaction(handler) {
     return withStorageLock(async () => {
-        const current = await loadAccountsInternal(saveAccountsUnlocked);
-        return handler(current, saveAccountsUnlocked);
+        const state = {
+            snapshot: await loadAccountsInternal(saveAccountsUnlocked),
+            active: true,
+        };
+        const current = state.snapshot;
+        const persist = async (storage) => {
+            await saveAccountsUnlocked(storage);
+            state.snapshot = storage;
+        };
+        return transactionSnapshotContext.run(state, () => handler(current, persist));
+    });
+}
+export async function withAccountAndFlaggedStorageTransaction(handler) {
+    return withStorageLock(async () => {
+        const state = {
+            snapshot: await loadAccountsInternal(saveAccountsUnlocked),
+            active: true,
+        };
+        const current = state.snapshot;
+        const persist = async (accountStorage, flaggedStorage) => {
+            const previousAccounts = cloneAccountStorageForPersistence(state.snapshot);
+            const nextAccounts = cloneAccountStorageForPersistence(accountStorage);
+            await saveAccountsUnlocked(nextAccounts);
+            try {
+                await saveFlaggedAccountsUnlocked(flaggedStorage);
+                state.snapshot = nextAccounts;
+            }
+            catch (error) {
+                try {
+                    await saveAccountsUnlocked(previousAccounts);
+                    state.snapshot = previousAccounts;
+                }
+                catch (rollbackError) {
+                    const combinedError = new AggregateError([error, rollbackError], "Flagged save failed and account storage rollback also failed");
+                    log.error("Failed to rollback account storage after flagged save failure", {
+                        error: String(error),
+                        rollbackError: String(rollbackError),
+                    });
+                    throw combinedError;
+                }
+                throw error;
+            }
+        };
+        return transactionSnapshotContext.run(state, () => handler(current, persist));
     });
 }
 /**
@@ -982,8 +1502,10 @@ export async function saveAccounts(storage) {
 export async function clearAccounts() {
     return withStorageLock(async () => {
         const path = getStoragePath();
+        const resetMarkerPath = getIntentionalResetMarkerPath(path);
         const walPath = getAccountsWalPath(path);
-        const backupPaths = getAccountsBackupRecoveryCandidates(path);
+        const backupPaths = await getAccountsBackupRecoveryCandidatesWithDiscovery(path);
+        await fs.writeFile(resetMarkerPath, JSON.stringify({ version: 1, createdAt: Date.now() }), { encoding: "utf-8", mode: 0o600 });
         const clearPath = async (targetPath) => {
             try {
                 await fs.unlink(targetPath);
@@ -999,7 +1521,11 @@ export async function clearAccounts() {
             }
         };
         try {
-            await Promise.all([clearPath(path), clearPath(walPath), ...backupPaths.map(clearPath)]);
+            await Promise.all([
+                clearPath(path),
+                clearPath(walPath),
+                ...backupPaths.map(clearPath),
+            ]);
         }
         catch {
             // Individual path cleanup is already best-effort with per-artifact logging.
@@ -1014,13 +1540,22 @@ function normalizeFlaggedStorage(data) {
     for (const rawAccount of data.accounts) {
         if (!isRecord(rawAccount))
             continue;
-        const refreshToken = typeof rawAccount.refreshToken === "string" ? rawAccount.refreshToken.trim() : "";
+        const refreshToken = typeof rawAccount.refreshToken === "string"
+            ? rawAccount.refreshToken.trim()
+            : "";
         if (!refreshToken)
             continue;
-        const flaggedAt = typeof rawAccount.flaggedAt === "number" ? rawAccount.flaggedAt : Date.now();
-        const isAccountIdSource = (value) => value === "token" || value === "id_token" || value === "org" || value === "manual";
+        const flaggedAt = typeof rawAccount.flaggedAt === "number"
+            ? rawAccount.flaggedAt
+            : Date.now();
+        const isAccountIdSource = (value) => value === "token" ||
+            value === "id_token" ||
+            value === "org" ||
+            value === "manual";
         const isSwitchReason = (value) => value === "rate-limit" || value === "initial" || value === "rotation";
-        const isCooldownReason = (value) => value === "auth-failure" || value === "network-error" || value === "rate-limit";
+        const isCooldownReason = (value) => value === "auth-failure" ||
+            value === "network-error" ||
+            value === "rate-limit";
         let rateLimitResetTimes;
         if (isRecord(rawAccount.rateLimitResetTimes)) {
             const normalizedRateLimits = {};
@@ -1045,19 +1580,33 @@ function normalizeFlaggedStorage(data) {
         const normalized = {
             refreshToken,
             addedAt: typeof rawAccount.addedAt === "number" ? rawAccount.addedAt : flaggedAt,
-            lastUsed: typeof rawAccount.lastUsed === "number" ? rawAccount.lastUsed : flaggedAt,
-            accountId: typeof rawAccount.accountId === "string" ? rawAccount.accountId : undefined,
+            lastUsed: typeof rawAccount.lastUsed === "number"
+                ? rawAccount.lastUsed
+                : flaggedAt,
+            accountId: typeof rawAccount.accountId === "string"
+                ? rawAccount.accountId
+                : undefined,
             accountIdSource,
-            accountLabel: typeof rawAccount.accountLabel === "string" ? rawAccount.accountLabel : undefined,
+            accountLabel: typeof rawAccount.accountLabel === "string"
+                ? rawAccount.accountLabel
+                : undefined,
             email: typeof rawAccount.email === "string" ? rawAccount.email : undefined,
-            enabled: typeof rawAccount.enabled === "boolean" ? rawAccount.enabled : undefined,
+            enabled: typeof rawAccount.enabled === "boolean"
+                ? rawAccount.enabled
+                : undefined,
             lastSwitchReason,
             rateLimitResetTimes,
-            coolingDownUntil: typeof rawAccount.coolingDownUntil === "number" ? rawAccount.coolingDownUntil : undefined,
+            coolingDownUntil: typeof rawAccount.coolingDownUntil === "number"
+                ? rawAccount.coolingDownUntil
+                : undefined,
             cooldownReason,
             flaggedAt,
-            flaggedReason: typeof rawAccount.flaggedReason === "string" ? rawAccount.flaggedReason : undefined,
-            lastError: typeof rawAccount.lastError === "string" ? rawAccount.lastError : undefined,
+            flaggedReason: typeof rawAccount.flaggedReason === "string"
+                ? rawAccount.flaggedReason
+                : undefined,
+            lastError: typeof rawAccount.lastError === "string"
+                ? rawAccount.lastError
+                : undefined,
         };
         byRefreshToken.set(refreshToken, normalized);
     }
@@ -1068,16 +1617,24 @@ function normalizeFlaggedStorage(data) {
 }
 export async function loadFlaggedAccounts() {
     const path = getFlaggedAccountsPath();
+    const resetMarkerPath = getIntentionalResetMarkerPath(path);
     const empty = { version: 1, accounts: [] };
     try {
         const content = await fs.readFile(path, "utf-8");
         const data = JSON.parse(content);
-        return normalizeFlaggedStorage(data);
+        const loaded = normalizeFlaggedStorage(data);
+        if (existsSync(resetMarkerPath)) {
+            return empty;
+        }
+        return loaded;
     }
     catch (error) {
         const code = error.code;
         if (code !== "ENOENT") {
-            log.error("Failed to load flagged account storage", { path, error: String(error) });
+            log.error("Failed to load flagged account storage", {
+                path,
+                error: String(error),
+            });
             return empty;
         }
     }
@@ -1114,38 +1671,89 @@ export async function loadFlaggedAccounts() {
         return empty;
     }
 }
-export async function saveFlaggedAccounts(storage) {
-    return withStorageLock(async () => {
-        const path = getFlaggedAccountsPath();
-        const uniqueSuffix = `${Date.now()}.${Math.random().toString(36).slice(2, 8)}`;
-        const tempPath = `${path}.${uniqueSuffix}.tmp`;
-        try {
-            await fs.mkdir(dirname(path), { recursive: true });
-            const content = JSON.stringify(normalizeFlaggedStorage(storage), null, 2);
-            await fs.writeFile(tempPath, content, { encoding: "utf-8", mode: 0o600 });
-            await fs.rename(tempPath, path);
-        }
-        catch (error) {
+async function saveFlaggedAccountsUnlocked(storage) {
+    const path = getFlaggedAccountsPath();
+    const markerPath = getIntentionalResetMarkerPath(path);
+    const uniqueSuffix = `${Date.now()}.${Math.random().toString(36).slice(2, 8)}`;
+    const tempPath = `${path}.${uniqueSuffix}.tmp`;
+    try {
+        await fs.mkdir(dirname(path), { recursive: true });
+        if (existsSync(path)) {
             try {
-                await fs.unlink(tempPath);
+                await copyFileWithRetry(path, `${path}.bak`, {
+                    allowMissingSource: true,
+                });
             }
-            catch {
-                // Ignore cleanup failures.
+            catch (backupError) {
+                log.warn("Failed to create flagged backup snapshot", {
+                    path,
+                    error: String(backupError),
+                });
             }
-            log.error("Failed to save flagged account storage", { path, error: String(error) });
-            throw error;
         }
+        const content = JSON.stringify(normalizeFlaggedStorage(storage), null, 2);
+        await fs.writeFile(tempPath, content, { encoding: "utf-8", mode: 0o600 });
+        await renameFileWithRetry(tempPath, path);
+        try {
+            await fs.unlink(markerPath);
+        }
+        catch {
+            // Best effort cleanup.
+        }
+    }
+    catch (error) {
+        try {
+            await fs.unlink(tempPath);
+        }
+        catch {
+            // Ignore cleanup failures.
+        }
+        log.error("Failed to save flagged account storage", {
+            path,
+            error: String(error),
+        });
+        throw error;
+    }
+}
+export async function saveFlaggedAccounts(storage) {
+    return withStorageLock(async () => {
+        await saveFlaggedAccountsUnlocked(storage);
     });
 }
 export async function clearFlaggedAccounts() {
     return withStorageLock(async () => {
+        const path = getFlaggedAccountsPath();
+        const markerPath = getIntentionalResetMarkerPath(path);
         try {
-            await fs.unlink(getFlaggedAccountsPath());
+            await fs.writeFile(markerPath, "reset", {
+                encoding: "utf-8",
+                mode: 0o600,
+            });
         }
         catch (error) {
-            const code = error.code;
-            if (code !== "ENOENT") {
-                log.error("Failed to clear flagged account storage", { error: String(error) });
+            log.error("Failed to write flagged reset marker", {
+                path,
+                markerPath,
+                error: String(error),
+            });
+            throw error;
+        }
+        const backupPaths = await getAccountsBackupRecoveryCandidatesWithDiscovery(path);
+        for (const candidate of [path, ...backupPaths, markerPath]) {
+            try {
+                await fs.unlink(candidate);
+            }
+            catch (error) {
+                const code = error.code;
+                if (code !== "ENOENT") {
+                    log.error("Failed to clear flagged account storage", {
+                        path: candidate,
+                        error: String(error),
+                    });
+                    if (candidate === path) {
+                        throw error;
+                    }
+                }
             }
         }
     });
@@ -1156,23 +1764,38 @@ export async function clearFlaggedAccounts() {
  * @param force - If true, overwrite existing file (default: true)
  * @throws Error if file exists and force is false, or if no accounts to export
  */
-export async function exportAccounts(filePath, force = true) {
+export async function exportAccounts(filePath, force = true, beforeCommit) {
     const resolvedPath = resolvePath(filePath);
     if (!force && existsSync(resolvedPath)) {
         throw new Error(`File already exists: ${resolvedPath}`);
     }
-    const storage = await withAccountStorageTransaction((current) => Promise.resolve(current));
+    const transactionState = transactionSnapshotContext.getStore();
+    const storage = transactionState?.active
+        ? transactionState.snapshot
+        : await withAccountStorageTransaction((current) => Promise.resolve(current));
     if (!storage || storage.accounts.length === 0) {
         throw new Error("No accounts to export");
     }
     await fs.mkdir(dirname(resolvedPath), { recursive: true });
-    const content = JSON.stringify(storage, null, 2);
+    await beforeCommit?.(resolvedPath);
+    if (!force && existsSync(resolvedPath)) {
+        throw new Error(`File already exists: ${resolvedPath}`);
+    }
+    const content = JSON.stringify({
+        version: storage.version,
+        accounts: storage.accounts,
+        activeIndex: storage.activeIndex,
+        activeIndexByFamily: storage.activeIndexByFamily,
+    }, null, 2);
     await fs.writeFile(resolvedPath, content, { encoding: "utf-8", mode: 0o600 });
-    log.info("Exported accounts", { path: resolvedPath, count: storage.accounts.length });
+    log.info("Exported accounts", {
+        path: resolvedPath,
+        count: storage.accounts.length,
+    });
 }
 /**
  * Imports accounts from a JSON file, merging with existing accounts.
- * Deduplicates by accountId/email, preserving most recently used entries.
+ * Deduplicates by safe account identity, preserving most recently used entries.
  * @param filePath - Source file path
  * @throws Error if file is invalid or would exceed MAX_ACCOUNTS
  */
@@ -1194,17 +1817,17 @@ export async function importAccounts(filePath) {
     if (!normalized) {
         throw new Error("Invalid account storage format");
     }
-    const { imported: importedCount, total, skipped: skippedCount } = await withAccountStorageTransaction(async (existing, persist) => {
+    const { imported: importedCount, total, skipped: skippedCount, } = await withAccountStorageTransaction(async (existing, persist) => {
         const existingAccounts = existing?.accounts ?? [];
         const existingActiveIndex = existing?.activeIndex ?? 0;
         const merged = [...existingAccounts, ...normalized.accounts];
         if (merged.length > ACCOUNT_LIMITS.MAX_ACCOUNTS) {
-            const deduped = deduplicateAccountsByEmail(deduplicateAccounts(merged));
+            const deduped = deduplicateAccounts(merged);
             if (deduped.length > ACCOUNT_LIMITS.MAX_ACCOUNTS) {
                 throw new Error(`Import would exceed maximum of ${ACCOUNT_LIMITS.MAX_ACCOUNTS} accounts (would have ${deduped.length})`);
             }
         }
-        const deduplicatedAccounts = deduplicateAccountsByEmail(deduplicateAccounts(merged));
+        const deduplicatedAccounts = deduplicateAccounts(merged);
         const newStorage = {
             version: 3,
             accounts: deduplicatedAccounts,
@@ -1216,7 +1839,12 @@ export async function importAccounts(filePath) {
         const skipped = normalized.accounts.length - imported;
         return { imported, total: deduplicatedAccounts.length, skipped };
     });
-    log.info("Imported accounts", { path: resolvedPath, imported: importedCount, skipped: skippedCount, total });
+    log.info("Imported accounts", {
+        path: resolvedPath,
+        imported: importedCount,
+        skipped: skippedCount,
+        total,
+    });
     return { imported: importedCount, total, skipped: skippedCount };
 }
 //# sourceMappingURL=storage.js.map