work-license-server 1.0.21 → 1.0.22

package/assets/admin.js

@@ -311,6 +311,9 @@
         if ($('#navAdmOrders')) $('#navAdmOrders').textContent = `Заказы и счета (${orders.length})`;
         if ($('#navAdmUsers')) $('#navAdmUsers').textContent = `Клиенты и администраторы (${users.length})`;
         if ($('#navAdmTickets')) $('#navAdmTickets').textContent = `Тикеты поддержки (${openTickets.length})`;
+        if ($('#admDataDirLabel') && data.dataDir) {
+            $('#admDataDirLabel').textContent = `Папка БД: ${data.dataDir}`;
+        }
 
         renderServersTable(licenses);
         renderFranchisesTable(franchises);
@@ -870,6 +873,57 @@
         URL.revokeObjectURL(url);
     }
 
+    async function exportAdminBackup() {
+        try {
+            const bundle = await api('/api/admin/backup/export');
+            const json = JSON.stringify(bundle, null, 2);
+            const blob = new Blob([json], { type: 'application/json;charset=utf-8' });
+            const url = URL.createObjectURL(blob);
+            const a = document.createElement('a');
+            const dayStr = new Date().toISOString().slice(0, 10);
+            a.href = url;
+            a.download = `odant-work-license-backup-${dayStr}.json`;
+            document.body.appendChild(a);
+            a.click();
+            a.remove();
+            URL.revokeObjectURL(url);
+        }
+        catch (err) {
+            alert(err.message);
+        }
+    }
+
+    async function importAdminBackupFile(file) {
+        if (!file) return;
+        try {
+            const text = await file.text();
+            const parsed = JSON.parse(text);
+            const res = await api('/api/admin/backup/import', {
+                backup: parsed,
+                mode: 'merge',
+            });
+            await refreshRegistry();
+            const c = res.counts || {};
+            alert(`Резервная копия успешно объединена с базой!\nПользователей: ${c.users || 0}, серверов/лицензий: ${c.licenses || 0}, заказов: ${c.orders || 0}, франшиз: ${c.reservations || 0}.`);
+        }
+        catch (err) {
+            alert('Ошибка импорта резервной копии: ' + (err.message || err));
+        }
+    }
+
+    async function recoverAdminFromNpx() {
+        try {
+            const res = await api('/api/admin/backup/recover', {});
+            await refreshRegistry();
+            const c = res.counts || {};
+            const srcCount = Array.isArray(res.mergedSources) ? res.mergedSources.length : 0;
+            alert(`Поиск по кэшу npx и системным папкам завершён (найдено источников: ${srcCount}).\nВ базе сейчас — пользователей: ${c.users || 0}, серверов/лицензий: ${c.licenses || 0}, заказов: ${c.orders || 0}, франшиз: ${c.reservations || 0}.`);
+        }
+        catch (err) {
+            alert(err.message);
+        }
+    }
+
     /* ================= Привязка событий ================= */
     function bind() {
         document.addEventListener('click', (e) => {
@@ -944,9 +998,18 @@
                     navigator.clipboard?.writeText($('#certJsonBox')?.textContent || '');
                     break;
                 case 'cert-download': downloadCurrentCert(); break;
+                case 'admin-export-backup': exportAdminBackup(); break;
+                case 'admin-import-backup': $('#inpAdmBackupFile')?.click(); break;
+                case 'admin-recover-npx': recoverAdminFromNpx(); break;
             }
         });
 
+        $('#inpAdmBackupFile')?.addEventListener('change', (e) => {
+            const file = e.target.files?.[0];
+            if (file) importAdminBackupFile(file);
+            e.target.value = '';
+        });
+
         $('#btnTheme')?.addEventListener('click', toggleTheme);
         $('#adminLoginScreen')?.addEventListener('keydown', (e) => {
             if (e.key === 'Enter' && e.target.tagName !== 'BUTTON') {

package/bin/server.mjs

@@ -2,16 +2,75 @@
 /**
  * Точка запуска лицензионного сервера и лендинга ПАК WORK (work.odant.org).
  */
-import { fileURLToPath } from 'node:url';
+import fs from 'node:fs';
+import net from 'node:net';
+import path from 'node:path';
+import * as childProcess from 'node:child_process';
 import { createLicenseServerApp } from '../src/server.js';
+import { resolvePersistentDataDir } from '../src/store.js';
 
 const port = Number(process.env.PORT || process.env.WORK_LICENSE_PORT || 8020);
-const defaultDataDir = fileURLToPath(new URL('../data', import.meta.url));
-const dataDir = process.env.WORK_LICENSE_DATA_DIR || defaultDataDir;
+const dataDir = resolvePersistentDataDir();
 
-const app = createLicenseServerApp({ dataDir });
+async function releasePreviousInstance() {
+    const pidFile = path.join(dataDir, 'run.pid');
+    try {
+        if (fs.existsSync(pidFile)) {
+            const oldPid = Number(fs.readFileSync(pidFile, 'utf8').trim());
+            if (Number.isInteger(oldPid) && oldPid > 0 && oldPid !== process.pid) {
+                try {
+                    process.kill(oldPid);
+                    for (let i = 0; i < 15; i++) {
+                        await new Promise(r => setTimeout(r, 100));
+                        try { process.kill(oldPid, 0); }
+                        catch { break; }
+                    }
+                }
+                catch { /* процесс уже завершён */ }
+            }
+        }
+    }
+    catch { /* ignore */ }
+
+    const isPortBusy = () => new Promise((resolve) => {
+        const sock = net.createConnection({ host: '127.0.0.1', port });
+        sock.once('connect', () => { sock.destroy(); resolve(true); });
+        sock.once('error', () => { sock.destroy(); resolve(false); });
+    });
+
+    if (await isPortBusy() && process.platform === 'win32') {
+        try {
+            const out = childProcess.execSync(`netstat -ano | findstr :${port}`, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+            for (const line of out.split(/\r?\n/)) {
+                const m = line.trim().match(/LISTENING\s+(\d+)$/i);
+                const pid = m ? Number(m[1]) : 0;
+                if (pid && pid !== process.pid) {
+                    try { process.kill(pid); } catch { /* ignore */ }
+                }
+            }
+            for (let i = 0; i < 15; i++) {
+                await new Promise(r => setTimeout(r, 100));
+                if (!(await isPortBusy()))
+                    break;
+            }
+        }
+        catch { /* ignore */ }
+    }
+
+    try {
+        fs.mkdirSync(dataDir, { recursive: true });
+        fs.writeFileSync(pidFile, String(process.pid), 'utf8');
+    }
+    catch { /* ignore */ }
+}
+
+await releasePreviousInstance();
+
+const app = createLicenseServerApp({ dataDir, autoRecover: true });
 const server = await app.listen(port);
 const addr = server.address();
 const actualPort = typeof addr === 'object' && addr ? addr.port : port;
+const counts = app.store.getStoreCounts();
 console.log(`[work.odant.org] Витрина ODANT-WORK: http://localhost:${actualPort}/`);
 console.log(`[work.odant.org] Панель администратора: http://localhost:${actualPort}/admin`);
+console.log(`[work.odant.org] Постоянная база данных: ${app.store.stateFile} (пользователей: ${counts.users}, серверов/лицензий: ${counts.licenses}, заказов: ${counts.orders})`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "work-license-server",
-  "version": "1.0.21",
+  "version": "1.0.22",
   "description": "Лицензионный сервер, биллинг ЮKassa, боты поддержки (MAX, Telegram, VK) и лендинг ПАК WORK (work.odant.org)",
   "type": "module",
   "main": "src/index.js",

package/src/admin.js

@@ -129,6 +129,15 @@ export function renderAdminPage({ publicKey = '', assetVersion = '' } = {}) {
                     <button type="button" class="sec-nav-item" data-adm-tab="orders" id="navAdmOrders">Заказы и счета (0)</button>
                     <button type="button" class="sec-nav-item" data-adm-tab="users" id="navAdmUsers">Клиенты и администраторы (0)</button>
                     <button type="button" class="sec-nav-item" data-adm-tab="tickets" id="navAdmTickets">Тикеты поддержки (0)</button>
+                    <div class="sec-nav-sep"></div>
+                    <div style="padding:10px 12px;border-radius:10px;border:1px solid var(--line);background:var(--panel);display:flex;flex-direction:column;gap:6px">
+                        <div class="small muted" style="font-weight:700;font-size:11.5px;text-transform:uppercase;letter-spacing:.04em">Резервная копия базы</div>
+                        <button type="button" class="btn btn-ghost btn-sm" style="width:100%;justify-content:flex-start;font-size:12px;padding:6px 10px" data-action="admin-export-backup">📥 Скачать бэкап (.json)</button>
+                        <button type="button" class="btn btn-ghost btn-sm" style="width:100%;justify-content:flex-start;font-size:12px;padding:6px 10px" data-action="admin-import-backup">📤 Восстановить из файла</button>
+                        <button type="button" class="btn btn-ghost btn-sm" style="width:100%;justify-content:flex-start;font-size:12px;padding:6px 10px" data-action="admin-recover-npx" title="Найти и объединить данные из предыдущих запусков npx">🔄 Найти данные из npx</button>
+                        <input type="file" id="inpAdmBackupFile" accept=".json,application/json" style="display:none">
+                        <div class="small muted" id="admDataDirLabel" style="font-size:11px;word-break:break-all;line-height:1.3;margin-top:2px"></div>
+                    </div>
                 </aside>
 
                 <!-- Правая область выбранного раздела -->

package/src/index.js

@@ -37,7 +37,13 @@ export {
     parseOwnerAccessToken,
     verifyOwnerAccessToken,
 } from './crypto.js';
-export { LicenseStore } from './store.js';
+export {
+    LicenseStore,
+    isEphemeralPackagePath,
+    resolvePersistentDataDir,
+    findCandidateRecoveryDirs,
+    mergeStoreStates,
+} from './store.js';
 export { YooKassaService } from './yookassa.js';
 export { SupportBotsHub } from './bots.js';
 export { LicenseServerAiAgent } from './agent.js';

package/src/server.js

@@ -39,16 +39,14 @@ import {
     calculateRegionPartnerQuota,
     PUBLIC_OFERTA,
 } from './catalog.js';
-import { LicenseStore } from './store.js';
+import { LicenseStore, resolvePersistentDataDir } from './store.js';
 import { YooKassaService } from './yookassa.js';
 import { SupportBotsHub } from './bots.js';
 import { LicenseServerAiAgent } from './agent.js';
 import { renderLandingPage, renderSandboxPaymentPage } from './landing.js';
 import { renderAdminPage } from './admin.js';
 
-const DEFAULT_DATA_DIR = fileURLToPath(new URL('../data', import.meta.url));
-
-async function readJsonBody(req, maxBytes = 1024 * 1024) {
+async function readJsonBody(req, maxBytes = 16 * 1024 * 1024) {
     const chunks = [];
     let size = 0;
     for await (const ch of req) {
@@ -284,10 +282,12 @@ async function sendOtpEmail({ to, code }) {
 export function createLicenseServerApp(options = {}) {
     const pendingOtpCodes = new Map(); // email -> { code, expiresAt, attempts }
     const store = options.store || new LicenseStore({
-        dataDir: options.dataDir || DEFAULT_DATA_DIR,
+        dataDir: options.dataDir || resolvePersistentDataDir(),
         adminLogin: options.adminLogin,
         adminPassword: options.adminPassword,
         publicOrigin: options.publicOrigin || 'https://work.odant.org',
+        autoRecover: options.autoRecover,
+        extraSearchRoots: options.extraSearchRoots,
     });
     let bots = null;
     const yookassa = options.yookassa || new YooKassaService({
@@ -986,6 +986,8 @@ export function createLicenseServerApp(options = {}) {
                     return sendJson(res, 401, { error: 'Требуется авторизация администратора (/admin)' });
                 const allFranchises = store.listAllFranchises();
                 return sendJson(res, 200, {
+                    dataDir: store.dataDir,
+                    counts: store.getStoreCounts(),
                     licenses: store.listLicenses(),
                     tickets: store.listTickets(),
                     orders: Object.values(store.state.orders).sort((a, b) => (b.createdAt || 0) - (a.createdAt || 0)),
@@ -997,6 +999,40 @@ export function createLicenseServerApp(options = {}) {
                 });
             }
 
+            if (req.method === 'GET' && pathname === '/api/admin/backup/export') {
+                const tok = extractBearerToken(req, null, url);
+                if (!store.verifyAdminToken(tok))
+                    return sendJson(res, 401, { error: 'Требуется авторизация администратора (/admin)' });
+                const bundle = store.exportBackupBundle();
+                const dayStr = new Date().toISOString().slice(0, 10);
+                const body = JSON.stringify(bundle, null, 2);
+                res.writeHead(200, {
+                    'Content-Type': 'application/json; charset=utf-8',
+                    'Content-Disposition': `attachment; filename="odant-work-license-backup-${dayStr}.json"`,
+                    'Access-Control-Allow-Origin': '*',
+                });
+                res.end(body);
+                return;
+            }
+
+            if (req.method === 'POST' && pathname === '/api/admin/backup/import') {
+                const body = await readJsonBody(req);
+                const tok = extractBearerToken(req, body, url);
+                if (!store.verifyAdminToken(tok))
+                    return sendJson(res, 401, { error: 'Требуется авторизация администратора (/admin)' });
+                const result = store.importBackupBundle(body.backup || body, { mode: body.mode || 'merge' });
+                return sendJson(res, 200, result);
+            }
+
+            if (req.method === 'POST' && pathname === '/api/admin/backup/recover') {
+                const body = await readJsonBody(req);
+                const tok = extractBearerToken(req, body, url);
+                if (!store.verifyAdminToken(tok))
+                    return sendJson(res, 401, { error: 'Требуется авторизация администратора (/admin)' });
+                const result = store.recoverFromExternalLocations({ extraSearchRoots: body.extraSearchRoots || [] });
+                return sendJson(res, 200, result);
+            }
+
             if (req.method === 'POST' && pathname === '/api/admin/servers/manage') {
                 const body = await readJsonBody(req);
                 const tok = extractBearerToken(req, body, url);

package/src/store.js

@@ -6,8 +6,10 @@
  *  - Тикеты техподдержки с расчётом SLA времени реакции и лимитов обращений по уровням Start / Business / Enterprise.
  */
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import crypto from 'node:crypto';
+import { fileURLToPath } from 'node:url';
 import {
     PAK_PRODUCT,
     BASE_LICENSE_PRODUCT,
@@ -70,14 +72,473 @@ export function buildFranchisePaymentSchedule({
     return schedule;
 }
 
+/**
+ * Проверить, указывает ли путь внутрь временного кэша npx / npm или папки node_modules.
+ * Хранить базу данных внутри таких папок недопустимо, так как при обновлении версии npx создаёт новый хэш-каталог.
+ */
+export function isEphemeralPackagePath(dirPath = '') {
+    const norm = String(dirPath || '').replace(/\\/g, '/').toLowerCase();
+    return norm.includes('/_npx/') || norm.includes('/node_modules/') || norm.includes('/npm-cache/');
+}
+
+/**
+ * Проверить, является ли директория изолированной временной папкой автотестов.
+ */
+export function isTestTempPath(dirPath = '') {
+    const full = path.resolve(String(dirPath || ''));
+    const norm = full.replace(/\\/g, '/').toLowerCase();
+    const tmpNorm = os.tmpdir().replace(/\\/g, '/').toLowerCase();
+    if (tmpNorm && norm.startsWith(tmpNorm))
+        return true;
+    return norm.includes('fake-hub-data')
+        || norm.includes('work-lic-')
+        || norm.includes('work-npx-test')
+        || norm.includes('/temp/opencode/');
+}
+
+/**
+ * Постоянное зеркало базы данных в профиле пользователя ОС (~/.odant-work-license/data).
+ */
+export function getHomeMirrorDataDir() {
+    if (process.env.WORK_LICENSE_HOME_MIRROR)
+        return path.resolve(process.env.WORK_LICENSE_HOME_MIRROR);
+    return path.join(os.homedir(), '.odant-work-license', 'data');
+}
+
+/**
+ * Определить постоянную папку хранения базы данных лицензионного сервера:
+ *  1) Явная переменная окружения WORK_LICENSE_DATA_DIR;
+ *  2) Явно переданный requestedDir (если он не указывает внутрь временного кэша _npx / node_modules);
+ *  3) Постоянная папка внутри рабочей директории запуска (например, <WORK>/data или <WORK>/license-server/data);
+ *  4) Защищённое системное хранилище в домашнем профиле ОС (~/.odant-work-license/data).
+ */
+export function resolvePersistentDataDir({
+    requestedDir = '',
+    cwd = process.cwd(),
+    env = process.env,
+} = {}) {
+    if (env?.WORK_LICENSE_DATA_DIR && String(env.WORK_LICENSE_DATA_DIR).trim()) {
+        return path.resolve(String(env.WORK_LICENSE_DATA_DIR).trim());
+    }
+    if (requestedDir && requestedDir !== './data' && !isEphemeralPackagePath(requestedDir)) {
+        return path.resolve(requestedDir);
+    }
+    const cleanCwd = path.resolve(cwd || process.cwd());
+    if (!isEphemeralPackagePath(cleanCwd)) {
+        const lsData = path.join(cleanCwd, 'license-server', 'data');
+        if (fs.existsSync(path.join(lsData, 'store.json')))
+            return lsData;
+        const sysData = path.join(cleanCwd, '#system', 'license-server');
+        if (fs.existsSync(path.join(sysData, 'store.json')))
+            return sysData;
+        return path.join(cleanCwd, 'data');
+    }
+    return getHomeMirrorDataDir();
+}
+
+/**
+ * Найти все возможные папки на диске (включая старые хэш-каталоги ~/.npm/_npx/* и %LOCALAPPDATA%/npm-cache/_npx/*),
+ * где могли остаться данные от предыдущих запусков через npx.
+ */
+export function findCandidateRecoveryDirs({
+    primaryDir = '',
+    cwd = process.cwd(),
+    extraSearchRoots = [],
+    includeSystemDefaults = true,
+} = {}) {
+    const seen = new Set();
+    const dirs = [];
+    const addDir = (d) => {
+        if (!d) return;
+        try {
+            const full = path.resolve(d);
+            const key = process.platform === 'win32' ? full.toLowerCase() : full;
+            if (seen.has(key)) return;
+            seen.add(key);
+            if (fs.existsSync(full))
+                dirs.push(full);
+        }
+        catch { /* ignore */ }
+    };
+
+    addDir(primaryDir);
+    addDir(getHomeMirrorDataDir());
+
+    const npxRoots = new Set();
+    const addNpxRoot = (r) => {
+        if (!r) return;
+        try {
+            const full = path.resolve(r);
+            if (fs.existsSync(full))
+                npxRoots.add(full);
+        }
+        catch { /* ignore */ }
+    };
+
+    for (const root of (extraSearchRoots || [])) {
+        addDir(root);
+        addNpxRoot(root);
+        addNpxRoot(path.join(root, '_npx'));
+    }
+
+    if (includeSystemDefaults) {
+        const cleanCwd = path.resolve(cwd || process.cwd());
+        if (!isEphemeralPackagePath(cleanCwd)) {
+            addDir(path.join(cleanCwd, 'data'));
+            addDir(path.join(cleanCwd, '#system', 'license-server'));
+            addDir(path.join(cleanCwd, 'license-server', 'data'));
+        }
+
+        try {
+            addDir(fileURLToPath(new URL('../data', import.meta.url)));
+        }
+        catch { /* ignore */ }
+
+        if (process.env.npm_config_cache)
+            addNpxRoot(path.join(process.env.npm_config_cache, '_npx'));
+        addNpxRoot(path.join(os.homedir(), '.npm', '_npx'));
+        addNpxRoot(path.join(os.homedir(), '.npm-cache', '_npx'));
+        addNpxRoot('/root/.npm/_npx');
+
+        if (process.platform !== 'win32' && fs.existsSync('/home')) {
+            try {
+                for (const entry of fs.readdirSync('/home', { withFileTypes: true })) {
+                    if (entry.isDirectory()) {
+                        addNpxRoot(path.join('/home', entry.name, '.npm', '_npx'));
+                        addDir(path.join('/home', entry.name, '.odant-work-license', 'data'));
+                    }
+                }
+            }
+            catch { /* ignore */ }
+        }
+
+        if (process.env.LOCALAPPDATA)
+            addNpxRoot(path.join(process.env.LOCALAPPDATA, 'npm-cache', '_npx'));
+        if (process.env.APPDATA) {
+            addNpxRoot(path.join(process.env.APPDATA, 'npm-cache', '_npx'));
+            addDir(path.join(process.env.APPDATA, 'npm', 'node_modules', 'work-license-server', 'data'));
+        }
+        addNpxRoot(path.join(os.homedir(), 'AppData', 'Local', 'npm-cache', '_npx'));
+        addNpxRoot(path.join(os.homedir(), 'AppData', 'Roaming', 'npm-cache', '_npx'));
+
+        addDir('/usr/local/lib/node_modules/work-license-server/data');
+        addDir('/usr/lib/node_modules/work-license-server/data');
+    }
+
+    for (const npxRoot of npxRoots) {
+        try {
+            const entries = fs.readdirSync(npxRoot, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory()) continue;
+                const hashDir = path.join(npxRoot, entry.name);
+                addDir(path.join(hashDir, 'node_modules', 'work-license-server', 'data'));
+                addDir(path.join(hashDir, 'node_modules', 'odant-work', 'license-server', 'data'));
+                addDir(path.join(hashDir, 'node_modules', 'odant-work', 'data'));
+            }
+        }
+        catch { /* ignore */ }
+    }
+
+    return dirs;
+}
+
+function isAutoPlaceholderLicense(lic, allOrders = {}) {
+    if (!lic || typeof lic !== 'object') return false;
+    if (lic.baseActivated) return false;
+    if (lic.hardware?.hwidBound || lic.hardware?.nodeFingerprint) return false;
+    if (Array.isArray(lic.addonSubscriptions) && lic.addonSubscriptions.length > 0) return false;
+    if (Array.isArray(lic.paidOrderIds) && lic.paidOrderIds.length > 0) return false;
+    const name = String(lic.serverName || '').trim();
+    if (name && name !== 'Сервер WORK #1' && name !== 'Сервер WORK') return false;
+    const hasOrders = Object.values(allOrders || {}).some(o => o && o.licenseId === lic.licenseId && o.status !== 'canceled');
+    return !hasOrders;
+}
+
+/**
+ * Безопасное объединение (merge без потери записей) двух состояний store.json.
+ * Сохраняет всех пользователей, их реквизиты, токены привязки (owk1...), серверы/лицензии,
+ * заказы, франшизы, партнёров, тикеты и привязки ботов.
+ */
+export function mergeStoreStates(baseState = {}, incomingState = {}) {
+    const out = {
+        licenses: { ...(baseState.licenses || {}) },
+        orders: { ...(baseState.orders || {}) },
+        tickets: { ...(baseState.tickets || {}) },
+        botBindings: { ...(baseState.botBindings || {}) },
+        partners: { ...(baseState.partners || {}) },
+        reservations: { ...(baseState.reservations || {}) },
+        certificates: { ...(baseState.certificates || {}) },
+        users: { ...(baseState.users || {}) },
+    };
+
+    // 1. Заказы (предпочитаем оплаченные или более свежие)
+    for (const [orderId, incOrd] of Object.entries(incomingState.orders || {})) {
+        if (!incOrd || !orderId) continue;
+        const curOrd = out.orders[orderId];
+        if (!curOrd) {
+            out.orders[orderId] = structuredClone(incOrd);
+            continue;
+        }
+        if (incOrd.status === 'paid' && curOrd.status !== 'paid') {
+            out.orders[orderId] = { ...curOrd, ...structuredClone(incOrd) };
+        }
+        else if (curOrd.status === 'paid' && incOrd.status !== 'paid') {
+            out.orders[orderId] = { ...structuredClone(incOrd), ...curOrd };
+        }
+        else {
+            const incTs = Number(incOrd.paidAt || incOrd.updatedAt || incOrd.createdAt || 0);
+            const curTs = Number(curOrd.paidAt || curOrd.updatedAt || curOrd.createdAt || 0);
+            out.orders[orderId] = incTs >= curTs
+                ? { ...curOrd, ...structuredClone(incOrd) }
+                : { ...structuredClone(incOrd), ...curOrd };
+        }
+    }
+
+    // 2. Серверы / Лицензии
+    for (const [licId, incLic] of Object.entries(incomingState.licenses || {})) {
+        if (!incLic || !licId) continue;
+        const curLic = out.licenses[licId];
+        if (!curLic) {
+            out.licenses[licId] = structuredClone(incLic);
+            continue;
+        }
+        const incTs = Number(incLic.updatedAt || incLic.issuedAt || 0);
+        const curTs = Number(curLic.updatedAt || curLic.issuedAt || 0);
+        const [older, newer] = incTs >= curTs ? [curLic, incLic] : [incLic, curLic];
+
+        const mergedAddonsMap = new Map();
+        for (const sub of [...(older.addonSubscriptions || []), ...(newer.addonSubscriptions || [])]) {
+            if (!sub) continue;
+            const key = sub.id || sub.orderId || JSON.stringify(sub);
+            mergedAddonsMap.set(key, sub);
+        }
+        const mergedPaidOrders = Array.from(new Set([
+            ...(older.paidOrderIds || []),
+            ...(newer.paidOrderIds || []),
+        ]));
+
+        const mergedCustomer = { ...(older.customer || {}), ...(newer.customer || {}) };
+        for (const k of ['name', 'inn', 'kpp', 'legalAddress', 'email', 'phone']) {
+            const vNew = String(newer.customer?.[k] || '').trim();
+            const vOld = String(older.customer?.[k] || '').trim();
+            mergedCustomer[k] = vNew || vOld;
+        }
+
+        const mergedHardware = (newer.hardware?.hwidBound || !older.hardware?.hwidBound)
+            ? { ...(older.hardware || {}), ...(newer.hardware || {}) }
+            : { ...(newer.hardware || {}), ...(older.hardware || {}) };
+
+        const pickServerName = (newer.serverName && newer.serverName !== 'Сервер WORK #1' && newer.serverName !== 'Сервер WORK')
+            ? newer.serverName
+            : (older.serverName || newer.serverName || 'Сервер WORK #1');
+
+        out.licenses[licId] = {
+            ...older,
+            ...newer,
+            serverName: pickServerName,
+            baseActivated: Boolean(older.baseActivated || newer.baseActivated),
+            perpetualBase: Boolean(older.perpetualBase || newer.perpetualBase || older.baseActivated || newer.baseActivated),
+            baseSeats: Math.max(Number(older.baseSeats || 0), Number(newer.baseSeats || 0), PAK_PRODUCT.baseSeats),
+            issuedAt: Math.min(Number(older.issuedAt || Date.now()), Number(newer.issuedAt || Date.now())),
+            updatedAt: Math.max(incTs, curTs),
+            hubToken: older.hubToken || newer.hubToken || '',
+            hubTokenId: older.hubTokenId || newer.hubTokenId || '',
+            hubTokenSecret: older.hubTokenSecret || newer.hubTokenSecret || '',
+            customer: mergedCustomer,
+            hardware: mergedHardware,
+            addonSubscriptions: Array.from(mergedAddonsMap.values()),
+            paidOrderIds: mergedPaidOrders,
+        };
+    }
+
+    // 3. Пользователи Личного кабинета и администраторы
+    for (const [rawKey, incUser] of Object.entries(incomingState.users || {})) {
+        if (!incUser || typeof incUser !== 'object') continue;
+        const email = String(incUser.email || rawKey || '').trim().toLowerCase();
+        if (!email) continue;
+        const curUser = out.users[email];
+        if (!curUser) {
+            out.users[email] = { ...structuredClone(incUser), email };
+            continue;
+        }
+
+        const emailPrefix = email.split('@')[0];
+        const isRealName = (val) => {
+            const s = String(val || '').trim();
+            return Boolean(s && s.toLowerCase() !== emailPrefix && s !== 'Организация ODANT-WORK' && !s.includes('@'));
+        };
+
+        const curCreated = Number(curUser.createdAt || Date.now());
+        const incCreated = Number(incUser.createdAt || Date.now());
+        const [olderU, newerU] = incCreated >= curCreated ? [curUser, incUser] : [incUser, curUser];
+
+        const mergedUser = {
+            ...olderU,
+            ...newerU,
+            userId: olderU.userId || newerU.userId,
+            email,
+            isAdmin: Boolean(curUser.isAdmin || incUser.isAdmin),
+            role: (curUser.isAdmin || incUser.isAdmin) ? 'ADMIN' : 'CLIENT',
+            createdAt: Math.min(curCreated, incCreated),
+            lastLoginAt: Math.max(Number(curUser.lastLoginAt || 0), Number(incUser.lastLoginAt || 0)),
+            name: isRealName(newerU.name) ? newerU.name : (isRealName(olderU.name) ? olderU.name : (newerU.name || olderU.name || emailPrefix)),
+            companyName: isRealName(newerU.companyName) ? newerU.companyName : (isRealName(olderU.companyName) ? olderU.companyName : (newerU.companyName || olderU.companyName || '')),
+            hubToken: olderU.hubToken || newerU.hubToken || '',
+            hubTokenId: olderU.hubTokenId || newerU.hubTokenId || '',
+            hubTokenSecret: olderU.hubTokenSecret || newerU.hubTokenSecret || '',
+            hubUrl: newerU.hubUrl || olderU.hubUrl || 'https://work.odant.org',
+            sessionKey: newerU.sessionKey || olderU.sessionKey || '',
+            ofertaAccepted: Boolean(curUser.ofertaAccepted || incUser.ofertaAccepted),
+            ofertaAcceptedAt: olderU.ofertaAcceptedAt || newerU.ofertaAcceptedAt || null,
+            ofertaVersion: newerU.ofertaVersion || olderU.ofertaVersion || '',
+            ofertaSignerName: isRealName(newerU.ofertaSignerName) ? newerU.ofertaSignerName : (olderU.ofertaSignerName || newerU.ofertaSignerName || ''),
+            ofertaSignatureId: olderU.ofertaSignatureId || newerU.ofertaSignatureId || '',
+        };
+
+        for (const field of ['position', 'inn', 'kpp', 'legalAddress', 'signerName', 'signerPosition', 'bankName', 'bik', 'bankAccount', 'corrAccount', 'phone']) {
+            const vNew = String(newerU[field] || '').trim();
+            const vOld = String(olderU[field] || '').trim();
+            mergedUser[field] = vNew || vOld;
+        }
+
+        out.users[email] = mergedUser;
+    }
+
+    // 4. Очистка пустых дублей «Сервер WORK #1», автоматически созданных при входе в пустую БД после перезапуска npx
+    for (const user of Object.values(out.users)) {
+        if (!user) continue;
+        const uEmail = String(user.email || '').toLowerCase();
+        const userLics = Object.values(out.licenses).filter(l => l && (
+            (user.userId && l.ownerAccountId === user.userId)
+            || (uEmail && String(l.ownerEmail || l.customer?.email || '').toLowerCase() === uEmail)
+        )).sort((a, b) => (a.issuedAt || 0) - (b.issuedAt || 0));
+
+        if (userLics.length > 1) {
+            const nonPlaceholders = userLics.filter(l => !isAutoPlaceholderLicense(l, out.orders));
+            const keepList = nonPlaceholders.length > 0 ? nonPlaceholders : [userLics[0]];
+            const keepIds = new Set(keepList.map(l => l.licenseId));
+            for (const l of userLics) {
+                if (!keepIds.has(l.licenseId) && isAutoPlaceholderLicense(l, out.orders)) {
+                    delete out.licenses[l.licenseId];
+                }
+            }
+            const remaining = userLics.filter(l => out.licenses[l.licenseId]);
+            if (remaining.length > 0 && (!user.licenseId || !out.licenses[user.licenseId])) {
+                const best = remaining.find(l => l.baseActivated || l.hardware?.hwidBound) || remaining[0];
+                user.licenseId = best.licenseId;
+            }
+        }
+        else if (userLics.length === 1) {
+            user.licenseId = userLics[0].licenseId;
+        }
+    }
+
+    // 5. Резервы франшиз и 12-месячные графики платежей
+    for (const [resId, incRes] of Object.entries(incomingState.reservations || {})) {
+        if (!incRes || !resId) continue;
+        const curRes = out.reservations[resId];
+        if (!curRes) {
+            out.reservations[resId] = structuredClone(incRes);
+            continue;
+        }
+        const mergedSchedule = buildFranchisePaymentSchedule({
+            remainingRub: incRes.remainingFranchiseFeeRub ?? curRes.remainingFranchiseFeeRub ?? 0,
+            startMs: Math.min(Number(curRes.createdAt || Date.now()), Number(incRes.createdAt || Date.now())),
+            existingSchedule: (curRes.paymentSchedule || []).map((item, idx) => {
+                const incItem = (incRes.paymentSchedule || [])[idx];
+                if (incItem?.status === 'paid' && item.status !== 'paid') return incItem;
+                return item;
+            }),
+        });
+        out.reservations[resId] = {
+            ...curRes,
+            ...incRes,
+            depositPaid: Boolean(curRes.depositPaid || incRes.depositPaid),
+            paidInstallmentsRub: Math.max(Number(curRes.paidInstallmentsRub || 0), Number(incRes.paidInstallmentsRub || 0)),
+            totalPaidRub: Math.max(Number(curRes.totalPaidRub || 0), Number(incRes.totalPaidRub || 0)),
+            paymentSchedule: mergedSchedule,
+        };
+    }
+
+    // 6. Партнёры, тикеты, привязки ботов и сертификаты специалистов
+    for (const [pId, incP] of Object.entries(incomingState.partners || {})) {
+        if (!incP || !pId) continue;
+        const curP = out.partners[pId];
+        if (!curP) {
+            out.partners[pId] = structuredClone(incP);
+            continue;
+        }
+        const issuedLicenses = Array.from(new Set([...(curP.issuedLicenses || []), ...(incP.issuedLicenses || [])]));
+        const certMap = new Map();
+        for (const c of [...(curP.certifiedSpecialists || []), ...(incP.certifiedSpecialists || [])]) {
+            if (c) certMap.set(c.certificateId || `${c.email}:${c.trackId}`, c);
+        }
+        out.partners[pId] = {
+            ...curP,
+            ...incP,
+            annualSalesRub: Math.max(Number(curP.annualSalesRub || 0), Number(incP.annualSalesRub || 0)),
+            issuedLicenses,
+            certifiedSpecialists: Array.from(certMap.values()),
+        };
+    }
+
+    for (const [tId, incT] of Object.entries(incomingState.tickets || {})) {
+        if (!incT || !tId) continue;
+        const curT = out.tickets[tId];
+        if (!curT) {
+            out.tickets[tId] = structuredClone(incT);
+            continue;
+        }
+        const msgMap = new Map();
+        for (const m of [...(curT.messages || []), ...(incT.messages || [])]) {
+            if (m) msgMap.set(`${m.time}:${m.author}:${m.text}`, m);
+        }
+        out.tickets[tId] = {
+            ...curT,
+            ...incT,
+            messages: Array.from(msgMap.values()).sort((a, b) => (a.time || 0) - (b.time || 0)),
+        };
+    }
+
+    Object.assign(out.botBindings, incomingState.botBindings || {});
+    Object.assign(out.certificates, incomingState.certificates || {});
+
+    return out;
+}
+
 export class LicenseStore {
-    constructor({ dataDir = './data', adminLogin = '', adminPassword = '', publicOrigin = 'https://work.odant.org' } = {}) {
-        this.dataDir = dataDir;
+    constructor({
+        dataDir = '',
+        adminLogin = '',
+        adminPassword = '',
+        publicOrigin = 'https://work.odant.org',
+        autoRecover = undefined,
+        extraSearchRoots = [],
+    } = {}) {
+        const isExplicitDir = Boolean(
+            dataDir && dataDir !== './data' && (autoRecover === false || !isEphemeralPackagePath(dataDir))
+        );
+        this.dataDir = isExplicitDir
+            ? path.resolve(dataDir)
+            : resolvePersistentDataDir({ requestedDir: dataDir });
+        this.autoRecover = autoRecover !== undefined
+            ? Boolean(autoRecover)
+            : !isTestTempPath(this.dataDir);
+        this.extraSearchRoots = Array.isArray(extraSearchRoots) ? extraSearchRoots : [];
+
         fs.mkdirSync(this.dataDir, { recursive: true });
+        this.backupDir = path.join(this.dataDir, 'backups');
         this.stateFile = path.join(this.dataDir, 'store.json');
+        this.prevStateFile = path.join(this.dataDir, 'store.prev.json');
         this.keyFile = path.join(this.dataDir, 'authority-key.json');
+
+        // Если в новой постоянной папке ещё нет authority-key.json, восстанавливаем его из прежних папок / кэша npx
+        if (this.autoRecover && !fs.existsSync(this.keyFile)) {
+            this._recoverAuthorityKeyFromCandidates();
+        }
+
         const isOfficialOrigin = !publicOrigin || String(publicOrigin).includes('work.odant.org') || String(publicOrigin).includes('localhost');
-        const isFakeTestDir = String(dataDir).includes('fake-hub-data');
+        const isFakeTestDir = String(this.dataDir).includes('fake-hub-data');
         this.authorityKeys = loadOrCreateAuthorityKeys(this.keyFile, {
             useCanonicalFallback: isOfficialOrigin && !isFakeTestDir,
         });
@@ -85,6 +546,7 @@ export class LicenseStore {
         this.adminPassword = String(adminPassword || process.env.WORK_ADMIN_PASSWORD || process.env.WORK_ADMIN_KEY || 'odant-admin');
         this.adminSessions = new Map();
         this.revokedSessions = new Set();
+        this._readFailedGuard = false;
 
         this.state = {
             licenses: {},
@@ -216,25 +678,257 @@ export class LicenseStore {
         return this._formatUserResponse(user);
     }
 
+    _recoverAuthorityKeyFromCandidates() {
+        const allRoots = [...this.extraSearchRoots];
+        const dirs = findCandidateRecoveryDirs({
+            primaryDir: this.dataDir,
+            extraSearchRoots: allRoots,
+            includeSystemDefaults: !(isTestTempPath(this.dataDir) && allRoots.length > 0),
+        });
+        let bestKeyFile = '';
+        let bestMtime = 0;
+        for (const d of dirs) {
+            const kf = path.join(d, 'authority-key.json');
+            if (path.resolve(kf) === path.resolve(this.keyFile)) continue;
+            try {
+                if (!fs.existsSync(kf)) continue;
+                const stat = fs.statSync(kf);
+                const parsed = JSON.parse(fs.readFileSync(kf, 'utf8'));
+                if (parsed?.publicKey && parsed?.privateKey && stat.mtimeMs >= bestMtime) {
+                    bestKeyFile = kf;
+                    bestMtime = stat.mtimeMs;
+                }
+            }
+            catch { /* ignore */ }
+        }
+        if (bestKeyFile) {
+            try {
+                fs.mkdirSync(path.dirname(this.keyFile), { recursive: true });
+                fs.copyFileSync(bestKeyFile, this.keyFile);
+                console.log(`[work.odant.org] Восстановлен ключ ЦС authority-key.json из: ${bestKeyFile}`);
+            }
+            catch { /* ignore */ }
+        }
+    }
+
+    _tryParseStateFile(filePath) {
+        try {
+            if (!filePath || !fs.existsSync(filePath)) return null;
+            const text = fs.readFileSync(filePath, 'utf8').trim();
+            if (!text) return null;
+            const raw = JSON.parse(text);
+            const stateObj = (raw?.state && typeof raw.state === 'object' && (raw.state.users || raw.state.licenses))
+                ? raw.state
+                : raw;
+            if (!stateObj || typeof stateObj !== 'object') return null;
+            return {
+                licenses: stateObj.licenses || {},
+                orders: stateObj.orders || {},
+                tickets: stateObj.tickets || {},
+                botBindings: stateObj.botBindings || {},
+                partners: stateObj.partners || {},
+                reservations: stateObj.reservations || {},
+                certificates: stateObj.certificates || {},
+                users: stateObj.users || {},
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+
+    getStoreCounts(state = this.state) {
+        return {
+            users: Object.keys(state?.users || {}).length,
+            licenses: Object.keys(state?.licenses || {}).length,
+            orders: Object.keys(state?.orders || {}).length,
+            reservations: Object.keys(state?.reservations || {}).length,
+            partners: Object.keys(state?.partners || {}).length,
+            tickets: Object.keys(state?.tickets || {}).length,
+        };
+    }
+
     _load() {
-        if (!fs.existsSync(this.stateFile))
-            return;
+        let loaded = this._tryParseStateFile(this.stateFile);
+        const mainExistsNonEmpty = fs.existsSync(this.stateFile) && fs.statSync(this.stateFile).size > 50;
+
+        if (!loaded && mainExistsNonEmpty) {
+            console.warn(`[work.odant.org] Внимание: не удалось прочитать ${this.stateFile}, проверяем резервные копии...`);
+            loaded = this._tryParseStateFile(this.prevStateFile);
+            if (!loaded && fs.existsSync(this.backupDir)) {
+                try {
+                    const bFiles = fs.readdirSync(this.backupDir)
+                        .filter(f => f.endsWith('.json'))
+                        .sort()
+                        .reverse();
+                    for (const bf of bFiles) {
+                        loaded = this._tryParseStateFile(path.join(this.backupDir, bf));
+                        if (loaded) {
+                            console.log(`[work.odant.org] Состояние восстановлено из резервной копии: ${bf}`);
+                            break;
+                        }
+                    }
+                }
+                catch { /* ignore */ }
+            }
+            if (!loaded) {
+                this._readFailedGuard = true;
+            }
+        }
+
+        if (loaded) {
+            this.state = mergeStoreStates(this.state, loaded);
+        }
+
+        if (this.autoRecover) {
+            this.recoverFromExternalLocations({ silentIfZero: true });
+        }
+        else if (loaded) {
+            this._ensureBootstrapAdmin();
+            this._resignAllWithAuthority();
+        }
+    }
+
+    /**
+     * Просканировать кэш npx (~/.npm/_npx/*, %LOCALAPPDATA%/npm-cache/_npx/*), домашнее зеркало и рабочие папки,
+     * и безопасно объединить все найденные записи store.json в текущую постоянную базу данных.
+     */
+    recoverFromExternalLocations({ extraSearchRoots = [], silentIfZero = false } = {}) {
+        const allRoots = [...this.extraSearchRoots, ...(extraSearchRoots || [])];
+        const dirs = findCandidateRecoveryDirs({
+            primaryDir: this.dataDir,
+            extraSearchRoots: allRoots,
+            includeSystemDefaults: !(isTestTempPath(this.dataDir) && allRoots.length > 0),
+        });
+
+        const candidates = [];
+        for (const d of dirs) {
+            const sf = path.join(d, 'store.json');
+            if (path.resolve(sf) === path.resolve(this.stateFile)) continue;
+            try {
+                if (!fs.existsSync(sf)) continue;
+                const stat = fs.statSync(sf);
+                const parsed = this._tryParseStateFile(sf);
+                if (!parsed) continue;
+                const counts = this.getStoreCounts(parsed);
+                const totalItems = counts.users + counts.licenses + counts.orders + counts.reservations + counts.partners + counts.tickets;
+                if (totalItems > 0) {
+                    candidates.push({ file: sf, dir: d, mtimeMs: stat.mtimeMs, parsed, counts });
+                }
+            }
+            catch { /* ignore */ }
+        }
+
+        // Сортируем от более старых к более новым, чтобы более свежие изменения дополняли старые
+        candidates.sort((a, b) => a.mtimeMs - b.mtimeMs);
+
+        const beforeCounts = this.getStoreCounts(this.state);
+        const mergedSources = [];
+
+        for (const item of candidates) {
+            this.state = mergeStoreStates(this.state, item.parsed);
+            mergedSources.push({
+                file: item.file,
+                counts: item.counts,
+            });
+        }
+
+        this._ensureBootstrapAdmin();
+        this._resignAllWithAuthority();
+
+        const afterCounts = this.getStoreCounts(this.state);
+        const addedOrMerged = (afterCounts.users > beforeCounts.users)
+            || (afterCounts.licenses > beforeCounts.licenses)
+            || (afterCounts.orders > beforeCounts.orders)
+            || (afterCounts.reservations > beforeCounts.reservations)
+            || !fs.existsSync(this.stateFile);
+
+        if (mergedSources.length > 0 && addedOrMerged) {
+            this._readFailedGuard = false;
+            try { this._save(); } catch { /* ignore */ }
+            if (!silentIfZero || afterCounts.users > beforeCounts.users || afterCounts.licenses > beforeCounts.licenses) {
+                console.log(
+                    `[work.odant.org] Автовосстановление данных (источников: ${mergedSources.length}): `
+                    + `пользователей=${afterCounts.users}, серверов/лицензий=${afterCounts.licenses}, `
+                    + `заказов=${afterCounts.orders}, франшиз=${afterCounts.reservations}`
+                );
+            }
+        }
+
+        return {
+            ok: true,
+            dataDir: this.dataDir,
+            scannedDirs: dirs,
+            mergedSources,
+            beforeCounts,
+            counts: afterCounts,
+        };
+    }
+
+    /**
+     * Сформировать полный пакет резервной копии базы данных для скачивания из /admin.
+     */
+    exportBackupBundle() {
+        let backups = [];
         try {
-            const raw = JSON.parse(fs.readFileSync(this.stateFile, 'utf8'));
-            if (raw && typeof raw === 'object') {
-                this.state.licenses = raw.licenses || {};
-                this.state.orders = raw.orders || {};
-                this.state.tickets = raw.tickets || {};
-                this.state.botBindings = raw.botBindings || {};
-                this.state.partners = raw.partners || {};
-                this.state.reservations = raw.reservations || {};
-                this.state.certificates = raw.certificates || {};
-                this.state.users = raw.users || {};
-                this._ensureBootstrapAdmin();
-                this._resignAllWithAuthority();
+            if (fs.existsSync(this.backupDir)) {
+                backups = fs.readdirSync(this.backupDir)
+                    .filter(f => f.endsWith('.json'))
+                    .sort()
+                    .reverse()
+                    .slice(0, 14);
             }
         }
-        catch { /* начинаем с чистого состояния */ }
+        catch { /* ignore */ }
+
+        return {
+            schema: 'ODANT-WORK-LICENSE-STORE-BACKUP-v1',
+            exportedAt: new Date().toISOString(),
+            dataDir: this.dataDir,
+            authorityPublicKey: this.authorityKeys.publicKey,
+            counts: this.getStoreCounts(this.state),
+            backups,
+            state: this.state,
+        };
+    }
+
+    /**
+     * Восстановить или безопасно объединить (merge) базу данных из резервной копии JSON.
+     */
+    importBackupBundle(payload = {}, { mode = 'merge' } = {}) {
+        const parsed = (payload?.state && typeof payload.state === 'object')
+            ? payload.state
+            : payload;
+        if (!parsed || typeof parsed !== 'object' || (!parsed.users && !parsed.licenses && !parsed.orders)) {
+            throw new Error('Некорректный формат файла резервной копии (ожидается JSON с разделами users / licenses / orders)');
+        }
+
+        // Перед импортом обязательно сохраняем страховочный снапшот текущего состояния
+        try {
+            fs.mkdirSync(this.backupDir, { recursive: true });
+            const preFile = path.join(this.backupDir, `store-pre-import-${Date.now()}.json`);
+            fs.writeFileSync(preFile, JSON.stringify(this.state, null, 2), 'utf8');
+        }
+        catch { /* ignore */ }
+
+        if (mode === 'replace') {
+            this.state = mergeStoreStates({}, parsed);
+        }
+        else {
+            this.state = mergeStoreStates(this.state, parsed);
+        }
+
+        this._readFailedGuard = false;
+        this._ensureBootstrapAdmin();
+        this._resignAllWithAuthority();
+        this._save();
+
+        return {
+            ok: true,
+            mode: mode === 'replace' ? 'replace' : 'merge',
+            dataDir: this.dataDir,
+            counts: this.getStoreCounts(this.state),
+        };
     }
 
     /**
@@ -294,9 +988,60 @@ export class LicenseStore {
     }
 
     _save() {
-        const tmp = `${this.stateFile}.${process.pid}.tmp`;
-        fs.writeFileSync(tmp, JSON.stringify(this.state, null, 2), 'utf8');
-        fs.renameSync(tmp, this.stateFile);
+        const counts = this.getStoreCounts(this.state);
+        const totalEntities = counts.users + counts.licenses + counts.orders + counts.reservations + counts.partners + counts.tickets;
+
+        // Защита от перезаписи непустого файла пустым состоянием при сбое чтения
+        if (this._readFailedGuard && totalEntities === 0) {
+            return;
+        }
+
+        fs.mkdirSync(this.dataDir, { recursive: true });
+
+        // Сохраняем предыдущую версию (store.prev.json) и ежедневный снапшот (backups/store-YYYY-MM-DD.json)
+        try {
+            if (fs.existsSync(this.stateFile) && fs.statSync(this.stateFile).size > 50) {
+                fs.copyFileSync(this.stateFile, this.prevStateFile);
+                if (totalEntities > 0) {
+                    fs.mkdirSync(this.backupDir, { recursive: true });
+                    const dayKey = new Date().toISOString().slice(0, 10);
+                    const dailyBackup = path.join(this.backupDir, `store-${dayKey}.json`);
+                    fs.copyFileSync(this.stateFile, dailyBackup);
+                }
+            }
+        }
+        catch { /* ignore */ }
+
+        const serialized = JSON.stringify(this.state, null, 2);
+        const writeAtomically = (destPath) => {
+            const tmp = `${destPath}.${process.pid}.${crypto.randomBytes(3).toString('hex')}.tmp`;
+            fs.writeFileSync(tmp, serialized, 'utf8');
+            try {
+                fs.renameSync(tmp, destPath);
+            }
+            catch {
+                fs.writeFileSync(destPath, serialized, 'utf8');
+                try { fs.unlinkSync(tmp); } catch { /* ignore */ }
+            }
+        };
+
+        writeAtomically(this.stateFile);
+
+        // Дублируем актуальную базу в системное зеркало профиля пользователя ОС (~/.odant-work-license/data),
+        // чтобы даже при запуске npx из другой папки данные всегда оставались едиными.
+        if (this.autoRecover && totalEntities > 0) {
+            try {
+                const mirrorDir = getHomeMirrorDataDir();
+                if (path.resolve(mirrorDir) !== path.resolve(this.dataDir)) {
+                    fs.mkdirSync(mirrorDir, { recursive: true });
+                    writeAtomically(path.join(mirrorDir, 'store.json'));
+                    if (fs.existsSync(this.keyFile)) {
+                        fs.copyFileSync(this.keyFile, path.join(mirrorDir, 'authority-key.json'));
+                    }
+                }
+            }
+            catch { /* ignore */ }
+        }
     }
 
     /**