neuroalpha 0.3.17 → 0.5.1

package/server/brokers/index.js

@@ -8,10 +8,16 @@ import { getSettings, normalizeParams } from '../settings.js';
 import { latestBarTs } from '../data/moex.js';
 import { barsFromHours, BAR_INTERVAL, BAR_MS } from '../model/dataset.js';
 import { forecastNow } from '../model/forecast.js';
+import { TIER1_LIQUID_SYMBOLS, symbolEdgeMult } from '../model/edge.js';
 import { MODELS } from '../model/models.js';
 import { blockingNews } from '../news/index.js';
-import { round, MSK, DAY } from '../util.js';
+import { round, MSK, DAY, fmtBarMsk } from '../util.js';
 import { hub } from '../hub.js';
+import { TRUSTED_CA } from '../tls-ca.js';
+import { tradingGate } from '../instance/agent.js';
+
+export const FULLY_SUPPORTED_BROKERS = ['tbank'];
+const MANUAL_BROKERS = ['sber', 'vtb', 'alfa'];
 
 export const BROKER_META = [
   {
@@ -111,13 +117,24 @@ export function roundToStep(price, minStep = 0.01, decimals = 2) {
   return Number(v.toFixed(Math.max(0, Math.min(6, decimals))));
 }
 
-export function calcLotOrder(symbol, targetSumRub, refPrice, action, offsetPct = 0.1, specs = {}) {
+// Снайперский расчёт лимитной цены (1-tick Limit):
+// отталкивается от живой секундной цены basePx и сдвигает её ровно на 1 минимальный шаг цены (minStep),
+// но не более заданного offsetPct, чтобы не переплачивать маркетмейкерам за пересечение спреда!
+export function sniperLimitPrice(basePx, dir, offsetPct = 0.02, sp = { minStep: 0.01, decimals: 2 }) {
+  const step = sp.minStep > 0 ? sp.minStep : 0.01;
+  const maxOffRatio = Math.max(0, Math.min(0.0005, (Number(offsetPct) || 0.02) / 100));
+  const byPct = basePx * (1 + dir * maxOffRatio);
+  const byOneTick = basePx + dir * step;
+  const rawLimit = dir > 0 ? Math.min(byPct, byOneTick) : Math.max(byPct, byOneTick);
+  return roundToStep(rawLimit, step, sp.decimals);
+}
+
+export function calcLotOrder(symbol, targetSumRub, refPrice, action, offsetPct = 0.02, specs = {}) {
   const sp = specs[symbol] || { lotSize: 1, minStep: 0.01, decimals: 2, lastPrice: 0 };
   const basePx = refPrice > 0 ? refPrice : sp.lastPrice;
   if (!(basePx > 0)) return null;
   const dir = action === 'buy' || action === 'cover' ? 1 : -1;
-  const rawLimit = basePx * (1 + dir * (Number(offsetPct) || 0) / 100);
-  const limitPrice = roundToStep(rawLimit, sp.minStep, sp.decimals);
+  const limitPrice = sniperLimitPrice(basePx, dir, offsetPct, sp);
   const lotCost = limitPrice * sp.lotSize;
   const lots = Math.floor(targetSumRub / lotCost);
   if (lots < 1) return null;
@@ -134,14 +151,132 @@ export function calcLotOrder(symbol, targetSumRub, refPrice, action, offsetPct =
   };
 }
 
-// ---------- хранение счетов (с изоляцией по user_id и AES-256-GCM шифрованием токенов) ----------
+// ---------- журнал исполнения: заявки, ошибки, стопы, ручные действия (по владельцу счёта) ----------
+db.exec(`CREATE TABLE IF NOT EXISTS broker_events (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  ts INTEGER NOT NULL,
+  user_id INTEGER NOT NULL,
+  account_id TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  text TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS broker_events_acc ON broker_events(user_id, account_id, ts);`);
+
+function logBrokerEvent(acc, kind, text) {
+  try {
+    const uid = currentUserId();
+    db.prepare('INSERT INTO broker_events (ts, user_id, account_id, kind, text) VALUES (?, ?, ?, ?, ?)')
+      .run(Date.now(), uid, String(acc?.id || ''), String(kind), String(text || '').slice(0, 500));
+    if (/error|stop|halt/.test(kind)) console.warn(`[брокер ${acc?.name || acc?.id}] ${kind}: ${text}`);
+    // храним последние 5000 событий на счёт
+    if (Math.random() < 0.02) {
+      db.prepare(`DELETE FROM broker_events WHERE user_id = ? AND account_id = ? AND id NOT IN
+        (SELECT id FROM broker_events WHERE user_id = ? AND account_id = ? ORDER BY id DESC LIMIT 5000)`).run(uid, String(acc?.id || ''), uid, String(acc?.id || ''));
+    }
+  } catch { /* журнал не должен ломать торговлю */ }
+}
+
+export function listBrokerEvents(accountId, limit = 200) {
+  return db.prepare('SELECT ts, kind, text FROM broker_events WHERE user_id = ? AND account_id = ? ORDER BY id DESC LIMIT ?')
+    .all(currentUserId(), String(accountId), Math.max(1, Math.min(1000, Number(limit) || 200)));
+}
+
+// ---------- хранение счетов: строка на счёт, изоляция по user_id, AES-256-GCM для токенов ----------
+// Синхронизация, пересчёт заявок, исполнение и сохранение настроек работают параллельно и между загрузкой
+// и записью ждут ответа брокера. Поэтому при сохранении пишутся ТОЛЬКО поля, изменённые этим участком кода,
+// поверх актуальной версии строки в транзакции — чужие изменения (дневной стоп, режим, пакет заявок) не затираются.
+db.exec(`CREATE TABLE IF NOT EXISTS broker_accounts (
+  user_id INTEGER NOT NULL,
+  id TEXT NOT NULL,
+  pos INTEGER NOT NULL DEFAULT 0,
+  data TEXT NOT NULL,
+  updated_at INTEGER NOT NULL,
+  PRIMARY KEY (user_id, id)
+)`);
+
+const SNAPSHOT = Symbol('brokerAccountsSnapshot');
+const fieldSnapshot = (a) => Object.fromEntries(Object.entries(a).map(([k, v]) => [k, JSON.stringify(v)]));
+const encryptAccount = (a) => ({ ...a, token: a.token ? encryptSecret(a.token) : '' });
+
+// Однократный перенос из прежнего хранения (один JSON на пользователя в kv)
+function migrateKvAccounts(uid) {
+  if (db.prepare('SELECT 1 FROM broker_accounts WHERE user_id = ? LIMIT 1').get(uid)) return;
+  if (userKvGet('brokerAccountsMigrated', false, uid)) return;
+  const old = userKvGet('brokerAccounts', null, uid);
+  if (Array.isArray(old) && old.length) {
+    const ins = db.prepare('INSERT OR IGNORE INTO broker_accounts (user_id, id, pos, data, updated_at) VALUES (?, ?, ?, ?, ?)');
+    db.exec('BEGIN IMMEDIATE');
+    try {
+      // encryptSecret не трогает уже зашифрованное значение и шифрует токен, если он почему-то лежал открытым текстом
+      old.forEach((a, i) => { if (a?.id) ins.run(uid, String(a.id), i, JSON.stringify({ ...a, token: a.token ? encryptSecret(a.token) : '' }), Date.now()); });
+      db.exec('COMMIT');
+    } catch (e) { db.exec('ROLLBACK'); throw e; }
+    // прежняя запись не удаляется: при откате на версию до 0.4.1 счета останутся на месте (в состоянии на момент переноса)
+    console.log(`✓ Брокерские счета пользователя ${uid} перенесены в отдельные записи (${old.length})`);
+  }
+  userKvSet('brokerAccountsMigrated', true, uid);
+}
+
 function loadRawAccounts() {
-  const list = userKvGet('brokerAccounts');
-  if (!Array.isArray(list)) return [];
-  return list.map((a) => ({ ...a, token: decryptSecret(a.token) }));
+  const uid = currentUserId();
+  migrateKvAccounts(uid);
+  const rows = db.prepare('SELECT data FROM broker_accounts WHERE user_id = ? ORDER BY pos, rowid').all(uid);
+  const list = [];
+  for (const r of rows) {
+    try {
+      const a = JSON.parse(r.data);
+      list.push({ ...a, token: decryptSecret(a.token) });
+    } catch { /* повреждённая запись пропускается */ }
+  }
+  Object.defineProperty(list, SNAPSHOT, { value: new Map(list.map((a) => [a.id, fieldSnapshot(a)])), writable: true, configurable: true, enumerable: false });
+  return list;
 }
+
 function saveRawAccounts(list) {
-  userKvSet('brokerAccounts', list.map((a) => ({ ...a, token: a.token ? encryptSecret(a.token) : '' })));
+  const uid = currentUserId();
+  const snap = list[SNAPSHOT] || null;
+  const getRow = db.prepare('SELECT data FROM broker_accounts WHERE user_id = ? AND id = ?');
+  const upsert = db.prepare(`INSERT INTO broker_accounts (user_id, id, pos, data, updated_at) VALUES (?, ?, ?, ?, ?)
+    ON CONFLICT(user_id, id) DO UPDATE SET data = excluded.data, updated_at = excluded.updated_at`);
+  db.exec('BEGIN IMMEDIATE');
+  try {
+    list.forEach((a, i) => {
+      if (!a?.id) return;
+      const before = snap?.get(a.id);
+      const curRow = getRow.get(uid, a.id);
+      if (!before || !curRow) {
+        upsert.run(uid, a.id, i, JSON.stringify(encryptAccount(a)), Date.now());
+        return;
+      }
+      const now = fieldSnapshot(a);
+      const changed = Object.keys(now).filter((k) => now[k] !== before[k]);
+      const removed = Object.keys(before).filter((k) => !(k in now));
+      if (!changed.length && !removed.length) return;
+      const merged = JSON.parse(curRow.data);
+      for (const k of changed) merged[k] = k === 'token' ? (a.token ? encryptSecret(a.token) : '') : a[k];
+      for (const k of removed) delete merged[k];
+      upsert.run(uid, a.id, i, JSON.stringify(merged), Date.now());
+    });
+    db.exec('COMMIT');
+  } catch (e) {
+    db.exec('ROLLBACK');
+    throw e;
+  }
+  // следующее сохранение этого же списка сравнивается с только что записанным состоянием
+  Object.defineProperty(list, SNAPSHOT, { value: new Map(list.filter((a) => a?.id).map((a) => [a.id, fieldSnapshot(a)])), writable: true, configurable: true, enumerable: false });
+}
+
+export const __brokerStorageForTests = { loadRawAccounts: () => loadRawAccounts(), saveRawAccounts: (l) => saveRawAccounts(l), reconcileBrokerStops: (id) => reconcileBrokerStops(id) };
+
+function deleteRawAccount(id) {
+  db.prepare('DELETE FROM broker_accounts WHERE user_id = ? AND id = ?').run(currentUserId(), String(id));
+}
+
+// Только счета (без токенов) — для технического состояния машины
+export function brokerAccountsSummary(uid = 1) {
+  return db.prepare('SELECT data FROM broker_accounts WHERE user_id = ?').all(uid).map((r) => {
+    try { const { token: _t, ...a } = JSON.parse(r.data); return a; } catch { return null; }
+  }).filter(Boolean);
 }
 
 function publicAccount(a) {
@@ -162,13 +297,17 @@ function publicAccount(a) {
       }),
     };
   }
-  return { ...a, lastSync, token: a.token || '', hasToken: Boolean(a.token && String(a.token).trim()), baseRunLabel };
+  // Токен брокера никогда не покидает сервер: в браузер, события WebSocket и ответы ИИ уходит только маска
+  const { token: rawToken, ...rest } = a;
+  const tok = String(rawToken || '').trim();
+  return { ...rest, lastSync, hasToken: Boolean(tok), tokenMask: tok ? `${tok.slice(0, 2)}…${tok.slice(-4)}` : '', baseRunLabel };
 }
 
 export function brokersState() {
   return {
     brokers: BROKER_META,
     accounts: loadRawAccounts().map(publicAccount),
+    trading: tradingGate(),
   };
 }
 
@@ -187,8 +326,20 @@ export function saveBrokerAccount(input = {}) {
   }
   const prev = idx >= 0 ? list[idx] : {};
   const broker = BROKER_META.some((b) => b.id === input.broker) ? input.broker : (prev.broker || 'tbank');
+  // СберИнвестиции / ВТБ / Альфа без моста QUIK не отправляют заявку брокеру, а лишь отмечают «исполнение» в платформе —
+  // новые такие счета не создаются (существующие продолжают работать до перевода на поддерживаемого брокера)
+  if (!prev.id && MANUAL_BROKERS.includes(broker) && process.env.ENABLE_EXPERIMENTAL_BROKERS !== '1') {
+    throw new Error('Подключение СберИнвестиций, ВТБ и Альфа-Инвестиций временно недоступно: у этих брокеров нет открытого API для заявок. Используйте Т-Банк.');
+  }
   const name = String(input.name ?? prev.name ?? '').trim() || BROKER_META.find((b) => b.id === broker).name;
-  const mode = ['readonly', 'confirm', 'auto'].includes(input.mode) ? input.mode : (prev.mode || 'confirm');
+  let mode = ['readonly', 'confirm', 'auto'].includes(input.mode) ? input.mode : (prev.mode || 'confirm');
+  // Полный автомат — только у брокера с проверенной поддержкой: средняя цена (защитные стопы), отмена заявок и история операций
+  if (mode === 'auto' && !FULLY_SUPPORTED_BROKERS.includes(broker)) {
+    if (input.mode === 'auto') {
+      throw new Error(`Режим «Автомат» пока доступен только для Т-Банка. У брокера «${BROKER_META.find((b) => b.id === broker)?.name || broker}» нет средней цены позиций, отмены заявок и истории — защитные стопы не сработают. Выберите «Подтверждение заявок».`);
+    }
+    mode = 'confirm';
+  }
   const legacyMode = ['isolate', 'smooth', 'takeover'].includes(input.legacyMode) ? input.legacyMode : (prev.legacyMode || 'isolate');
   let token = prev.token || '';
   if (input.clearToken) token = '';
@@ -199,14 +350,15 @@ export function saveBrokerAccount(input = {}) {
   const capCeiling = plan.maxCapitalPerAccountRub > 0 ? plan.maxCapitalPerAccountRub : 1000000000;
   const maxCapitalRub = Math.min(rawMaxCap, capCeiling);
   const nextBaseRunId = input.baseRunId !== undefined ? (Number(input.baseRunId) || null) : (prev.baseRunId || null);
-  const nextLimitOffset = Math.max(0, Math.min(2, Number(input.limitOffsetPct ?? prev.limitOffsetPct ?? 0.1)));
-  const strategyOrCapChanged = idx < 0
-    || acctChanged
-    || nextBaseRunId !== (prev.baseRunId || null)
-    || maxCapitalRub !== (prev.maxCapitalRub || 100000)
-    || legacyMode !== (prev.legacyMode || 'isolate')
-    || mode !== (prev.mode || 'confirm')
-    || nextLimitOffset !== (prev.limitOffsetPct ?? 0.1);
+  const nextLimitOffset = Math.max(0, Math.min(2, Number(input.limitOffsetPct ?? prev.limitOffsetPct ?? 0.02)));
+    const strategyOrCapChanged = idx < 0
+      || acctChanged
+      || nextBaseRunId !== (prev.baseRunId || null)
+      || maxCapitalRub !== (prev.maxCapitalRub || 100000)
+      || legacyMode !== (prev.legacyMode || 'isolate')
+      || mode !== (prev.mode || 'confirm')
+      || nextLimitOffset !== (prev.limitOffsetPct ?? 0.02)
+      || (input.cashSweep !== undefined && Boolean(input.cashSweep) !== Boolean(prev.cashSweep));
   const next = {
     id,
     name,
@@ -222,6 +374,7 @@ export function saveBrokerAccount(input = {}) {
     lastHistory: acctChanged ? null : (prev.lastHistory || null),
     entryTsBySymbol: acctChanged ? {} : (prev.entryTsBySymbol || {}),
     exitCooldownBySymbol: acctChanged ? {} : (prev.exitCooldownBySymbol || {}),
+    peakPriceBySymbol: acctChanged ? {} : (prev.peakPriceBySymbol || {}),
     baseRunId: nextBaseRunId,
     // жёсткие предохранители (недоступны для изменения ИИ-Стратегом)
     maxCapitalRub,
@@ -230,7 +383,16 @@ export function saveBrokerAccount(input = {}) {
     skipEdgeMinutes: input.skipEdgeMinutes !== undefined ? Boolean(input.skipEdgeMinutes) : (prev.skipEdgeMinutes ?? true),
     autoSchedule: input.autoSchedule !== undefined ? Boolean(input.autoSchedule) : (prev.autoSchedule ?? true),
     lastScheduledBarTs: strategyOrCapChanged ? 0 : (prev.lastScheduledBarTs || 0),
-    haltedReason: input.resetHalt ? null : (prev.haltedReason || null),
+    // дневной стоп при сохранении настроек не снимается — только отдельным действием «Снять стоп до конца дня»
+    haltedReason: prev.haltedReason || null,
+    ddOverrideDay: prev.ddOverrideDay || null,
+    // защитные стоп-заявки у брокера (бета, только Т-Банк); выставленные заявки сохраняются при любом изменении настроек
+    brokerStops: broker === 'tbank' && (input.brokerStops !== undefined ? Boolean(input.brokerStops) : Boolean(prev.brokerStops)),
+    brokerStopBySymbol: prev.brokerStopBySymbol || {},
+    brokerStopCooldown: prev.brokerStopCooldown || {},
+    // авто-размещение свободных рублей в фонд ликвидности LQDT и авто-продажа из него под сигналы стратегии (только Т-Банк)
+    cashSweep: broker === 'tbank' && (input.cashSweep !== undefined ? Boolean(input.cashSweep) : Boolean(prev.cashSweep)),
+    ddBreachCount: prev.ddBreachCount || 0,
     token,
     lastSync: prev.lastSync || null,
     pendingBatch: strategyOrCapChanged ? null : (prev.pendingBatch || null),
@@ -254,14 +416,53 @@ export function saveBrokerAccount(input = {}) {
   return st;
 }
 
-export function deleteBrokerAccount(id) {
-  const list = loadRawAccounts().filter((x) => x.id !== id);
+// Осознанное снятие дневного стопа: до конца текущего дня (МСК) стоп по просадке на этом счёте больше не срабатывает.
+// Блокировку за автоследование снять нельзя — она восстанавливается при каждой синхронизации.
+export function resetBrokerDailyStop(id) {
+  const list = loadRawAccounts();
+  const acc = list.find((x) => x.id === id);
+  if (!acc) throw new Error('Счёт не найден');
+  if (!acc.haltedReason) throw new Error('Дневной стоп на этом счёте не активен');
+  if (!acc.haltedReason.startsWith('Сработал дневной стоп')) throw new Error('Эту блокировку снять нельзя: ' + acc.haltedReason);
+  const today = new Date(Date.now() + MSK).toISOString().slice(0, 10);
+  logBrokerEvent(acc, 'daily_stop_reset', `снят вручную до конца дня (${acc.haltedReason})`);
+  acc.haltedReason = null;
+  acc.ddBreachCount = 0;
+  acc.ddOverrideDay = today;
   saveRawAccounts(list);
   const st = brokersState();
   hub.emit({ type: 'brokers:update', state: st });
   return st;
 }
 
+// Аварийная остановка всех счетов пользователя: авто-торговля на паузу, все активные заявки у брокера снимаются.
+// Защитные стопы по открытым позициям продолжают работать.
+export async function stopAllBrokerTrading() {
+  const list = loadRawAccounts();
+  for (const acc of list) {
+    acc.autoSchedule = false;
+    if (acc.pendingBatch && acc.pendingBatch.status === 'pending') acc.pendingBatch = null;
+    logBrokerEvent(acc, 'stop_all', 'аварийная остановка: авто-торговля на паузе, активные заявки снимаются');
+  }
+  saveRawAccounts(list);
+  const errors = [];
+  for (const acc of list) {
+    if (acc.broker === 'tbank' && acc.token) {
+      await cancelBrokerOrder(acc.id, 'all').catch((e) => errors.push(`${acc.name}: ${e.message}`));
+    }
+  }
+  const st = brokersState();
+  hub.emit({ type: 'brokers:update', state: st });
+  return { ...st, stopErrors: errors };
+}
+
+export function deleteBrokerAccount(id) {
+  deleteRawAccount(id);
+  const st = brokersState();
+  hub.emit({ type: 'brokers:update', state: st });
+  return st;
+}
+
 // ---------- адаптеры REST API брокеров (Т-Банк, Финам, Алор, БКС) ----------
 // HTTPS-клиент с поддержкой российских сертификатов НУЦ Минцифры РФ (invest-public-api.tinkoff.ru и др.)
 function brokerFetch(url, { method = 'GET', headers = {}, body = null, timeoutMs = 15000 } = {}) {
@@ -278,7 +479,8 @@ function brokerFetch(url, { method = 'GET', headers = {}, body = null, timeoutMs
       path: u.pathname + u.search,
       method,
       headers: reqHeaders,
-      rejectUnauthorized: false,
+      ca: TRUSTED_CA,
+      rejectUnauthorized: true,
       timeout: timeoutMs,
     }, (res) => {
       const chunks = [];
@@ -378,11 +580,45 @@ async function resolveTbankMetaMap(base, headers, keys = []) {
   return cache;
 }
 
+// Возвращает живые секундные цены акций из T-Invest API (GetLastPrices, 0 секунд задержки), если у любого пользователя подключён счёт Т-Банка
+export async function fetchTbankRealtimePrices() {
+  try {
+    // только токен владельца текущих данных — токены других пользователей не используются никогда
+    const tbAcc = loadRawAccounts().find((a) => a.broker === 'tbank' && a.token);
+    if (!tbAcc?.token) return null;
+    await ensureTbankShortableMap(tbAcc);
+    const uidMap = kvGet('tbankShortableMap')?.uidMap || {};
+    const entries = Object.entries(uidMap).filter(([, uid]) => Boolean(uid));
+    if (!entries.length) return null;
+    const uidToSym = new Map(entries.map(([sym, uid]) => [uid, sym]));
+    const instrumentIds = entries.map(([, uid]) => uid);
+    const base = tbAcc.sandbox ? 'https://sandbox-invest-public-api.tinkoff.ru/rest' : 'https://invest-public-api.tinkoff.ru/rest';
+    const headers = { Authorization: `Bearer ${tbAcc.token}`, 'Content-Type': 'application/json' };
+    const r = await brokerFetch(`${base}/tinkoff.public.invest.api.contract.v1.MarketDataService/GetLastPrices`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({ instrumentId: instrumentIds }),
+      timeoutMs: 5000,
+    });
+    if (!r.ok) return null;
+    const j = await r.json();
+    const prices = new Map();
+    for (const lp of j.lastPrices || []) {
+      const sym = uidToSym.get(lp.instrumentUid) || uidToSym.get(lp.figi);
+      const px = qVal(lp.price);
+      if (sym && px > 0) prices.set(sym, px);
+    }
+    return prices.size > 0 ? prices : null;
+  } catch {
+    return null;
+  }
+}
+
 // Загружает и кэширует на 12 часов справочник доступности шортов, UID и точных параметров лота/шага цены по тикерам в Т-Банке (TQBR + SPBRU для SPBE)
 async function ensureTbankShortableMap(acc) {
   if (!acc || acc.broker !== 'tbank' || !acc.token) return null;
   const cached = kvGet('tbankShortableMap');
-  if (cached?.v === 4 && cached?.map && Date.now() - cached.at < 12 * 3600000) {
+  if (cached?.v === 5 && cached?.map && Date.now() - cached.at < 12 * 3600000) {
     if (cached.uidMap) {
       for (const [sym, uid] of Object.entries(cached.uidMap)) tbankUidCache.set(sym, uid);
     }
@@ -391,20 +627,29 @@ async function ensureTbankShortableMap(acc) {
   try {
     const base = acc.sandbox ? 'https://sandbox-invest-public-api.tinkoff.ru/rest' : 'https://invest-public-api.tinkoff.ru/rest';
     const headers = { Authorization: `Bearer ${acc.token}`, 'Content-Type': 'application/json' };
-    const r = await brokerFetch(`${base}/tinkoff.public.invest.api.contract.v1.InstrumentsService/Shares`, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify({ instrumentStatus: 'INSTRUMENT_STATUS_BASE' }),
-      timeoutMs: 15000,
-    });
+    const [r, rEtfs] = await Promise.all([
+      brokerFetch(`${base}/tinkoff.public.invest.api.contract.v1.InstrumentsService/Shares`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({ instrumentStatus: 'INSTRUMENT_STATUS_BASE' }),
+        timeoutMs: 15000,
+      }),
+      brokerFetch(`${base}/tinkoff.public.invest.api.contract.v1.InstrumentsService/Etfs`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({ instrumentStatus: 'INSTRUMENT_STATUS_BASE' }),
+        timeoutMs: 15000,
+      }).catch(() => null),
+    ]);
     if (!r.ok) return cached?.map || null;
     const j = await r.json();
+    const jEtfs = rEtfs?.ok ? await rEtfs.json().catch(() => null) : null;
     const map = {};
     const uidMap = { ...(cached?.uidMap || {}) };
     const specMap = { ...(cached?.specMap || {}) };
-    for (const inst of j.instruments || []) {
+    for (const inst of [...(j.instruments || []), ...(jEtfs?.instruments || [])]) {
       if (!inst.ticker || inst.apiTradeAvailableFlag === false) continue;
-      if (inst.classCode === 'TQBR' || (inst.classCode === 'SPBRU' && !(inst.ticker in map))) {
+      if (inst.classCode === 'TQBR' || inst.classCode === 'TQTF' || (inst.classCode === 'SPBRU' && !(inst.ticker in map))) {
         map[inst.ticker] = Boolean(inst.shortEnabledFlag);
         const uid = inst.uid || inst.figi;
         if (uid) {
@@ -422,7 +667,7 @@ async function ensureTbankShortableMap(acc) {
         }
       }
     }
-    kvSet('tbankShortableMap', { v: 4, at: Date.now(), map, uidMap, specMap });
+    kvSet('tbankShortableMap', { v: 5, at: Date.now(), map, uidMap, specMap });
     return map;
   } catch {
     return cached?.map || null;
@@ -462,7 +707,7 @@ async function resolveTbankInstrumentId(base, headers, symbol) {
     });
     if (r.ok) {
       const j = await r.json();
-      const hit = (j.instruments || []).find((x) => x.ticker === symbol && x.apiTradeAvailableFlag === true && x.instrumentKind === 'INSTRUMENT_TYPE_SHARE');
+      const hit = (j.instruments || []).find((x) => x.ticker === symbol && x.apiTradeAvailableFlag === true && (x.instrumentKind === 'INSTRUMENT_TYPE_SHARE' || x.instrumentKind === 'INSTRUMENT_TYPE_ETF'));
       const uid = hit?.uid || hit?.figi;
       if (uid) { tbankUidCache.set(symbol, uid); return uid; }
     }
@@ -1004,10 +1249,11 @@ export async function syncBrokerAccount(id) {
     const ddPct = dayStartRub > 0 ? round(((dayStartRub - data.totalRub) / dayStartRub) * 100, 2) : 0;
     if (data.autoFollowDetected || /автослед|сигнал|copy|follow|comon/i.test(acc.name || '')) {
       acc.haltedReason = 'Заблокировано: на счёте обнаружено Автоследование (использование счетов автоследования запрещено Публичной офертой и правилами платформы)';
-    } else if (ddPct >= acc.maxDailyDrawdownPct) {
+    } else if (ddPct >= acc.maxDailyDrawdownPct && acc.ddOverrideDay !== today) {
       // Требуем подтверждения просадки на 2 синхронизациях подряд (защита от секундного переходного состояния API брокера в момент исполнения лимитной заявки)
       acc.ddBreachCount = (acc.ddBreachCount || 0) + 1;
       if (acc.ddBreachCount >= 2) {
+        if (!acc.haltedReason) logBrokerEvent(acc, 'daily_stop', `просадка −${ddPct}% при пороге ${acc.maxDailyDrawdownPct}%`);
         acc.haltedReason = `Сработал дневной стоп по просадке: −${ddPct}% (порог ${acc.maxDailyDrawdownPct}%)`;
       }
     } else {
@@ -1022,16 +1268,46 @@ export async function syncBrokerAccount(id) {
     }
     acc.equityHistory = hist;
     const entryMap = { ...(acc.entryTsBySymbol || {}) };
-    const curSymbols = new Set((data.positions || []).filter((p) => p.qty !== 0).map((p) => p.symbol));
-    for (const s of curSymbols) {
-      // Если позиция обнаружена при синхронизации без записи в executeBrokerOrders (например, перешла со вчерашнего дня),
-      // помечаем её как зрелую (120 мин), чтобы для неё сразу действовал штатный порог выхода 0.95, а не стартовый 65-минутный буфер
-      if (!entryMap[s]) entryMap[s] = nowTs - 120 * 60000;
+    const peakMap = { ...(acc.peakPriceBySymbol || {}) };
+    const curPositions = (data.positions || []).filter((p) => p.qty !== 0);
+    const curSymbols = new Set(curPositions.map((p) => p.symbol));
+    const pendingOrderSymbols = new Set((data.activeOrders || []).map((o) => o.symbol).filter(Boolean));
+    const histOps = Array.isArray(acc.lastHistory?.operations) ? acc.lastHistory.operations : [];
+    for (const p of curPositions) {
+      const s = p.symbol;
+      if (!entryMap[s]) {
+        // Ищем реальное время последней открывающей сделки по этой бумаге в истории брокера
+        const wantKind = p.qty > 0 ? 'buy' : 'sell';
+        const lastEntryOp = histOps.find((op) => op.symbol === s && op.kind === wantKind && op.date > 0);
+        // Если бумага только что появилась в портфеле (например, исполнилась лимитная заявка),
+        // ставим реальное время сделки или nowTs (возраст 0 мин), чтобы 65-минутный буфер удержания всегда работал!
+        entryMap[s] = lastEntryOp?.date || nowTs;
+      }
+      // Отслеживаем пиковую лучшую цену позиции с момента входа (для фиксации прибыли и защиты безубытка)
+      const curPx = Number(p.price) || 0;
+      const avgPx = Number(p.avgPrice) || curPx;
+      if (curPx > 0) {
+        if (p.qty > 0) {
+          peakMap[s] = Math.max(Number(peakMap[s]) || avgPx || curPx, curPx);
+        } else if (p.qty < 0) {
+          const prevBest = Number(peakMap[s]) > 0 ? Number(peakMap[s]) : (avgPx || curPx);
+          peakMap[s] = Math.min(prevBest, curPx);
+        }
+      }
     }
     for (const s of Object.keys(entryMap)) {
-      if (!curSymbols.has(s)) delete entryMap[s];
+      // Не удаляем метку времени входа, если лимитная заявка по бумаге ещё стоит в стакане
+      // или была отправлена менее 20 минут назад (чтобы не сбросить 65-минутный таймер до исполнения лимитки!)
+      const isRecentEntryOrder = nowTs - entryMap[s] < 20 * 60000;
+      if (!curSymbols.has(s) && !pendingOrderSymbols.has(s) && !isRecentEntryOrder) {
+        delete entryMap[s];
+      }
+    }
+    for (const s of Object.keys(peakMap)) {
+      if (!curSymbols.has(s)) delete peakMap[s];
     }
     acc.entryTsBySymbol = entryMap;
+    acc.peakPriceBySymbol = peakMap;
     acc.lastSync = { at: nowTs, ok: true, error: null, day: today, dayStartRub, dayDrawdownPct: ddPct, ...data };
   } catch (e) {
     acc.lastSync = { ...(acc.lastSync || {}), at: Date.now(), ok: false, error: e.message };
@@ -1080,7 +1356,12 @@ function sessionEdgeWarning(now = Date.now()) {
 }
 
 // ---------- формирование и исполнение пакета лимитных заявок ----------
-export async function prepareBrokerOrders(id) {
+const accountBusyLocks = new Set();
+
+export async function prepareBrokerOrders(id, { onlyEntries = false } = {}) {
+  if (accountBusyLocks.has(id)) return brokersState();
+  accountBusyLocks.add(id);
+  try {
   let list = loadRawAccounts();
   let acc = list.find((x) => x.id === id);
   if (!acc) throw new Error('Счёт не найден');
@@ -1092,8 +1373,8 @@ export async function prepareBrokerOrders(id) {
     throw new Error('Для работы с брокерскими счетами оформите подписку «Инвестор» (3 900 ₽/мес), «Профи» (9 900 ₽/мес) или «VIP» в разделе «Подписка и уведомления».');
   }
   hub.emit({ type: 'trading:pulse', kind: 'broker_calc', ts: Date.now(), accountId: acc.id, name: acc.name, text: `Пересчёт заявок по счёту «${acc.name}»…` });
-  // Перед расчётом заявок автоматически снимаем старые неисполненные заявки со стакана и синхронизируем свежий баланс!
-  if (acc.token && acc.mode !== 'readonly' && acc.broker === 'tbank' && acc.lastSync?.activeOrders?.length > 0) {
+  // При плановом шаге снимаем старые неисполненные заявки со стакана, а при быстром доборе (onlyEntries) не трогаем уже стоящие свежие заявки!
+  if (!onlyEntries && acc.token && acc.mode !== 'readonly' && acc.broker === 'tbank' && acc.lastSync?.activeOrders?.length > 0) {
     await cancelBrokerOrder(id, 'all').catch(() => {});
     list = loadRawAccounts();
     acc = list.find((x) => x.id === id) || acc;
@@ -1149,24 +1430,59 @@ export async function prepareBrokerOrders(id) {
   const vipBoost = Boolean(plan.allowVipBoost);
   const rawDir = params.modelDirection || 'long';
   const dir = (marginAllowed && planAllowsShorts) ? rawDir : 'long';
-  const exitRatio = autoAdapt ? 0.95 : Number(params.modelExitRatio ?? 0.5);
+  // В реальном стакане брокера (где каждый вход-выход стоит 0.08% комиссии + спред) используем гистерезис удержания 0.58
+  // (около +0.145%), чтобы не закрывать открытую позицию преждевременно при положительном прогнозе +0.16%…+0.23%!
+  const exitRatio = autoAdapt ? 0.58 : Number(params.modelExitRatio ?? 0.5);
   const exitThresholdPct = round((fc.thresholdPct || 0) * exitRatio, 3);
-  const earlyExitThresholdPct = round((fc.thresholdPct || 0) * 0.35, 3);
+  const earlyExitThresholdPct = round((fc.thresholdPct || 0) * 0.25, 3);
   const nowTs = Date.now();
   const entryTsMap = acc.entryTsBySymbol || {};
   const exitCooldownMap = acc.exitCooldownBySymbol || {};
   const mskDate = new Date(nowTs + MSK);
   const isEveningSession = (mskDate.getUTCHours() * 60 + mskDate.getUTCMinutes()) >= 19 * 60;
   const eveningBoost = (autoAdapt && isEveningSession) ? 1.25 : 1.0;
-  const minEntryEdgePct = round((fc.thresholdPct || 0) * eveningBoost, 3);
+  // Спред-фильтр реального стакана по эшелонам ликвидности:
+  // для 1-го эшелона требуем минимум базовый порог (≥ 0.50%), а для 2–3 эшелона (широкий спред стакана) — в 1.35× выше (≥ 0.675%)
+  const baseBuyNeedPct = Number(fc.buyThresholdPct ?? fc.thresholdPct ?? 0.50);
+  const baseShortNeedPct = Number(fc.shortThresholdPct ?? fc.thresholdPct ?? 0.50);
+  const minBuyEdgePct = round(baseBuyNeedPct * eveningBoost, 3);
+  const minShortEdgePct = round(baseShortNeedPct * eveningBoost, 3);
+  const reqBuyEdgeOf = (sym) => round(Math.max(minBuyEdgePct * symbolEdgeMult(sym), 0.30 * eveningBoost), 3);
+  const reqShortEdgeOf = (sym) => round(Math.max(minShortEdgePct * symbolEdgeMult(sym), 0.31 * eveningBoost), 3);
   const isInCooldown = (sym) => autoAdapt && exitCooldownMap[sym] && (nowTs - exitCooldownMap[sym] < 60 * 60000);
+  // Самообучение на истории реальных сделок счёта (адаптивный карантин убыточных бумаг, как в research.js):
+  // если за последние 14 дней по бумаге было >= 3 закрытых сделок на счёте и их суммарный итог отрицательный (< -1.0%),
+  // временно исключаем такую бумагу из новых входов, чтобы не наступать на одни и те же грабли в неликвиде!
+  const quarantined = new Set();
+  if (autoAdapt && Array.isArray(acc.lastHistory?.operations)) {
+    const cutoffTs = nowTs - 14 * DAY;
+    const recentOps = acc.lastHistory.operations
+      .filter((op) => op.date >= cutoffTs && op.symbol && (op.kind === 'buy' || op.kind === 'sell' || op.kind === 'fee'))
+      .sort((a, b) => a.date - b.date);
+    const heldNowSet = new Set((acc.lastSync?.positions || []).filter((p) => p.qty !== 0).map((p) => p.symbol));
+    const statBySym = {};
+    for (const op of recentOps) {
+      if (heldNowSet.has(op.symbol)) continue; // считаем только полностью закрытые цепочки сделок
+      const st = statBySym[op.symbol] || (statBySym[op.symbol] = { buys: 0, sells: 0, buyRub: 0, netRub: 0 });
+      const pay = Number(op.paymentRub) || 0;
+      if (op.kind === 'buy') { st.buys++; st.buyRub += Math.abs(pay); st.netRub += pay; }
+      else if (op.kind === 'sell') { st.sells++; st.netRub += pay; }
+      else if (op.kind === 'fee') { st.netRub += pay; }
+    }
+    for (const [sym, st] of Object.entries(statBySym)) {
+      const closedRounds = Math.min(st.buys, st.sells);
+      if (closedRounds >= 3 && st.buyRub > 10000 && (st.netRub / st.buyRub) < -0.009) {
+        quarantined.add(sym);
+      }
+    }
+  }
   const slots = dir === 'long' ? K : 2 * K;
   // Фильтр мощности слота по тарифу:
-  // • Инвестор (до 60% годовых): 1 счёт до 1 млн ₽, только покупки (без шортов), консервативный слот до 24% капитала
-  // • Профи (до 120% годовых): до 5 счетов по 1 млн ₽, покупки + шорты, базовый слот до 28% капитала
-  // • VIP (до 240% годовых): счета и сумма по согласованию, покупки + шорты, слот до 48% капитала
-  // • Хозяин (без ограничений): полная мощность ядра (>400% годовых, Conviction Sizing до 75% капитала)
-  const isOwnerPlan = Boolean(plan.isOwner || plan.id === 'owner' || plan.maxAnnualReturnPct === 0);
+  // • Инвестор: 1 счёт до 1 млн ₽, только покупки (без шортов), консервативный слот до 24% капитала
+  // • Профи: до 5 счетов по 1 млн ₽, покупки + шорты, базовый слот до 28% капитала
+  // • VIP: счета и сумма по договору, покупки + шорты, слот до 48% капитала
+  // • Хозяин: Conviction Sizing до 75% капитала
+  const isOwnerPlan = Boolean(plan.isOwner || plan.id === 'owner');
   let slotRub;
   if (isOwnerPlan && autoAdapt) {
     const maxSlotWeight = Math.min(0.45, Math.max(1 / K, 1.8 / K));
@@ -1179,19 +1495,8 @@ export async function prepareBrokerOrders(id) {
   } else {
     slotRub = budget * Math.min(0.24, 1.05 / Math.max(3, K + 1));
   }
-  // Мягкий дроссель при опережении годового потолка доходности тарифа (60% Инвестор, 120% Профи, 240% VIP; у Хозяина = 0 — без потолка)
-  if (!isOwnerPlan && plan.maxAnnualReturnPct > 0 && Array.isArray(acc.equityHistory) && acc.equityHistory.length >= 2) {
-    const firstPt = acc.equityHistory[0];
-    const lastPt = acc.equityHistory[acc.equityHistory.length - 1];
-    const elapsedDays = Math.max(7, (lastPt.ts - firstPt.ts) / DAY);
-    if (firstPt.totalRub > 0 && lastPt.totalRub > firstPt.totalRub) {
-      const curGainPct = ((lastPt.totalRub - firstPt.totalRub) / firstPt.totalRub) * 100;
-      const targetGainPct = plan.maxAnnualReturnPct * (elapsedDays / 365);
-      if (curGainPct > targetGainPct) {
-        slotRub *= Math.max(0.25, targetGainPct / curGainPct);
-      }
-    }
-  }
+  // (Потолки доходности по тарифам и «дроссель» размера позиций удалены: тарифы различаются возможностями,
+  // а не обещанной доходностью — реалистичная доходность определяется стресс-тестом, а не тарифом.)
   const needPct = Math.max(0.01, Number(fc.thresholdPct || 0));
   const convOf = (r) => {
     if (!autoAdapt || !r.expectedPct) return 1;
@@ -1201,11 +1506,11 @@ export async function prepareBrokerOrders(id) {
   };
   const heldMap = new Map((acc.lastSync?.positions || []).map((p) => [p.symbol, p]));
   const rowMap = new Map((fc.rows || []).map((r) => [r.symbol, r]));
-  const quarantined = new Set();
   const nb = params.newsFilter ? blockingNews(6) : null;
 
-  const buyCands = fc.rows.filter((r) => r.signal && r.expectedPct >= minEntryEdgePct && !isInCooldown(r.symbol) && !quarantined.has(r.symbol) && !nb?.get(r.symbol)?.bad).sort((a, b) => b.expectedPct - a.expectedPct).slice(0, K);
-  const allShortSignals = rawDir !== 'long' ? fc.rows.filter((r) => r.shortSignal && r.expectedPct <= -minEntryEdgePct && !isInCooldown(r.symbol) && !quarantined.has(r.symbol) && !nb?.get(r.symbol)?.good).sort((a, b) => a.expectedPct - b.expectedPct) : [];
+  const cooldownSkipped = fc.rows.filter((r) => ((r.signal && r.expectedPct >= reqBuyEdgeOf(r.symbol)) || (rawDir !== 'long' && r.shortSignal && r.expectedPct <= -reqShortEdgeOf(r.symbol))) && isInCooldown(r.symbol));
+  const buyCands = fc.rows.filter((r) => r.signal && r.expectedPct >= reqBuyEdgeOf(r.symbol) && !isInCooldown(r.symbol) && !quarantined.has(r.symbol) && !nb?.get(r.symbol)?.bad).sort((a, b) => b.expectedPct - a.expectedPct).slice(0, K);
+  const allShortSignals = rawDir !== 'long' ? fc.rows.filter((r) => r.shortSignal && r.expectedPct <= -reqShortEdgeOf(r.symbol) && !isInCooldown(r.symbol) && !quarantined.has(r.symbol) && !nb?.get(r.symbol)?.good).sort((a, b) => a.expectedPct - b.expectedPct) : [];
   const nonShortableSkipped = [];
   const rawShortCands = [];
   for (const r of allShortSignals) {
@@ -1232,7 +1537,11 @@ export async function prepareBrokerOrders(id) {
   const orders = [];
   const closing = new Set();
   const smoothSellPool = [];
-  // 1) закрытие бумаг стратегии (покупок и шортов), чей прогноз ослаб ниже порога выхода exitThresholdPct
+  const peakMap = acc.peakPriceBySymbol || {};
+  const roundTripFeePct = 2 * ((Number(params.commissionPct) || 0.04) + (Number(params.slippagePct) || 0.01));
+  // 1) закрытие бумаг стратегии (покупок и шортов):
+  // • по фиксации реальной прибыли (Take-Profit / Trailing Stop от лучшей достигнутой цены peakPrice, чтобы не отдавать заработанный плюс в минус!),
+  // • либо если прогноз ослаб ниже порога выхода curExitThr.
   // Облигации, фонды (LQDT/TMOS) и бумаги вне словаря MOEXBMI (!rowMap.has(sym)) не затрагиваются никогда
   for (const [sym, pos] of heldMap) {
     if (!pos.qty) continue;
@@ -1241,31 +1550,50 @@ export async function prepareBrokerOrders(id) {
     const sp = specs[sym] || { lotSize: 1, minStep: 0.01, decimals: 2 };
     const aQty = algoQtyOf(sym, pos.qty);
     const baseQty = pos.qty - aQty;
-    const heldMs = entryTsMap[sym] ? (nowTs - entryTsMap[sym]) : (120 * 60000);
+    const histOps = Array.isArray(acc.lastHistory?.operations) ? acc.lastHistory.operations : [];
+    const wantOpenKind = aQty >= 0 ? 'buy' : 'sell';
+    const lastHistEntryOp = histOps.find((op) => op.symbol === sym && op.kind === wantOpenKind && op.date > 0);
+    const lastHistEntryTs = lastHistEntryOp?.date || 0;
+    const effEntryTs = Math.max(entryTsMap[sym] || 0, lastHistEntryTs);
+    const heldMs = effEntryTs > 0 ? Math.max(0, nowTs - effEntryTs) : 0;
     // Как в эталонном симуляторе (research.js): первые 65 минут после открытия позиции действует мягкий порог удержания (0.35),
     // чтобы не резать сделку от рыночного шума каждые 30 минут; затем включается плотный порог фиксации (0.95)
     const curExitThr = (autoAdapt && heldMs <= 65 * 60000) ? earlyExitThresholdPct : exitThresholdPct;
+    const curPx = Number(r.price || pos.price) || 0;
+    const avgPx = Number(pos.avgPrice) > 0 ? Number(pos.avgPrice) : (Number(lastHistEntryOp?.price) || curPx);
     if (aQty > 0) {
       const lots = Math.floor(aQty / sp.lotSize);
-      const keep = r.liquid && r.expectedPct > curExitThr;
+      const curGainPct = avgPx > 0 ? ((curPx - avgPx) / avgPx) * 100 : 0;
+      const hitHardStopLoss = curGainPct <= -2.6;
+      const keepByForecast = onlyEntries ? (r.liquid && r.expectedPct > -needPct) : (r.liquid && r.expectedPct > curExitThr);
+      const keep = keepByForecast && !hitHardStopLoss;
       if (lots >= 1 && !keep) {
-        const limitPrice = roundToStep(pos.price * (1 - acc.limitOffsetPct / 100), sp.minStep, sp.decimals);
+        const limitPrice = sniperLimitPrice(curPx, -1, acc.limitOffsetPct, sp);
+        const exitReason = hitHardStopLoss
+          ? `Защитный стоп-лосс позиции (${round(curGainPct, 2)}%)`
+          : `Выход из покупки: ожидание ${r.expectedPct > 0 ? '+' : ''}${r.expectedPct}% ниже порога удержания +${curExitThr}%`;
         orders.push({
           symbol: sym, action: 'sell', lotSize: sp.lotSize, lots, shares: lots * sp.lotSize,
-          refPrice: pos.price, limitPrice, amountRub: round(lots * sp.lotSize * limitPrice, 2),
-          reason: `Выход из покупки: ожидание ${r.expectedPct > 0 ? '+' : ''}${r.expectedPct}% ниже порога удержания +${curExitThr}%`,
+          refPrice: curPx, limitPrice, amountRub: round(lots * sp.lotSize * limitPrice, 2),
+          reason: exitReason,
         });
         closing.add(sym);
       }
     } else if (aQty < 0) {
       const lots = Math.floor(Math.abs(aQty) / sp.lotSize);
-      const keep = dir !== 'long' && r.liquid && r.expectedPct < -curExitThr;
+      const curGainPct = avgPx > 0 ? ((avgPx - curPx) / avgPx) * 100 : 0;
+      const hitHardStopLoss = curGainPct <= -2.2;
+      const keepByForecast = onlyEntries ? (dir !== 'long' && r.liquid && r.expectedPct < needPct) : (dir !== 'long' && r.liquid && r.expectedPct < -curExitThr);
+      const keep = keepByForecast && !hitHardStopLoss;
       if (lots >= 1 && !keep) {
-        const limitPrice = roundToStep(pos.price * (1 + acc.limitOffsetPct / 100), sp.minStep, sp.decimals);
+        const limitPrice = sniperLimitPrice(curPx, 1, acc.limitOffsetPct, sp);
+        const exitReason = hitHardStopLoss
+          ? `Защитный стоп-лосс шорта от выноса вверх (${round(curGainPct, 2)}%)`
+          : `Закрытие шорта: ожидание ${r.expectedPct > 0 ? '+' : ''}${r.expectedPct}% выше порога удержания −${curExitThr}%`;
         orders.push({
           symbol: sym, action: 'cover', lotSize: sp.lotSize, lots, shares: lots * sp.lotSize,
-          refPrice: pos.price, limitPrice, amountRub: round(lots * sp.lotSize * limitPrice, 2),
-          reason: `Закрытие шорта: ожидание ${r.expectedPct > 0 ? '+' : ''}${r.expectedPct}% выше порога удержания −${curExitThr}%`,
+          refPrice: curPx, limitPrice, amountRub: round(lots * sp.lotSize * limitPrice, 2),
+          reason: exitReason,
         });
         closing.add(sym);
       }
@@ -1277,7 +1605,7 @@ export async function prepareBrokerOrders(id) {
       const bLots = Math.floor(baseQty / sp.lotSize);
       if (bLots >= 1 && !(r.liquid && r.expectedPct > exitThresholdPct)) {
         if (r.expectedPct <= -needPct) {
-          const limitPrice = roundToStep(pos.price * (1 - acc.limitOffsetPct / 100), sp.minStep, sp.decimals);
+          const limitPrice = sniperLimitPrice(pos.price, -1, acc.limitOffsetPct, sp);
           orders.push({
             symbol: sym, action: 'sell', lotSize: sp.lotSize, lots: bLots, shares: bLots * sp.lotSize,
             refPrice: pos.price, limitPrice, amountRub: round(bLots * sp.lotSize * limitPrice, 2),
@@ -1290,25 +1618,82 @@ export async function prepareBrokerOrders(id) {
       }
     }
   }
-  const activeLongs = [...heldMap.values()].filter((p) => rowMap.has(p.symbol) && algoQtyOf(p.symbol, p.qty) > 0 && !closing.has(p.symbol)).length;
-  const activeShorts = [...heldMap.values()].filter((p) => rowMap.has(p.symbol) && algoQtyOf(p.symbol, p.qty) < 0 && !closing.has(p.symbol)).length;
-  const usedRub = [...heldMap.values()].filter((p) => rowMap.has(p.symbol) && algoQtyOf(p.symbol, p.qty) !== 0 && !closing.has(p.symbol)).reduce((s, p) => s + Math.abs(algoQtyOf(p.symbol, p.qty) * p.price), 0);
+  const activePendingOrders = acc.lastSync?.activeOrders || [];
+  const activeOrderSymbols = new Set(activePendingOrders.map((o) => o.symbol).filter(Boolean));
+  const pendingBuyOrdersCount = activePendingOrders.filter((o) => o.direction === 'buy').length;
+  const pendingSellOrdersCount = activePendingOrders.filter((o) => o.direction === 'sell').length;
+  let activeLongs = [...heldMap.values()].filter((p) => rowMap.has(p.symbol) && algoQtyOf(p.symbol, p.qty) > 0 && !closing.has(p.symbol)).length + (onlyEntries ? pendingBuyOrdersCount : 0);
+  let activeShorts = [...heldMap.values()].filter((p) => rowMap.has(p.symbol) && algoQtyOf(p.symbol, p.qty) < 0 && !closing.has(p.symbol)).length + (onlyEntries ? pendingSellOrdersCount : 0);
+  let usedRub = [...heldMap.values()].filter((p) => rowMap.has(p.symbol) && algoQtyOf(p.symbol, p.qty) !== 0 && !closing.has(p.symbol)).reduce((s, p) => s + Math.abs(algoQtyOf(p.symbol, p.qty) * p.price), 0)
+    + (onlyEntries ? activePendingOrders.reduce((s, o) => s + Math.abs(Number(o.amountRub) || 0), 0) : 0);
+
+  // Ротация остывшей позиции в мощного нового лидера (Opportunity Rotation):
+  // если на счёте занято >65% бюджета, а на рынке появился новый лидер с прогнозом >= +0.55% (в 2.4 раза сильнее текущей остывшей бумаги),
+  // освобождаем слот под лидера, чтобы капитал не застревал в вялых позициях
+  if (!onlyEntries && autoAdapt && usedRub > budget * 0.65 && (buyCands.length > 0 || shortCands.length > 0)) {
+    const bestNewPct = Math.max(
+      buyCands.length ? Math.abs(buyCands[0].expectedPct || 0) : 0,
+      shortCands.length ? Math.abs(shortCands[0].expectedPct || 0) : 0,
+    );
+    if (bestNewPct >= needPct * 2.2) {
+      let weakestSym = null, weakestEdge = Infinity;
+      for (const [sym, pos] of heldMap) {
+        if (closing.has(sym) || !rowMap.has(sym)) continue;
+        const aQ = algoQtyOf(sym, pos.qty);
+        if (!aQ) continue;
+        const rCur = rowMap.get(sym);
+        const curSignedPct = aQ > 0 ? (rCur.expectedPct || 0) : -(rCur.expectedPct || 0);
+        if (curSignedPct < exitThresholdPct * 0.90 && curSignedPct < weakestEdge && bestNewPct > Math.max(needPct, curSignedPct) * 2.4) {
+          weakestEdge = curSignedPct;
+          weakestSym = sym;
+        }
+      }
+      if (weakestSym) {
+        const wPos = heldMap.get(weakestSym);
+        const wRow = rowMap.get(weakestSym);
+        const wSp = specs[weakestSym] || { lotSize: 1, minStep: 0.01, decimals: 2 };
+        const wAq = algoQtyOf(weakestSym, wPos.qty);
+        const wLots = Math.floor(Math.abs(wAq) / wSp.lotSize);
+        const wPx = Number(wRow?.price || wPos.price) || 0;
+        if (wLots >= 1 && wPx > 0) {
+          const isLongPos = wAq > 0;
+          const limPx = sniperLimitPrice(wPx, isLongPos ? -1 : 1, acc.limitOffsetPct, wSp);
+          orders.push({
+            symbol: weakestSym,
+            action: isLongPos ? 'sell' : 'cover',
+            lotSize: wSp.lotSize,
+            lots: wLots,
+            shares: wLots * wSp.lotSize,
+            refPrice: wPx,
+            limitPrice: limPx,
+            amountRub: round(wLots * wSp.lotSize * limPx, 2),
+            reason: `Ротация капитала из остывшей бумаги (${wRow?.expectedPct > 0 ? '+' : ''}${wRow?.expectedPct}%) в нового сильного лидера (${bestNewPct}%)`,
+          });
+          closing.add(weakestSym);
+          if (isLongPos) activeLongs = Math.max(0, activeLongs - 1);
+          else activeShorts = Math.max(0, activeShorts - 1);
+          usedRub = Math.max(0, usedRub - Math.abs(wAq * wPos.price));
+        }
+      }
+    }
+  }
   const freedRub = orders.filter((o) => o.action === 'sell').reduce((s, o) => s + o.amountRub, 0);
   const cashLimit = acc.lastSync?.cashRub !== undefined ? acc.lastSync.cashRub + freedRub : budget;
   let availRub = Math.min(Math.max(0, budget * 0.99 - usedRub), Math.max(0, cashLimit));
 
     // 2) вход в лучшие сигналы (с учётом лотности Мосбиржи, свободного лимита и адаптивного отбора числа акций Dynamic Top-K)
-  const rawNewBuys = buyCands.filter((r) => !(algoQtyOf(r.symbol, heldMap.get(r.symbol)?.qty || 0) > 0 && !closing.has(r.symbol)));
+  const rawNewBuys = buyCands.filter((r) => !(algoQtyOf(r.symbol, heldMap.get(r.symbol)?.qty || 0) > 0 && !closing.has(r.symbol)) && !(onlyEntries && activeOrderSymbols.has(r.symbol)));
   // Не открываем шорт по тикеру, в котором ещё лежит непроданный остаток старого портфеля (baseQty > 0), чтобы брокер не превратил шорт в продажу старой позиции
   const rawNewShorts = shortCands.filter((r) => {
+    if (onlyEntries && activeOrderSymbols.has(r.symbol)) return false;
     const curQ = heldMap.get(r.symbol)?.qty || 0;
     const aQ = algoQtyOf(r.symbol, curQ);
     const bQ = curQ - aQ;
     if (bQ > 0 && !closing.has(r.symbol)) return false;
     return !(aQ < 0 && !closing.has(r.symbol));
   });
-  const newBuys = filterBrokerDynamicTopK(rawNewBuys, minEntryEdgePct, Math.max(0, K - activeLongs));
-  const newShorts = filterBrokerDynamicTopK(rawNewShorts, minEntryEdgePct, Math.max(0, K - activeShorts));
+  const newBuys = filterBrokerDynamicTopK(rawNewBuys, minBuyEdgePct, Math.max(0, K - activeLongs));
+  const newShorts = filterBrokerDynamicTopK(rawNewShorts, minShortEdgePct, Math.max(0, K - activeShorts));
   const totalNew = newBuys.length + newShorts.length;
   const activeTotal = Math.max(2, activeLongs + activeShorts + totalNew);
   const dynSlotRub = (isOwnerPlan && autoAdapt)
@@ -1342,7 +1727,7 @@ export async function prepareBrokerOrders(id) {
         : smoothSellPool.filter((x) => (x.r.expectedPct || 0) <= -0.02).slice(0, maxSteps);
       for (const item of poolToUse) {
         if (shortfall <= 1000) break;
-        const limitPrice = roundToStep(item.pos.price * (1 - acc.limitOffsetPct / 100), item.sp.minStep, item.sp.decimals);
+        const limitPrice = sniperLimitPrice(item.pos.price, -1, acc.limitOffsetPct, item.sp);
         const lotVal = limitPrice * item.sp.lotSize;
         const lotsToSell = Math.min(item.bLots, Math.max(1, Math.ceil(shortfall / lotVal)));
         const amountRub = round(lotsToSell * item.sp.lotSize * limitPrice, 2);
@@ -1364,26 +1749,63 @@ export async function prepareBrokerOrders(id) {
     ...newBuys.map((r) => ({ r, side: 'buy' })),
     ...newShorts.map((r) => ({ r, side: 'short' })),
   ];
+  // Если включено «Свободные рубли в LQDT» (cashSweep) и для новых сигналов не хватает свободных рублей,
+  // сначала автоматически продаём нужное число паёв фонда ликвидности LQDT, которые открыла стратегия (сверх неприкосновенного baselineQty)
+  if (acc.cashSweep && acc.broker === 'tbank' && combinedNew.length > 0 && !closing.has('LQDT') && !activeOrderSymbols.has('LQDT')) {
+    const lqdtPos = heldMap.get('LQDT');
+    const lqdtAlgoQty = lqdtPos ? algoQtyOf('LQDT', lqdtPos.qty) : 0;
+    if (lqdtAlgoQty > 0 && lqdtPos.price > 0) {
+      const lqdtSp = specs.LQDT || { lotSize: 1, minStep: 0.001, decimals: 3 };
+      const lqdtLots = Math.floor(lqdtAlgoQty / lqdtSp.lotSize);
+      const neededForNewRub = combinedNew.reduce((s, { r, side }) => {
+        const isT1 = TIER1_LIQUID_SYMBOLS.has(r.symbol);
+        const cap = budget * (side === 'short' ? (isT1 ? 0.35 : 0.18) : (isT1 ? 0.45 : 0.22));
+        return s + Math.min(cap, (params.modelAllocMode === 'invvol' && r.weight ? dynSlotRub * r.weight : dynSlotRub) * convOf(r));
+      }, 0);
+      const needFromLqdtRub = Math.min(Math.max(0, budget * 0.99 - usedRub), neededForNewRub) - availRub;
+      if (lqdtLots >= 1 && needFromLqdtRub > 1500) {
+        const limPx = sniperLimitPrice(lqdtPos.price, -1, 0.03, lqdtSp);
+        const lotVal = limPx * lqdtSp.lotSize;
+        const sellLots = Math.min(lqdtLots, Math.max(1, Math.ceil((needFromLqdtRub * 1.005) / lotVal)));
+        const amountRub = round(sellLots * lqdtSp.lotSize * limPx, 2);
+        orders.push({
+          symbol: 'LQDT', action: 'sell', lotSize: lqdtSp.lotSize, lots: sellLots, shares: sellLots * lqdtSp.lotSize,
+          refPrice: lqdtPos.price, limitPrice: limPx, amountRub,
+          reason: `Высвобождение ${fmtRubSimple(amountRub)} ₽ из фонда денежного рынка LQDT под сигнал стратегии (${combinedNew.map((x) => x.r.symbol).join(', ')})`,
+        });
+        closing.add('LQDT');
+        availRub += amountRub;
+      }
+    }
+  }
   if (autoAdapt && combinedNew.length > 1) {
     combinedNew.sort((a, b) => Math.abs(b.r.expectedPct || 0) - Math.abs(a.r.expectedPct || 0));
   }
   let remWeightSum = combinedNew.reduce((s, x) => s + Math.max(0.01, Math.abs(x.r.expectedPct || 0)), 0);
 
   // Жёсткий предохранитель концентрации на одну бумагу в реальном стакане брокера:
-  // максимум до 45% счёта на один лонг и максимум до 35% счёта на один шорт (включая множитель силы сигнала convOf)
-  const maxLongPerStockRub = budget * 0.45;
-  const maxShortPerStockRub = budget * 0.35;
+  // • для ликвидных бумаг 1-го эшелона: до 45% счёта на один лонг и до 35% счёта на один шорт;
+  // • для бумаг 2–3 эшелона (MRKC, MRKZ, NKHP, AQUA, FESH, FEES и др.): до 22% счёта на один лонг и до 18% на один шорт,
+  //   чтобы крупная заявка не выкупала тонкий стакан против самой себя и всегда оставляла капитал на 3–4 бумаги!
+  const maxLongTier1Rub = budget * 0.45;
+  const maxShortTier1Rub = budget * 0.35;
+  const maxLongTier2Rub = budget * 0.22;
+  const maxShortTier2Rub = budget * 0.18;
 
   for (const { r, side } of combinedNew) {
     const wCur = Math.max(0.01, Math.abs(r.expectedPct || 0));
     const propShare = autoAdapt && remWeightSum > 0 ? availRub * (wCur / remWeightSum) : availRub / Math.max(1, remNew);
     remWeightSum = Math.max(0, remWeightSum - wCur);
     remNew--;
-    const sideCapRub = side === 'short' ? maxShortPerStockRub : maxLongPerStockRub;
+    const isTier1 = TIER1_LIQUID_SYMBOLS.has(r.symbol);
+    const sideCapRub = side === 'short'
+      ? (isTier1 ? maxShortTier1Rub : maxShortTier2Rub)
+      : (isTier1 ? maxLongTier1Rub : maxLongTier2Rub);
     const rawSum = Math.min(sideCapRub, (params.modelAllocMode === 'invvol' && r.weight ? dynSlotRub * r.weight : dynSlotRub) * convOf(r));
     const sum = Math.min(rawSum, propShare, availRub);
     const refPx = r.price || specs[r.symbol]?.lastPrice || 0;
-    const ord = calcLotOrder(r.symbol, sum, refPx, side, acc.limitOffsetPct, specs);
+    const effOffsetPct = isTier1 ? Math.min(Number(acc.limitOffsetPct) || 0.05, 0.06) : Math.min(Number(acc.limitOffsetPct) || 0.04, 0.04);
+    const ord = calcLotOrder(r.symbol, sum, refPx, side, effOffsetPct, specs);
     if (ord) {
       availRub = Math.max(0, availRub - ord.amountRub);
       orders.push({
@@ -1396,17 +1818,36 @@ export async function prepareBrokerOrders(id) {
     }
   }
 
+  // При включённом «Свободные рубли в LQDT» на плановом шаге (!onlyEntries), если новых входов нет и нет открытых заявок,
+  // а свободных рублей выше резерва — размещаем излишек в фонд ликвидности LQDT, чтобы кэш приносил ставку денежного рынка (~16–18% годовых)
+  if (!onlyEntries && acc.cashSweep && acc.broker === 'tbank' && combinedNew.length === 0 && !activePendingOrders.length && !edgeWarn) {
+    const lqdtSp = specs.LQDT || { lotSize: 1, minStep: 0.001, decimals: 3 };
+    const lqdtPx = Number(heldMap.get('LQDT')?.price || lqdtSp.lastPrice || 0);
+    const reserveRub = Math.max(5000, round(budget * 0.03, 0));
+    const sweepRub = Math.min(availRub - reserveRub, (acc.lastSync?.cashRub || 0) - reserveRub);
+    if (lqdtPx > 0 && sweepRub >= 20000) {
+      const ord = calcLotOrder('LQDT', sweepRub, lqdtPx, 'buy', 0.02, { ...specs, LQDT: lqdtSp });
+      if (ord) {
+        availRub = Math.max(0, availRub - ord.amountRub);
+        orders.push({
+          ...ord,
+          reason: `Фонд денежного рынка LQDT: размещение свободных ${fmtRubSimple(ord.amountRub)} ₽ под дневную ставку ликвидности до появления сигнала`,
+        });
+      }
+    }
+  }
+
   let diagNote = '';
   let planThrottleNote = '';
   if (plan.id === 'investor') {
     const shInfo = rawShortCands.length ? ` (пропущены сигналы на шорт: ${rawShortCands.map((r) => `${r.symbol} ${r.expectedPct}%`).join(', ')})` : '';
     const reinvNote = reinvestedProfitRub > 0 ? ` + реинвестировано прибыли +${fmtRubSimple(reinvestedProfitRub)} ₽ (в работе ${fmtRubSimple(budget)} ₽)` : '';
-    planThrottleNote = `Тариф «Инвестор» (целевой потолок до 60% годовых, 1 счёт со стартовым лимитом до 1 млн ₽${reinvNote}): активен режим «Только в рост (без шорта)»${shInfo}. Для включения заработка на падении акций (шорты, до 120% годовых и до 5 счетов) перейдите на тариф «Профи».`;
+    planThrottleNote = `Тариф «Инвестор» (1 счёт со стартовым лимитом до 1 млн ₽${reinvNote}): активен режим «Только в рост (без шорта)»${shInfo}. Сделки на падении акций (шорты) и до 5 счетов — на тарифе «Профи».`;
   } else if (plan.id === 'pro') {
     const reinvNote = reinvestedProfitRub > 0 ? ` + реинвестировано прибыли +${fmtRubSimple(reinvestedProfitRub)} ₽ (в работе ${fmtRubSimple(budget)} ₽)` : '';
-    planThrottleNote = `Тариф «Профи» (целевой потолок до 120% годовых, до 5 счетов со стартовым лимитом до 1 млн ₽/счёт${reinvNote}): активны покупки и шорты. Для расширения потолка доходности до 240% годовых и индивидуальных лимитов подключите тариф «VIP».`;
+    planThrottleNote = `Тариф «Профи» (до 5 счетов со стартовым лимитом до 1 млн ₽/счёт${reinvNote}): активны покупки и шорты. Индивидуальные лимиты — на тарифе «VIP».`;
   } else if (plan.id === 'vip') {
-    planThrottleNote = `Тариф «VIP» (целевой потолок до 240% годовых, лимиты по согласованию): активны покупки и шорты с повышенной концентрацией слота.`;
+    planThrottleNote = 'Тариф «VIP» (лимиты по договору): активны покупки и шорты с повышенной концентрацией слота.';
   }
   if (!orders.length) {
     if ((newBuys.length || newShorts.length) && availRub < 1500) {
@@ -1415,16 +1856,23 @@ export async function prepareBrokerOrders(id) {
       diagNote = `У стратегии есть сигналы (${sigList}), но для открытия позиций не хватает свободных рублей (на счёте свободно ${fmtRubSimple(cashNow)} ₽, остальные средства размещены в других активах). Пополните счёт рублями или выберите счёт со свободным кэшем.`;
     } else if (!newBuys.length && !planAllowsShorts && rawShortCands.length > 0) {
       const skippedShorts = rawShortCands.map((r) => `${r.symbol} (${r.expectedPct}%)`).join(', ');
-      diagNote = `По прогнозу есть сигнал на падение (${skippedShorts}), но на тарифе «${plan.name}» разрешена торговля только в рост (без шорта, до 60% годовых). Чтобы зарабатывать и на падении акций (до 120% годовых), перейдите на тариф «Профи» или «VIP».`;
+      diagNote = `По прогнозу есть сигнал на падение (${skippedShorts}), но на тарифе «${plan.name}» разрешена торговля только в рост (без шорта). Сделки на падении акций доступны на тарифах «Профи» и «VIP».`;
     } else if (!newBuys.length && !marginAllowed && rawShortCands.length > 0) {
       const skippedShorts = rawShortCands.map((r) => `${r.symbol} (${r.expectedPct}%)`).join(', ');
       diagNote = `Счёт автоматически работает в режиме «Только в рост (без шорта)», так как на нём в Т-Инвестициях отключена маржинальная торговля. Сигналы на падение (${skippedShorts}) пропущены; новых сигналов на покупку на свече ${fc.bar} нет. Если хотите зарабатывать и на падении (шортах), включите «Маржинальную торговлю» в настройках этого счёта в приложении Т-Инвестиций.`;
     } else if (!newBuys.length && !newShorts.length) {
       const noShortNote = nonShortableSkipped.length ? ` (пропущены немаржинальные бумаги, недоступные для шорта у брокера: ${nonShortableSkipped.map((r) => `${r.symbol} ${r.expectedPct}%`).join(', ')})` : '';
-      diagNote = `На свече ${fc.bar} ни одна доступная бумага не превысила порог выгоды +${fc.thresholdPct}%${noShortNote}.`;
+      const cdNote = cooldownSkipped.length ? ` Сигнал ${cooldownSkipped.map((r) => `${r.symbol} (${r.expectedPct > 0 ? '+' : ''}${r.expectedPct}%)`).join(', ')} временно пропущен: действует 60-минутная пауза после недавнего выхода из позиции, чтобы не платить повторную комиссию.` : '';
+      diagNote = cdNote
+        ? `На свече ${fc.bar} новых входов нет.${cdNote}${noShortNote}`
+        : `На свече ${fc.bar} ни одна доступная бумага не превысила порог выгоды +${fc.thresholdPct}%${noShortNote}.`;
     }
   }
 
+  if (onlyEntries && !orders.length) {
+    return brokersState();
+  }
+
   acc.pendingBatch = {
     id: `batch_${Date.now()}`,
     createdAt: Date.now(),
@@ -1445,12 +1893,15 @@ export async function prepareBrokerOrders(id) {
   saveRawAccounts(list);
   notifyBrokerBatch(currentUserId(), acc, acc.pendingBatch).catch(() => {});
   if (acc.mode === 'auto' && !edgeWarn && acc.token && orders.length) {
-    return executeBrokerOrders(id);
+    return await executeBrokerOrders(id, { _lockHeld: true });
   }
   const st = brokersState();
   hub.emit({ type: 'brokers:update', state: st });
   hub.emit({ type: 'trading:pulse', kind: 'broker_done', ts: Date.now(), accountId: acc.id, name: acc.name, ordersCount: orders.length });
   return st;
+  } finally {
+    accountBusyLocks.delete(id);
+  }
 }
 
 function formatTbankOrderError(status, rawText = '', ord = {}) {
@@ -1484,14 +1935,46 @@ async function sendOrderToBroker(acc, ord) {
     const base = acc.sandbox ? 'https://sandbox-invest-public-api.tinkoff.ru/rest' : 'https://invest-public-api.tinkoff.ru/rest';
     const headers = { Authorization: `Bearer ${acc.token}`, 'Content-Type': 'application/json' };
     const instrumentId = await resolveTbankInstrumentId(base, headers, ord.symbol);
-    const units = Math.trunc(ord.limitPrice);
-    const nano = Math.round((ord.limitPrice - units) * 1e9);
     const isBuy = ord.action === 'buy' || ord.action === 'cover';
+    const isEntry = ord.action === 'buy' || ord.action === 'short';
+    // Подтягиваем живой стакан 1×1 (GetOrderBook depth=1) в секунду отправки:
+    // • для входа (buy/short) и для LQDT ставим лимитку по лучшей цене своей стороны или середине спреда (не переплачиваем за пересечение спреда!);
+    // • если спред в стакане в момент входа разъехался шире половины ожидаемого хода сигнала (или >0,35%) — отклоняем вход в тонкий стакан!
+    let finalLimitPx = Number(ord.limitPrice) || 0;
+    const sp = kvGet('tbankShortableMap')?.specMap?.[ord.symbol] || { minStep: 0.01, decimals: 2 };
+    const rBook = await brokerFetch(`${base}/tinkoff.public.invest.api.contract.v1.MarketDataService/GetOrderBook`, {
+      method: 'POST', headers, body: JSON.stringify({ instrumentId, depth: 1 }), timeoutMs: 3500,
+    }).catch(() => null);
+    if (rBook?.ok) {
+      const jBook = await rBook.json().catch(() => null);
+      const bestBid = qVal(jBook?.bids?.[0]?.price);
+      const bestAsk = qVal(jBook?.asks?.[0]?.price);
+      if (bestBid > 0 && bestAsk >= bestBid) {
+        const midPx = (bestBid + bestAsk) / 2;
+        const spreadPct = ((bestAsk - bestBid) / midPx) * 100;
+        const maxSpreadPct = ord.symbol === 'LQDT' ? 0.15 : Math.max(0.28, Math.abs(Number(ord.expectedPct) || 0.6) * 0.45);
+        if (isEntry && spreadPct > maxSpreadPct) {
+          throw Object.assign(new Error(`Широкий спред в стакане ${ord.symbol} (${round(spreadPct, 2)}% > ${round(maxSpreadPct, 2)}%) — вход пропущен, чтобы не потерять на спреде`), { definitive: true });
+        }
+        if (isEntry && ord.symbol !== 'LQDT') {
+          // Пассивный вход на середине спреда (или на 1 шаг внутри спреда от своей стороны), но не хуже расчётной limitPrice
+          const passivePx = isBuy
+            ? Math.min(finalLimitPx, roundToStep(Math.min(midPx, bestBid + (sp.minStep || 0.01)), sp.minStep, sp.decimals))
+            : Math.max(finalLimitPx, roundToStep(Math.max(midPx, bestAsk - (sp.minStep || 0.01)), sp.minStep, sp.decimals));
+          if (passivePx > 0) finalLimitPx = passivePx;
+        } else if (ord.symbol === 'LQDT') {
+          finalLimitPx = roundToStep(isBuy ? bestAsk : bestBid, sp.minStep || 0.001, sp.decimals ?? 3);
+        }
+      }
+    }
+    const units = Math.trunc(finalLimitPx);
+    const nano = Math.round((finalLimitPx - units) * 1e9);
     let lotsToOrder = Number(ord.lots) || 0;
 
     // Перед выставлением новой лимитной заявки автоматически снимаем старые неисполненные заявки по этой же бумаге и направлению,
     // чтобы в стакане никогда не копились дублирующиеся заявки и не блокировали рублёвый лимит счёта!
-    const rActive = await brokerFetch(`${base}/tinkoff.public.invest.api.contract.v1.OrdersService/GetOrders`, {
+    // При повторе после таймаута не снимаем: среди «старых» может оказаться эта же заявка, дошедшая до брокера.
+    const rActive = ord.uncertainSend ? null : await brokerFetch(`${base}/tinkoff.public.invest.api.contract.v1.OrdersService/GetOrders`, {
       method: 'POST', headers, body: JSON.stringify({ accountId: acc.accountId }), timeoutMs: 8000,
     }).catch(() => null);
     if (rActive?.ok) {
@@ -1524,9 +2007,9 @@ async function sendOrderToBroker(acc, ord) {
         if (Number.isFinite(maxLots)) {
           if (maxLots < 1) {
             if (ord.action === 'short') {
-              throw new Error(`Короткая продажа (шорт) по бумаге ${ord.symbol} недоступна у брокера (бумага не входит в список маржинальных для шорта или исчерпан лимит займа)`);
+              throw Object.assign(new Error(`Короткая продажа (шорт) по бумаге ${ord.symbol} недоступна у брокера (бумага не входит в список маржинальных для шорта или исчерпан лимит займа)`), { definitive: true });
             }
-            throw new Error(`У брокера недостаточно доступного лимита для ${isBuy ? 'покупки' : 'продажи'} ${ord.symbol} (доступно 0 лотов)`);
+            throw Object.assign(new Error(`У брокера недостаточно доступного лимита для ${isBuy ? 'покупки' : 'продажи'} ${ord.symbol} (доступно 0 лотов)`), { definitive: true });
           }
           if (maxLots < lotsToOrder) lotsToOrder = Math.floor(maxLots);
         }
@@ -1540,7 +2023,8 @@ async function sendOrderToBroker(acc, ord) {
       price: { units: String(units), nano },
       direction: isBuy ? 'ORDER_DIRECTION_BUY' : 'ORDER_DIRECTION_SELL',
       orderType: 'ORDER_TYPE_LIMIT',
-      orderId: crypto.randomUUID(),
+      // ключ идемпотентности T-Invest: повтор с тем же orderId не создаёт вторую заявку
+      orderId: ord.clientOrderId || crypto.randomUUID(),
     };
     const r = await brokerFetch(`${base}/tinkoff.public.invest.api.contract.v1.OrdersService/PostOrder`, {
       method: 'POST',
@@ -1550,10 +2034,12 @@ async function sendOrderToBroker(acc, ord) {
     });
     if (!r.ok) {
       const errText = await r.text().catch(() => '');
-      throw new Error(formatTbankOrderError(r.status, errText, ord));
+      // 5xx — исход не известен (заявка могла быть принята), 4xx — брокер точно отклонил
+      throw Object.assign(new Error(formatTbankOrderError(r.status, errText, ord)), { definitive: r.status < 500 });
     }
     const j = await r.json();
-    return { ok: true, orderId: j.orderId || body.orderId, lots: lotsToOrder };
+    logBrokerEvent(acc, 'order_sent', `${ord.action} ${ord.symbol} ${lotsToOrder} л. по ${finalLimitPx} ₽ · ${body.orderId}`);
+    return { ok: true, orderId: j.orderId || body.orderId, lots: lotsToOrder, limitPrice: finalLimitPx };
   }
   if (acc.broker === 'finam') {
     const body = {
@@ -1712,52 +2198,98 @@ async function sendOrderToBroker(acc, ord) {
   throw new Error(`Неизвестный брокер: ${acc.broker}`);
 }
 
-export async function executeBrokerOrders(id) {
-  const list = loadRawAccounts();
-  const acc = list.find((x) => x.id === id);
-  if (!acc) throw new Error('Счёт не найден');
-  if (acc.mode === 'readonly') throw new Error('Счёт в режиме «Только чтение» — отправка заявок отключена');
-  if (acc.haltedReason) throw new Error(acc.haltedReason);
-  const batch = acc.pendingBatch;
-  if (!batch || !batch.orders?.length) throw new Error('Нет подготовленных заявок для отправки');
-  const results = [];
-  acc.entryTsBySymbol = acc.entryTsBySymbol || {};
-  acc.exitCooldownBySymbol = acc.exitCooldownBySymbol || {};
-  const execNowTs = Date.now();
-  const exitOrders = batch.orders.filter((o) => o.action === 'sell' || o.action === 'cover');
-  const entryOrders = batch.orders.filter((o) => o.action !== 'sell' && o.action !== 'cover');
-  const orderedBatch = [...exitOrders, ...entryOrders];
-  let hadExits = false;
-  for (const ord of orderedBatch) {
-    // Если перед открытием новых позиций мы отправили закрывающие ордера (sell/cover),
-    // даём брокеру 1.2 секунды на исполнение в стакане и пересчёт свободного маржинального/рублёвого лимита перед вызовом GetMaxLots
-    if (hadExits && (ord.action === 'buy' || ord.action === 'short')) {
-      hadExits = false;
-      await new Promise((r) => setTimeout(r, 1200));
+export async function executeBrokerOrders(id, { _lockHeld = false } = {}) {
+  if (!_lockHeld) {
+    // Счёт может быть занят пересчётом заявок (после перезапуска — обучением прогноза): ждём до 15 с, а не молча пропускаем
+    const waitUntil = Date.now() + 15000;
+    while (accountBusyLocks.has(id) && Date.now() < waitUntil) await new Promise((r) => setTimeout(r, 300));
+    if (accountBusyLocks.has(id)) throw new Error('Счёт сейчас занят пересчётом заявок — повторите через минуту');
+    accountBusyLocks.add(id);
+  }
+  try {
+    const list = loadRawAccounts();
+    const acc = list.find((x) => x.id === id);
+    if (!acc) throw new Error('Счёт не найден');
+    if (acc.mode === 'readonly') throw new Error('Счёт в режиме «Только чтение» — отправка заявок отключена');
+    if (acc.haltedReason) throw new Error(acc.haltedReason);
+    const gate = tradingGate();
+    if (!gate.allowNew) throw new Error(gate.reason);
+    const batch = acc.pendingBatch;
+    if (!batch || !batch.orders?.length) throw new Error('Нет подготовленных заявок для отправки');
+    if (batch.status === 'executed' || batch.status === 'executing') return brokersState();
+    // Идемпотентность: у каждой заявки постоянный clientOrderId (для Т-Банка — orderId в PostOrder, брокер не исполнит его дважды).
+    // ID закрепляется и сохраняется ДО отправки; при повторе пакета «partial» уже принятые брокером заявки не отправляются снова.
+    for (const ord of batch.orders) {
+      if (!ord.clientOrderId) ord.clientOrderId = crypto.randomUUID();
     }
-    try {
-      const r = await sendOrderToBroker(acc, ord);
-      results.push({ symbol: ord.symbol, ok: true, orderId: r.orderId });
-      if (ord.action === 'buy' || ord.action === 'short') {
-        acc.entryTsBySymbol[ord.symbol] = execNowTs;
-        delete acc.exitCooldownBySymbol[ord.symbol];
-      } else if (ord.action === 'sell' || ord.action === 'cover') {
-        hadExits = true;
-        delete acc.entryTsBySymbol[ord.symbol];
-        acc.exitCooldownBySymbol[ord.symbol] = execNowTs;
+    batch.status = 'executing';
+    saveRawAccounts(list);
+    const prevResults = new Map((batch.results || []).filter((r) => r.ok && r.clientOrderId).map((r) => [r.clientOrderId, r]));
+    const results = [];
+    acc.entryTsBySymbol = acc.entryTsBySymbol || {};
+    acc.exitCooldownBySymbol = acc.exitCooldownBySymbol || {};
+    acc.peakPriceBySymbol = acc.peakPriceBySymbol || {};
+    const execNowTs = Date.now();
+    const exitOrders = batch.orders.filter((o) => o.action === 'sell' || o.action === 'cover');
+    const entryOrders = batch.orders.filter((o) => o.action !== 'sell' && o.action !== 'cover');
+    const orderedBatch = [...exitOrders, ...entryOrders];
+    let hadExits = false;
+    for (const ord of orderedBatch) {
+      const already = prevResults.get(ord.clientOrderId);
+      if (already) {
+        results.push(already);
+        continue;
+      }
+      // Если перед открытием новых позиций мы отправили закрывающие ордера (sell/cover),
+      // даём брокеру 1.2 секунды на исполнение в стакане и пересчёт свободного маржинального/рублёвого лимита перед вызовом GetMaxLots
+      if (hadExits && (ord.action === 'buy' || ord.action === 'short')) {
+        hadExits = false;
+        await new Promise((r) => setTimeout(r, 1200));
+      }
+      try {
+        if ((ord.action === 'sell' || ord.action === 'cover') && acc.brokerStopBySymbol?.[ord.symbol]) {
+          try {
+            await closeBrokerStopBeforeExit(acc, ord.symbol);
+          } catch (e) {
+            throw new Error(`не удалось снять стоп-заявку у брокера перед закрытием (${e.message}) — закрывающая заявка не отправлена, чтобы не продать дважды`);
+          }
+        }
+        const r = await sendOrderToBroker(acc, ord);
+        results.push({ symbol: ord.symbol, ok: true, orderId: r.orderId, clientOrderId: ord.clientOrderId });
+        if (ord.action === 'buy' || ord.action === 'short') {
+          acc.entryTsBySymbol[ord.symbol] = execNowTs;
+          acc.peakPriceBySymbol[ord.symbol] = Number(ord.limitPrice || ord.refPrice) || 0;
+          delete acc.exitCooldownBySymbol[ord.symbol];
+        } else if (ord.action === 'sell' || ord.action === 'cover') {
+          hadExits = true;
+          delete acc.entryTsBySymbol[ord.symbol];
+          delete acc.peakPriceBySymbol[ord.symbol];
+          acc.exitCooldownBySymbol[ord.symbol] = execNowTs;
+        }
+      } catch (e) {
+        // Брокер явно отклонил заявку — при повторе нужен новый ID. Сетевая ошибка или таймаут — ID сохраняется:
+        // заявка могла дойти до брокера, и повтор с тем же ID не создаст дубль.
+        ord.sendAttempts = (ord.sendAttempts || 0) + 1;
+        if (e.definitive) ord.clientOrderId = crypto.randomUUID();
+        else ord.uncertainSend = true;
+        results.push({ symbol: ord.symbol, ok: false, error: e.message, uncertain: !e.definitive });
+        logBrokerEvent(acc, 'order_error', `${ord.action} ${ord.symbol} ${ord.lots} л.: ${e.message}`);
       }
-    } catch (e) {
-      results.push({ symbol: ord.symbol, ok: false, error: e.message });
     }
+    batch.status = results.every((r) => r.ok) ? 'executed' : 'partial';
+    batch.results = results;
+    batch.executedAt = Date.now();
+    saveRawAccounts(list);
+    await syncBrokerAccount(id).catch(() => {});
+    if (acc.broker === 'tbank' && acc.token) {
+      await fetchBrokerHistory(id).catch(() => {});
+    }
+    const st = brokersState();
+    hub.emit({ type: 'brokers:update', state: st });
+    return st;
+  } finally {
+    if (!_lockHeld) accountBusyLocks.delete(id);
   }
-  batch.status = results.every((r) => r.ok) ? 'executed' : 'partial';
-  batch.results = results;
-  batch.executedAt = Date.now();
-  saveRawAccounts(list);
-  await syncBrokerAccount(id).catch(() => {});
-  const st = brokersState();
-  hub.emit({ type: 'brokers:update', state: st });
-  return st;
 }
 
 export async function cancelBrokerOrder(id, orderId = null) {
@@ -1873,6 +2405,19 @@ export async function fetchBrokerHistory(id, opts = {}) {
   const fetchedOps = rawOps.map((op) => {
     const m = metaMap[op.figi] || metaMap[op.instrumentUid] || {};
     const [kind, kindLabel] = OP_KIND(op.operationType);
+    // В T-Invest API v2 поле op.quantity — это ЗАЯВЛЕННОЕ количество в лимитном ордере, а op.quantityRest — неисполненный остаток!
+    // Реально исполненное количество акций всегда равно сумме сделок в op.trades, либо (quantity - quantityRest):
+    const tradesQty = Array.isArray(op.trades) && op.trades.length > 0
+      ? op.trades.reduce((s, t) => s + (Number(t.quantity) || 0), 0)
+      : 0;
+    const rawQty = Number(op.quantityDone ?? (Number(op.quantity || 0) - Number(op.quantityRest || 0)));
+    const execQty = tradesQty > 0 ? tradesQty : Math.max(0, rawQty);
+    const paymentRub = round(qVal(op.payment), 2);
+    // Точная средневзвешенная цена исполнения из фактической суммы сделки (чтобы Кол-во × Цена = Сумма сходились до копейки):
+    const rawPx = qVal(op.price);
+    const effPx = (execQty > 0 && Math.abs(paymentRub) > 0 && (kind === 'buy' || kind === 'sell'))
+      ? round(Math.abs(paymentRub) / execQty, 6)
+      : round(rawPx, 6);
     return {
       id: op.id || '',
       date: op.date ? new Date(op.date).getTime() : 0,
@@ -1881,11 +2426,11 @@ export async function fetchBrokerHistory(id, opts = {}) {
       title: op.type || kindLabel,
       symbol: m.ticker || op.figi || '',
       name: m.name || '',
-      qty: Number(op.quantityDone || op.quantity || 0),
-      price: round(qVal(op.price), 4),
-      paymentRub: round(qVal(op.payment), 2),
+      qty: execQty,
+      price: effPx,
+      paymentRub,
     };
-  });
+  }).filter((op) => !((op.kind === 'buy' || op.kind === 'sell') && op.qty === 0 && op.paymentRub === 0));
 
   // Сохраняем операции других годов, которые уже были загружены ранее, и заменяем только targetYear
   const prevOps = Array.isArray(acc.lastHistory?.operations) ? acc.lastHistory.operations : [];
@@ -1941,6 +2486,7 @@ let schedulerBusy = false;
 
 async function tickBrokerSchedule() {
   if (schedulerBusy) return;
+  if (!tradingGate().allowNew) return;
   const nowMsk = new Date(Date.now() + MSK);
   const dow = nowMsk.getUTCDay();
   const mins = nowMsk.getUTCHours() * 60 + nowMsk.getUTCMinutes();
@@ -1948,8 +2494,8 @@ async function tickBrokerSchedule() {
   schedulerBusy = true;
   try {
     const latest = await latestBarTs('IMOEX', BAR_INTERVAL).catch(() => null);
-    if (!latest || latest === lastSeenBar) return;
-    lastSeenBar = latest;
+    const isNewBar = Boolean(latest && latest !== lastSeenBar);
+    if (isNewBar) lastSeenBar = latest;
     const users = db.prepare('SELECT * FROM users').all();
     for (const u of users) {
       await runWithUser(u, async () => {
@@ -1965,11 +2511,28 @@ async function tickBrokerSchedule() {
           const H = barsFromHours(effHorizon);
           // Внутричасовой перехват H/5 (каждые 30 мин) активен в режимах VIP и Хозяин; на тарифах Инвестор и Профи шаг равен полному горизонту H
           const stepBars = ((plan.allowVipBoost || plan.isOwner) && autoAdapt) ? Math.max(3, Math.floor(H / 5)) : H;
-          if (latest - (acc.lastScheduledBarTs || 0) < stepBars * BAR_MS) continue;
-          acc.lastScheduledBarTs = latest;
-          saveRawAccounts(list);
-          if (acc.token) await syncBrokerAccount(acc.id).catch(() => {});
-          await prepareBrokerOrders(acc.id).catch(() => {});
+          const minStepMs = stepBars * BAR_MS;
+          const lastRunWallTs = acc.pendingBatch?.executedAt || acc.pendingBatch?.createdAt || 0;
+          const dueFullStep = Boolean(
+            latest &&
+            (latest - (acc.lastScheduledBarTs || 0) >= minStepMs) &&
+            !(lastRunWallTs > 0 && Date.now() - lastRunWallTs < minStepMs - 5 * 60000),
+          );
+          if (dueFullStep) {
+            acc.lastScheduledBarTs = latest;
+            saveRawAccounts(list);
+            if (acc.token) await syncBrokerAccount(acc.id).catch(() => {});
+            await prepareBrokerOrders(acc.id).catch(() => {});
+            continue;
+          }
+          // Мгновенный перехват новых сигналов «купить» / «шорт» при наличии свободных рублей или резерва в LQDT (каждые 20 секунд, не дожидаясь конца 30-минутного шага!):
+          const lqdtPos = acc.cashSweep ? (acc.lastSync?.positions || []).find((p) => p.symbol === 'LQDT' && p.qty > 0) : null;
+          const lqdtBaseQty = Number(acc.baselineQty?.LQDT || 0);
+          const lqdtAvailRub = lqdtPos ? Math.max(0, (lqdtPos.qty - (acc.legacyMode === 'takeover' ? 0 : Math.max(0, lqdtBaseQty))) * (lqdtPos.price || 0)) : 0;
+          const freeCashRub = Number(acc.lastSync?.cashRub ?? acc.maxCapitalRub ?? 0) + lqdtAvailRub;
+          if (acc.mode === 'auto' && acc.token && freeCashRub >= 15000 && Date.now() - lastRunWallTs >= 20000) {
+            await prepareBrokerOrders(acc.id, { onlyEntries: true }).catch(() => {});
+          }
         }
       });
     }
@@ -1987,15 +2550,10 @@ async function resumeBrokerAccountsOnBoot() {
         const list = loadRawAccounts();
         for (const acc of list) {
           if (!acc.token) continue;
-          await syncBrokerAccount(acc.id).catch(() => {});
           if (!acc.lastHistory && acc.broker === 'tbank') {
             await fetchBrokerHistory(acc.id).catch(() => {});
           }
-          // Если в предыдущем пакете была ошибка 400 из-за шорта на безмаржинальном счёте — пересчитываем пакет под реальные настройки счёта
-          const fresh = loadRawAccounts().find((x) => x.id === acc.id);
-          if (fresh?.pendingBatch?.results?.some((r) => !r.ok && /HTTP 400|margin/i.test(String(r.error || '')))) {
-            await prepareBrokerOrders(acc.id).catch(() => {});
-          }
+          await syncBrokerAccount(acc.id).catch(() => {});
         }
       });
     }
@@ -2003,7 +2561,284 @@ async function resumeBrokerAccountsOnBoot() {
   } catch { /* ignore startup sync errors */ }
 }
 
-// Автоматическое периодическое фоновое обновление портфеля и истории текущего года (раз в 2 минуты)
+// ---------- защитные стоп-заявки на стороне Т-Банка (бета, включаются на счёте) ----------
+// Стоп-лосс висит у брокера и срабатывает, даже если машина клиента выключена или упала.
+// Правила безопасности (чтобы не получить непреднамеренный шорт на маржинальном счёте):
+//   • стоп-заявка на каждую бумагу с позицией стратегии, ровно на её число лотов (сверка раз в 25 с);
+//   • перед любой закрывающей заявкой по бумаге её стоп-заявка снимается (closeBrokerStopBeforeExit);
+//   • внутренний защитный стоп по бумаге со стоп-заявкой у брокера не выставляется;
+//   • трогаются только стоп-заявки, выставленные самой программой (их ID хранятся в brokerStopBySymbol).
+const BROKER_STOP_LONG_PCT = 2.6;
+const BROKER_STOP_SHORT_PCT = 2.2;
+const tbankBase = (acc) => (acc.sandbox ? 'https://sandbox-invest-public-api.tinkoff.ru/rest' : 'https://invest-public-api.tinkoff.ru/rest');
+const tbankHeaders = (acc) => ({ Authorization: `Bearer ${acc.token}`, 'Content-Type': 'application/json' });
+const qPrice = (v) => { const units = Math.trunc(v); return { units: String(units), nano: Math.round((v - units) * 1e9) }; };
+
+function algoQtyFor(acc, sym, totalQty) {
+  const legacyMode = acc.legacyMode || 'isolate';
+  if (legacyMode === 'takeover') return totalQty;
+  const baseQ = Number((acc.baselineQty || {})[sym] || 0);
+  if (totalQty > 0 && baseQ > 0) return Math.max(0, totalQty - baseQ);
+  if (totalQty < 0 && baseQ < 0) return Math.min(0, totalQty - baseQ);
+  return totalQty;
+}
+
+async function tbankActiveStopIds(acc) {
+  const r = await brokerFetch(`${tbankBase(acc)}/tinkoff.public.invest.api.contract.v1.StopOrdersService/GetStopOrders`, {
+    method: 'POST', headers: tbankHeaders(acc), body: JSON.stringify({ accountId: acc.accountId, status: 'STOP_ORDER_STATUS_ACTIVE' }), timeoutMs: 10000,
+  });
+  if (!r.ok) throw new Error(`GetStopOrders HTTP ${r.status}`);
+  const j = await r.json();
+  return new Set((j.stopOrders || []).map((s) => s.stopOrderId).filter(Boolean));
+}
+
+async function tbankCancelStop(acc, stopOrderId) {
+  const r = await brokerFetch(`${tbankBase(acc)}/tinkoff.public.invest.api.contract.v1.StopOrdersService/CancelStopOrder`, {
+    method: 'POST', headers: tbankHeaders(acc), body: JSON.stringify({ accountId: acc.accountId, stopOrderId }), timeoutMs: 10000,
+  });
+  // 4xx «не найдена» — стоп уже сработал или снят: считаем снятым
+  if (!r.ok && r.status >= 500) throw new Error(`CancelStopOrder HTTP ${r.status}`);
+}
+
+// Снять стоп-заявку у брокера перед закрытием позиции стратегией (иначе после закрытия она продаст ещё раз)
+async function closeBrokerStopBeforeExit(acc, sym) {
+  const t = acc.brokerStopBySymbol?.[sym];
+  if (!t?.stopOrderId || acc.broker !== 'tbank' || !acc.token) return;
+  await tbankCancelStop(acc, t.stopOrderId);
+  delete acc.brokerStopBySymbol[sym];
+  logBrokerEvent(acc, 'broker_stop_cancel', `${sym}: снята перед закрытием позиции`);
+}
+
+async function cancelAllBrokerStops(acc, why) {
+  for (const [sym, t] of Object.entries(acc.brokerStopBySymbol || {})) {
+    try {
+      if (t?.stopOrderId) await tbankCancelStop(acc, t.stopOrderId);
+      delete acc.brokerStopBySymbol[sym];
+      logBrokerEvent(acc, 'broker_stop_cancel', `${sym}: ${why}`);
+    } catch (e) {
+      logBrokerEvent(acc, 'broker_stop_error', `${sym}: не удалось снять (${e.message})`);
+    }
+  }
+}
+
+async function reconcileBrokerStops(accId) {
+  const list = loadRawAccounts();
+  const acc = list.find((x) => x.id === accId);
+  if (!acc || acc.broker !== 'tbank' || !acc.token || !acc.accountId) return;
+  acc.brokerStopBySymbol = acc.brokerStopBySymbol || {};
+  // выключено на счёте, «Только чтение» или аварийная остановка из центра — свои стоп-заявки снимаем
+  const gate = tradingGate();
+  if (!acc.brokerStops || acc.mode === 'readonly' || !gate.allowProtective) {
+    if (Object.keys(acc.brokerStopBySymbol).length) {
+      await cancelAllBrokerStops(acc, !acc.brokerStops ? 'стоп-заявки у брокера выключены на счёте' : 'счёт в режиме «Только чтение» или торговля остановлена');
+      saveRawAccounts(list);
+    }
+    return;
+  }
+  if (!acc.lastSync?.ok) return;
+  if (accountBusyLocks.has(accId)) return; // идёт исполнение пакета — сверимся в следующий раз
+  accountBusyLocks.add(accId);
+  try {
+    await reconcileBrokerStopsLocked(list, acc);
+  } finally {
+    accountBusyLocks.delete(accId);
+  }
+}
+
+async function reconcileBrokerStopsLocked(list, acc) {
+  acc.brokerStopCooldown = acc.brokerStopCooldown || {};
+  const active = await tbankActiveStopIds(acc);
+  const rawSpecs = await ensureBoardSpecs().catch(() => ({}));
+  const specs = { ...rawSpecs, ...(kvGet('tbankShortableMap')?.specMap || {}) };
+  const base = tbankBase(acc);
+  const headers = tbankHeaders(acc);
+  const want = new Map();
+  for (const pos of acc.lastSync.positions || []) {
+    const sym = pos.symbol;
+    const sp = specs[sym];
+    if (!sym || !sp) continue;
+    const aQty = algoQtyFor(acc, sym, Number(pos.qty) || 0);
+    const lots = Math.floor(Math.abs(aQty) / (sp.lotSize || 1));
+    const avgPx = Number(pos.avgPrice) || 0;
+    if (lots < 1 || avgPx <= 0) continue;
+    const side = aQty > 0 ? 'long' : 'short';
+    const stopPx = roundToStep(side === 'long' ? avgPx * (1 - BROKER_STOP_LONG_PCT / 100) : avgPx * (1 + BROKER_STOP_SHORT_PCT / 100), sp.minStep, sp.decimals);
+    want.set(sym, { lots, side, stopPx, sp });
+  }
+  let changed = false;
+  // 1) снять свои стоп-заявки без позиции, сработавшие (их нет среди активных) или с другим объёмом / ценой / стороной
+  for (const [sym, t] of Object.entries(acc.brokerStopBySymbol)) {
+    const w = want.get(sym);
+    const alive = t?.stopOrderId && active.has(t.stopOrderId);
+    const same = alive && w && w.lots === t.lots && w.side === t.side && Math.abs(w.stopPx - t.stopPx) < (w.sp.minStep || 0.01) / 2;
+    if (same) continue;
+    if (alive) {
+      try { await tbankCancelStop(acc, t.stopOrderId); } catch (e) { logBrokerEvent(acc, 'broker_stop_error', `${sym}: ${e.message}`); continue; }
+    }
+    logBrokerEvent(acc, alive ? 'broker_stop_cancel' : 'broker_stop_gone', `${sym}: ${!w ? 'позиции стратегии нет' : !alive ? 'стоп-заявка сработала или снята у брокера' : 'объём или цена позиции изменились'}`);
+    // стоп сработал, а позиция в данных ещё видна — не выставляем новый, пока портфель не обновится (иначе возможна повторная продажа)
+    if (!alive) acc.brokerStopCooldown[sym] = Date.now();
+    delete acc.brokerStopBySymbol[sym];
+    changed = true;
+  }
+  // 2) выставить недостающие
+  for (const [sym, w] of want) {
+    if (acc.brokerStopBySymbol[sym]) continue;
+    const cd = acc.brokerStopCooldown[sym];
+    if (cd && (Date.now() - cd < 120000 || Number(acc.lastSync?.at || 0) < cd + 30000)) continue;
+    if (cd) { delete acc.brokerStopCooldown[sym]; changed = true; }
+    try {
+      const instrumentId = await resolveTbankInstrumentId(base, headers, sym);
+      const body = {
+        accountId: acc.accountId,
+        instrumentId,
+        quantity: String(w.lots),
+        stopPrice: qPrice(w.stopPx),
+        direction: w.side === 'long' ? 'STOP_ORDER_DIRECTION_SELL' : 'STOP_ORDER_DIRECTION_BUY',
+        expirationType: 'STOP_ORDER_EXPIRATION_TYPE_GOOD_TILL_CANCEL',
+        stopOrderType: 'STOP_ORDER_TYPE_STOP_LOSS',
+        exchangeOrderType: 'EXCHANGE_ORDER_TYPE_MARKET',
+        orderId: crypto.randomUUID(),
+      };
+      const r = await brokerFetch(`${base}/tinkoff.public.invest.api.contract.v1.StopOrdersService/PostStopOrder`, { method: 'POST', headers, body: JSON.stringify(body), timeoutMs: 15000 });
+      if (!r.ok) throw new Error(`PostStopOrder HTTP ${r.status} ${(await r.text().catch(() => '')).slice(0, 160)}`);
+      const j = await r.json();
+      if (!j.stopOrderId) throw new Error('брокер не вернул stopOrderId');
+      acc.brokerStopBySymbol[sym] = { stopOrderId: j.stopOrderId, lots: w.lots, side: w.side, stopPx: w.stopPx, at: Date.now() };
+      logBrokerEvent(acc, 'broker_stop_set', `${sym}: ${w.side === 'long' ? 'продажа' : 'покупка'} ${w.lots} л. при цене ${w.stopPx} ₽ (стоп ${w.side === 'long' ? '−' + BROKER_STOP_LONG_PCT : '+' + BROKER_STOP_SHORT_PCT}% от средней)`);
+      changed = true;
+    } catch (e) {
+      logBrokerEvent(acc, 'broker_stop_error', `${sym}: ${e.message}`);
+    }
+  }
+  if (changed) {
+    saveRawAccounts(list);
+    hub.emit({ type: 'brokers:update', state: brokersState() });
+  }
+}
+
+// Быстрая проверка и автоматическая фиксация прибыли (Take-Profit / защита безубытка от отката) каждые 2 минуты между шагами расписания
+async function checkIntradayProfitLock(accId) {
+  const list = loadRawAccounts();
+  const acc = list.find((x) => x.id === accId);
+  if (!acc || acc.mode !== 'auto' || !acc.token || acc.haltedReason) return;
+  if (!tradingGate().allowProtective) return;
+  const nowMsk = new Date(Date.now() + MSK);
+  const dow = nowMsk.getUTCDay();
+  const mins = nowMsk.getUTCHours() * 60 + nowMsk.getUTCMinutes();
+  if (dow === 0 || dow === 6 || mins < 9 * 60 + 55 || mins > 23 * 60 + 48) return;
+  if (acc.skipEdgeMinutes && sessionEdgeWarning()) return;
+
+  const positions = acc.lastSync?.positions || [];
+  if (!positions.length) return;
+  const legacyMode = acc.legacyMode || 'isolate';
+  const baseline = acc.baselineQty || {};
+  const algoQtyOf = (sym, totalQty) => {
+    if (legacyMode === 'takeover') return totalQty;
+    const baseQ = Number(baseline[sym] || 0);
+    if (totalQty > 0 && baseQ > 0) return Math.max(0, totalQty - baseQ);
+    if (totalQty < 0 && baseQ < 0) return Math.min(0, totalQty - baseQ);
+    return totalQty;
+  };
+
+  const rawSpecs = await ensureBoardSpecs().catch(() => ({}));
+  const tbSpecs = acc.broker === 'tbank' ? (kvGet('tbankShortableMap')?.specMap || {}) : {};
+  const specs = { ...rawSpecs, ...tbSpecs };
+  const params = normalizeParams(getSettings());
+  const roundTripFeePct = 2 * ((Number(params.commissionPct) || 0.04) + (Number(params.slippagePct) || 0.01));
+  const peakMap = acc.peakPriceBySymbol || {};
+  const histOps = Array.isArray(acc.lastHistory?.operations) ? acc.lastHistory.operations : [];
+
+  const lockOrders = [];
+  for (const pos of positions) {
+    const sym = pos.symbol;
+    if (!sym) continue;
+    const aQty = algoQtyOf(sym, pos.qty);
+    if (!aQty) continue;
+    // позицию уже защищает стоп-заявка у брокера — внутренний стоп не дублируем
+    if (acc.brokerStops && acc.brokerStopBySymbol?.[sym]) continue;
+    // Если по этой бумаге в стакане УЖЕ висит закрывающая заявка (sell для лонга или buy для шорта) — не дублируем
+    const wantCloseDir = aQty > 0 ? 'sell' : 'buy';
+    if ((acc.lastSync?.activeOrders || []).some((o) => o.symbol === sym && o.direction === wantCloseDir)) continue;
+    const sp = specs[sym];
+    if (!sp) continue; // не трогаем облигации, фонды и бумаги вне словаря
+    const curPx = Number(pos.price) || 0;
+    if (curPx <= 0) continue;
+    const wantOpenKind = aQty > 0 ? 'buy' : 'sell';
+    const lastHistEntryOp = histOps.find((op) => op.symbol === sym && op.kind === wantOpenKind && op.date > 0);
+    const avgPx = Number(pos.avgPrice) > 0 ? Number(pos.avgPrice) : (Number(lastHistEntryOp?.price) || curPx);
+    if (avgPx <= 0) continue;
+
+    if (aQty > 0) {
+      const lots = Math.floor(aQty / sp.lotSize);
+      if (lots < 1) continue;
+      const curGainPct = ((curPx - avgPx) / avgPx) * 100;
+      const hitHardStopLoss = curGainPct <= -2.6;
+      if (hitHardStopLoss) {
+        const limitPrice = sniperLimitPrice(curPx, -1, acc.limitOffsetPct, sp);
+        lockOrders.push({
+          symbol: sym, action: 'sell', lotSize: sp.lotSize, lots, shares: lots * sp.lotSize,
+          refPrice: curPx, limitPrice, amountRub: round(lots * sp.lotSize * limitPrice, 2),
+          reason: `Авто-стоп позиции (${round(curGainPct, 2)}%)`,
+        });
+      }
+    } else if (aQty < 0) {
+      const lots = Math.floor(Math.abs(aQty) / sp.lotSize);
+      if (lots < 1) continue;
+      const curGainPct = ((avgPx - curPx) / avgPx) * 100;
+      const hitHardStopLoss = curGainPct <= -2.2;
+      if (hitHardStopLoss) {
+        const limitPrice = sniperLimitPrice(curPx, 1, acc.limitOffsetPct, sp);
+        lockOrders.push({
+          symbol: sym, action: 'cover', lotSize: sp.lotSize, lots, shares: lots * sp.lotSize,
+          refPrice: curPx, limitPrice, amountRub: round(lots * sp.lotSize * limitPrice, 2),
+          reason: `Авто-стоп шорта от выноса вверх (${round(curGainPct, 2)}%)`,
+        });
+      }
+    }
+  }
+
+  if (!lockOrders.length) return;
+  const results = [];
+  const execNowTs = Date.now();
+  acc.entryTsBySymbol = acc.entryTsBySymbol || {};
+  acc.exitCooldownBySymbol = acc.exitCooldownBySymbol || {};
+  acc.peakPriceBySymbol = acc.peakPriceBySymbol || {};
+  const lockSymbols = new Set(lockOrders.map((o) => o.symbol));
+  const conflictingOrders = (acc.lastSync?.activeOrders || []).filter((o) => lockSymbols.has(o.symbol) && o.orderId);
+  for (const co of conflictingOrders) {
+    await cancelBrokerOrder(accId, co.orderId).catch(() => {});
+  }
+  for (const ord of lockOrders) {
+    logBrokerEvent(acc, 'protective_stop', `${ord.reason}: ${ord.action} ${ord.symbol} ${ord.lots} л.`);
+    try {
+      const r = await sendOrderToBroker(acc, ord);
+      results.push({ symbol: ord.symbol, ok: true, orderId: r.orderId });
+      delete acc.entryTsBySymbol[ord.symbol];
+      delete acc.peakPriceBySymbol[ord.symbol];
+      acc.exitCooldownBySymbol[ord.symbol] = execNowTs;
+    } catch (e) {
+      results.push({ symbol: ord.symbol, ok: false, error: e.message });
+      logBrokerEvent(acc, 'protective_stop_error', `${ord.symbol}: ${e.message}`);
+    }
+  }
+  acc.pendingBatch = {
+    ...(acc.pendingBatch || {}),
+    id: `batch_tp_${execNowTs}`,
+    createdAt: execNowTs,
+    executedAt: execNowTs,
+    bar: `${fmtBarMsk(execNowTs)} (Take-Profit)`,
+    orders: lockOrders,
+    status: results.every((r) => r.ok) ? 'executed' : 'partial',
+    results,
+  };
+  saveRawAccounts(list);
+  await syncBrokerAccount(accId).catch(() => {});
+  const st = brokersState();
+  hub.emit({ type: 'brokers:update', state: st });
+}
+
+// Автоматическое периодическое фоновое обновление портфеля и контроль фиксации прибыли (раз в 25 секунд; история операций — раз в 2 минуты)
 let autoRefreshBusy = false;
 async function tickBrokerAutoRefresh() {
   if (autoRefreshBusy || schedulerBusy) return;
@@ -2017,7 +2852,11 @@ async function tickBrokerAutoRefresh() {
         for (const acc of list) {
           if (!acc.token) continue;
           await syncBrokerAccount(acc.id).catch(() => {});
-          if (acc.broker === 'tbank') {
+          await checkIntradayProfitLock(acc.id).catch(() => {});
+          if (acc.broker === 'tbank' && (acc.brokerStops || Object.keys(acc.brokerStopBySymbol || {}).length)) {
+            await reconcileBrokerStops(acc.id).catch((e) => logBrokerEvent(acc, 'broker_stop_error', `сверка: ${e.message}`));
+          }
+          if (acc.broker === 'tbank' && (!acc.lastHistory?.at || Date.now() - acc.lastHistory.at >= 120000)) {
             await fetchBrokerHistory(acc.id, { year: curYear }).catch(() => {});
           }
         }
@@ -2028,6 +2867,13 @@ async function tickBrokerAutoRefresh() {
   }
 }
 
+export function triggerBrokerFastEntryCheck() {
+  if (schedulerBusy || autoRefreshBusy) return;
+  setImmediate(() => {
+    tickBrokerSchedule().catch(() => {});
+  });
+}
+
 export function startBrokerScheduler() {
   ensureBoardSpecs().catch(() => {});
   // В фоне после старта сервера сразу прогреваем прогноз, чтобы при открытии вкладки «Прогноз сейчас» он уже был в памяти
@@ -2035,8 +2881,8 @@ export function startBrokerScheduler() {
     forecastNow(getSettings()).catch(() => {});
   }, 800);
   setTimeout(resumeBrokerAccountsOnBoot, 2500);
-  const timer = setInterval(tickBrokerSchedule, 60000);
-  const syncTimer = setInterval(tickBrokerAutoRefresh, 120000);
+  const timer = setInterval(tickBrokerSchedule, 20000);
+  const syncTimer = setInterval(tickBrokerAutoRefresh, 25000);
   timer.unref?.();
   syncTimer.unref?.();
 }