neuroalpha 0.3.14 → 0.3.16

package/server/brokers/index.js

@@ -14,17 +14,67 @@ import { round, MSK, DAY } from '../util.js';
 import { hub } from '../hub.js';
 
 export const BROKER_META = [
-  { id: 'tbank', name: 'Т-Банк (T-Invest API)', accountHint: 'ID счёта (оставьте пустым для выбора первого доступного)', tokenHint: 'Токен T-Invest API (t.…)' },
-  { id: 'finam', name: 'Финам (Trade API)', accountHint: 'Код клиента (ClientId, например 123456R)', tokenHint: 'Токен Finam Trade API (CA…)' },
-  { id: 'alor', name: 'Алор (OpenAPI)', accountHint: 'Портфель Мосбиржи (например D12345)', tokenHint: 'Refresh-токен Alor OpenAPI' },
-  { id: 'bcs', name: 'БКС Мир инвестиций', accountHint: 'Номер соглашения / субсчёта (необязательно)', tokenHint: 'Refresh-токен БКС Trade API' },
+  {
+    id: 'tbank',
+    name: 'Т-Банк (T-Invest API)',
+    accountHint: 'ID счёта (или нажмите «Найти мои счета по токену»)',
+    tokenHint: 'Токен T-Invest API (t.…)',
+  },
+  {
+    id: 'finam',
+    name: 'Финам (Finam Trade API)',
+    accountHint: 'Код клиента (ClientId, например 123456R)',
+    tokenHint: 'Токен Finam Trade API (CA…)',
+  },
+  {
+    id: 'bcs',
+    name: 'БКС Мир инвестиций (Trade API)',
+    accountHint: 'Номер субсчёта / соглашения (необязательно)',
+    tokenHint: 'Refresh-токен БКС Trade API',
+  },
+  {
+    id: 'alor',
+    name: 'Алор Брокер (Alor OpenAPI v2)',
+    accountHint: 'Фондовый портфель Мосбиржи (например D12345)',
+    tokenHint: 'Refresh-токен Alor OpenAPI',
+  },
+  {
+    id: 'cifra',
+    name: 'Цифра брокер (Tradernet API)',
+    accountHint: 'Номер счёта Tradernet (необязательно)',
+    tokenHint: 'Ключи Tradernet в формате PublicKey:SecretKey',
+  },
+  {
+    id: 'iticapital',
+    name: 'ITI Capital (OpenAPI)',
+    accountHint: 'Код портфеля Мосбиржи (например BP12345)',
+    tokenHint: 'Refresh-токен ITI Capital OpenAPI',
+  },
+  {
+    id: 'sber',
+    name: 'СберИнвестиции (Сбербанк)',
+    accountHint: 'Номер брокерского счёта (например 400ABCD)',
+    tokenHint: 'URL моста QUIK (http://…) или оставьте пустым для режима подтверждения заявок',
+  },
+  {
+    id: 'vtb',
+    name: 'ВТБ Мои Инвестиции',
+    accountHint: 'Номер брокерского счёта / субсчёта ВТБ',
+    tokenHint: 'URL моста QUIK (http://…) или оставьте пустым для режима подтверждения заявок',
+  },
+  {
+    id: 'alfa',
+    name: 'Альфа-Инвестиции',
+    accountHint: 'Номер брокерского счёта Альфа-Инвестиций',
+    tokenHint: 'URL моста QUIK (http://…) или оставьте пустым для режима подтверждения заявок',
+  },
 ];
 
 // ---------- справочник лотов и шага цены Мосбиржи (TQBR) ----------
 const SPECS_URL = 'https://iss.moex.com/iss/engines/stock/markets/shares/boards/TQBR/securities.json?iss.meta=off&iss.only=securities,marketdata';
 export async function ensureBoardSpecs() {
   const cached = kvGet('moexSpecs');
-  if (cached?.specs && Date.now() - cached.at < DAY) return cached.specs;
+  if (cached?.specs && cached?.v === 2 && Date.now() - cached.at < DAY) return cached.specs;
   try {
     const r = await fetch(SPECS_URL, { signal: AbortSignal.timeout(25000) });
     if (!r.ok) throw new Error(`HTTP ${r.status}`);
@@ -45,9 +95,10 @@ export async function ensureBoardSpecs() {
       const minStep = Number(row[is('MINSTEP')]) > 0 ? Number(row[is('MINSTEP')]) : 0.01;
       const decimals = Math.max(0, Number(row[is('DECIMALS')]) || 0);
       const prev = Number(row[is('PREVPRICE')] || row[is('PREVADMITTEDQUOTE')] || 0);
-      specs[sym] = { lotSize, minStep, decimals, lastPrice: prices.get(sym) || prev || 0 };
+      const issueSize = Number(row[is('ISSUESIZE')] || 0);
+      specs[sym] = { lotSize, minStep, decimals, issueSize, lastPrice: prices.get(sym) || prev || 0 };
     }
-    kvSet('moexSpecs', { at: Date.now(), specs });
+    kvSet('moexSpecs', { v: 2, at: Date.now(), specs });
     return specs;
   } catch {
     return cached?.specs || {};
@@ -94,13 +145,24 @@ function saveRawAccounts(list) {
 }
 
 function publicAccount(a) {
-  const { token, ...rest } = a;
   let baseRunLabel = null;
   if (a.baseRunId) {
     const r = getRun(Number(a.baseRunId));
     if (r) baseRunLabel = `№${r.id}${r.params?._title ? ` (${r.params._title})` : ''}`;
   }
-  return { ...rest, hasToken: Boolean(token && String(token).trim()), baseRunLabel };
+  const specs = kvGet('moexSpecs')?.specs || {};
+  let lastSync = a.lastSync || null;
+  if (lastSync && Array.isArray(lastSync.positions)) {
+    lastSync = {
+      ...lastSync,
+      positions: lastSync.positions.map((p) => {
+        const issueSize = p.issueSize || specs[p.symbol]?.issueSize || 0;
+        const ownershipPct = issueSize > 0 && p.qty > 0 ? (p.qty / issueSize) * 100 : (p.ownershipPct || null);
+        return { ...p, issueSize, ownershipPct };
+      }),
+    };
+  }
+  return { ...a, lastSync, token: a.token || '', hasToken: Boolean(a.token && String(a.token).trim()), baseRunLabel };
 }
 
 export function brokersState() {
@@ -154,9 +216,12 @@ export function saveBrokerAccount(input = {}) {
     mode,
     legacyMode,
     baselineQty: acctChanged ? null : (prev.baselineQty || null),
+    initialTotalRub: acctChanged ? 0 : (prev.initialTotalRub || 0),
     tbankAccountName: acctChanged ? '' : (prev.tbankAccountName || ''),
     equityHistory: acctChanged ? [] : (prev.equityHistory || []),
     lastHistory: acctChanged ? null : (prev.lastHistory || null),
+    entryTsBySymbol: acctChanged ? {} : (prev.entryTsBySymbol || {}),
+    exitCooldownBySymbol: acctChanged ? {} : (prev.exitCooldownBySymbol || {}),
     baseRunId: nextBaseRunId,
     // жёсткие предохранители (недоступны для изменения ИИ-Стратегом)
     maxCapitalRub,
@@ -176,7 +241,8 @@ export function saveBrokerAccount(input = {}) {
   const st = brokersState();
   hub.emit({ type: 'brokers:update', state: st });
   // При изменении стратегии, лимита капитала или режима счёта сразу пересинхронизируем счёт и пересчитываем заявки под новые настройки
-  if (strategyOrCapChanged && token) {
+  const canAutoInit = Boolean(token) || ['sber', 'vtb', 'alfa'].includes(broker);
+  if (strategyOrCapChanged && canAutoInit) {
     const activeUser = currentUser();
     setImmediate(() => {
       runWithUser(activeUser, async () => {
@@ -312,18 +378,94 @@ async function resolveTbankMetaMap(base, headers, keys = []) {
   return cache;
 }
 
+// Загружает и кэширует на 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 === 3 && cached?.map && Date.now() - cached.at < 12 * 3600000) {
+    if (cached.uidMap) {
+      for (const [sym, uid] of Object.entries(cached.uidMap)) tbankUidCache.set(sym, uid);
+    }
+    return cached.map;
+  }
+  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,
+    });
+    if (!r.ok) return cached?.map || null;
+    const j = await r.json();
+    const map = {};
+    const uidMap = { ...(cached?.uidMap || {}) };
+    const specMap = { ...(cached?.specMap || {}) };
+    for (const inst of j.instruments || []) {
+      if (!inst.ticker || inst.apiTradeAvailableFlag === false) continue;
+      if (inst.classCode === 'TQBR' || (inst.classCode === 'SPBRU' && !(inst.ticker in map))) {
+        map[inst.ticker] = Boolean(inst.shortEnabledFlag);
+        const uid = inst.uid || inst.figi;
+        if (uid) {
+          tbankUidCache.set(inst.ticker, uid);
+          uidMap[inst.ticker] = uid;
+        }
+        const minStep = qVal(inst.minPriceIncrement);
+        if (minStep > 0) {
+          const stepStr = String(minStep);
+          const dotIdx = stepStr.indexOf('.');
+          const decimals = dotIdx >= 0 ? Math.min(6, stepStr.length - dotIdx - 1) : 0;
+          specMap[inst.ticker] = {
+            lotSize: Math.max(1, Number(inst.lot) || 1),
+            minStep,
+            decimals,
+          };
+        }
+      }
+    }
+    kvSet('tbankShortableMap', { v: 3, at: Date.now(), map, uidMap, specMap });
+    return map;
+  } catch {
+    return cached?.map || null;
+  }
+}
+
 async function resolveTbankInstrumentId(base, headers, symbol) {
   if (tbankUidCache.has(symbol)) return tbankUidCache.get(symbol);
+  const savedUid = kvGet('tbankShortableMap')?.uidMap?.[symbol];
+  if (savedUid) {
+    tbankUidCache.set(symbol, savedUid);
+    return savedUid;
+  }
+  for (const classCode of ['TQBR', 'SPBRU']) {
+    try {
+      const r = await brokerFetch(`${base}/tinkoff.public.invest.api.contract.v1.InstrumentsService/ShareBy`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({ idType: 'INSTRUMENT_ID_TYPE_TICKER', classCode, id: symbol }),
+        timeoutMs: 10000,
+      });
+      if (r.ok) {
+        const j = await r.json();
+        if (j.instrument?.apiTradeAvailableFlag !== false) {
+          const uid = j.instrument?.uid || j.instrument?.figi;
+          if (uid) { tbankUidCache.set(symbol, uid); return uid; }
+        }
+      }
+    } catch { /* next classCode */ }
+  }
   try {
-    const r = await brokerFetch(`${base}/tinkoff.public.invest.api.contract.v1.InstrumentsService/ShareBy`, {
+    const r = await brokerFetch(`${base}/tinkoff.public.invest.api.contract.v1.InstrumentsService/FindInstrument`, {
       method: 'POST',
       headers,
-      body: JSON.stringify({ idType: 'INSTRUMENT_ID_TYPE_TICKER', classCode: 'TQBR', id: symbol }),
+      body: JSON.stringify({ query: symbol }),
       timeoutMs: 10000,
     });
     if (r.ok) {
       const j = await r.json();
-      const uid = j.instrument?.uid || j.instrument?.figi;
+      const hit = (j.instruments || []).find((x) => x.ticker === symbol && x.apiTradeAvailableFlag === true && x.instrumentKind === 'INSTRUMENT_TYPE_SHARE');
+      const uid = hit?.uid || hit?.figi;
       if (uid) { tbankUidCache.set(symbol, uid); return uid; }
     }
   } catch { /* fallback */ }
@@ -394,9 +536,43 @@ async function syncTbank(acc) {
     marginEnabled = !mTxt.includes('30051') && !/margin.*disabled/i.test(mTxt) ? false : false;
   }
   const p = await rPort.json();
+  const jOrd = rOrd?.ok ? await rOrd.json().catch(() => null) : null;
+  let rawOrders = jOrd?.orders || [];
+
+  // Автоматическая уборка стакана (если счёт не в режиме «Только чтение»):
+  // 1) если по одному инструменту и направлению висит несколько дублирующих заявок — оставляем только самую свежую, остальные снимаем;
+  // 2) если лимитная заявка висит неисполненной дольше 12 минут (прошла свеча, цена ушла) — автоматически снимаем её и разблокируем рубли!
+  if (acc.mode !== 'readonly' && rawOrders.length > 0) {
+    const seenInstDir = new Set();
+    const toCancelIds = [];
+    const keptOrders = [];
+    const sortedByDate = [...rawOrders].sort((a, b) => Date.parse(b.orderDate || 0) - Date.parse(a.orderDate || 0));
+    const nowMs = Date.now();
+    for (const o of sortedByDate) {
+      const k = `${o.instrumentUid || o.figi || o.ticker}:${o.direction}`;
+      const ageMs = o.orderDate ? (nowMs - Date.parse(o.orderDate)) : 0;
+      if (seenInstDir.has(k) || ageMs > 12 * 60000) {
+        if (o.orderId) toCancelIds.push(o.orderId);
+      } else {
+        seenInstDir.add(k);
+        keptOrders.push(o);
+      }
+    }
+    if (toCancelIds.length > 0) {
+      await Promise.all(toCancelIds.map((orderId) => (
+        brokerFetch(`${base}/tinkoff.public.invest.api.contract.v1.OrdersService/CancelOrder`, {
+          method: 'POST', headers, body: JSON.stringify({ accountId, orderId: String(orderId) }), timeoutMs: 8000,
+        }).catch(() => null)
+      )));
+      rawOrders = keptOrders;
+    }
+  }
   const totalRub = round(qVal(p.totalAmountPortfolio), 2);
   const rawPositions = p.positions || [];
-  const lookupIds = rawPositions.flatMap((pos) => [pos.ticker, pos.figi, pos.instrumentUid]).filter(Boolean);
+  const lookupIds = [
+    ...rawPositions.flatMap((pos) => [pos.ticker, pos.figi, pos.instrumentUid]),
+    ...rawOrders.flatMap((o) => [o.ticker, o.figi, o.instrumentUid]),
+  ].filter(Boolean);
   const metaMap = await resolveTbankMetaMap(base, headers, lookupIds);
 
   const positions = [];
@@ -410,7 +586,7 @@ async function syncTbank(acc) {
     const qty = qVal(pos.quantity);
     const px = qVal(pos.currentPrice);
     if (isRubCashPos(pos, rawTicker)) {
-      cashRub += qty;
+      cashRub += Math.max(0, qty);
       continue;
     }
     if (qty === 0) continue;
@@ -446,23 +622,28 @@ async function syncTbank(acc) {
   }
 
   const activeOrders = [];
-  if (rOrd?.ok) {
-    const jOrd = await rOrd.json();
-    for (const o of jOrd.orders || []) {
-      const m = metaMap[o.figi] || metaMap[o.instrumentUid] || {};
-      activeOrders.push({
-        orderId: o.orderId,
-        symbol: m.ticker || o.figi || '—',
-        name: m.name || '',
-        direction: String(o.direction || '').includes('BUY') ? 'buy' : 'sell',
-        lotsRequested: Number(o.lotsRequested || 0),
-        lotsExecuted: Number(o.lotsExecuted || 0),
-        price: round(qVal(o.initialSecurityPrice), 4),
-        amountRub: round(qVal(o.initialOrderPrice), 2),
-        orderDate: o.orderDate || null,
-      });
-    }
+  for (const o of rawOrders) {
+    const m = metaMap[o.ticker] || metaMap[o.figi] || metaMap[o.instrumentUid] || {};
+    const sym = m.ticker || o.ticker || o.figi || '—';
+    const lotsReq = Number(o.lotsRequested || 0);
+    const lotsExec = Number(o.lotsExecuted || 0);
+    const remLots = Math.max(0, lotsReq - lotsExec);
+    const totalOrdRub = qVal(o.initialOrderPrice);
+    const remRub = lotsReq > 0 ? round(totalOrdRub * (remLots / lotsReq), 2) : round(totalOrdRub, 2);
+    activeOrders.push({
+      orderId: o.orderId,
+      symbol: sym,
+      name: m.name || '',
+      direction: String(o.direction || '').includes('BUY') ? 'buy' : 'sell',
+      lotsRequested: lotsReq,
+      lotsExecuted: lotsExec,
+      price: round(qVal(o.initialSecurityPrice), 4),
+      amountRub: remRub,
+      orderDate: o.orderDate || null,
+    });
   }
+  const activeBuyOrdersRub = activeOrders.filter((o) => o.direction === 'buy').reduce((s, o) => s + (o.amountRub || 0), 0);
+  cashRub = Math.max(0, cashRub - activeBuyOrdersRub);
 
   const breakdown = {
     sharesRub: round(qVal(p.totalAmountShares), 0),
@@ -667,11 +848,109 @@ async function syncBcs(acc) {
   return { accountId: acc.accountId || 'основной', totalRub: round(totalRub, 2), cashRub: round(cashRub, 2), positions };
 }
 
+async function syncCifra(acc) {
+  const [apiKey, secKey] = String(acc.token || '').split(':').map((s) => s.trim());
+  if (!apiKey || !secKey) throw new Error('Для Цифра брокер (Tradernet API) укажите ключи в формате PublicKey:SecretKey');
+  const qObj = { cmd: 'getPositionJson', params: {} };
+  const qStr = `q=${JSON.stringify(qObj)}`;
+  const sig = crypto.createHmac('sha256', secKey).update(qStr).digest('hex');
+  const r = await fetch('https://tradernet.ru/api/v2/cmd/getPositionJson', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded', 'X-NtApi-PublicKey': apiKey, 'X-NtApi-Sig': sig },
+    body: qStr,
+    signal: AbortSignal.timeout(15000),
+  });
+  if (!r.ok) throw new Error(`Tradernet API: HTTP ${r.status}`);
+  const j = await r.json();
+  const ps = j?.result?.ps || {};
+  const accList = Array.isArray(ps.acc) ? ps.acc : [];
+  const rubAcc = accList.find((c) => c.curr === 'RUR' || c.curr === 'RUB') || accList[0] || {};
+  const cashRub = round(Number(rubAcc.s || 0), 2);
+  const posRaw = Array.isArray(ps.pos) ? ps.pos : [];
+  let posSum = 0, pnlSum = 0;
+  const positions = posRaw.map((p) => {
+    const qty = Number(p.q || 0);
+    const price = round(Number(p.mkt_price || p.price_a || 0), 4);
+    const val = round(Number(p.s || qty * price), 2);
+    const pnl = round(Number(p.vm || 0), 2);
+    posSum += val;
+    pnlSum += pnl;
+    return { symbol: String(p.i || '').replace(/\..*$/, ''), name: p.name || p.i || '', qty, price, valueRub: val, pnlRub: pnl };
+  });
+  return { accountId: acc.accountId || 'Tradernet', marginEnabled: true, totalRub: round(cashRub + posSum, 2), cashRub, totalPnlRub: round(pnlSum, 2), positions };
+}
+
+async function syncItiCapital(acc) {
+  if (!acc.accountId) throw new Error('Укажите портфель ITI Capital (например BP12345)');
+  const oauth = acc.sandbox ? 'https://oauthdev.iticapital.ru' : 'https://oauth.iticapital.ru';
+  const api = acc.sandbox ? 'https://apidev.iticapital.ru' : 'https://api.iticapital.ru';
+  const rTok = await fetch(`${oauth}/refresh?token=${encodeURIComponent(acc.token)}`, { method: 'POST', signal: AbortSignal.timeout(15000) });
+  if (!rTok.ok) throw new Error(`ITI Capital OAuth: HTTP ${rTok.status}`);
+  const { AccessToken } = await rTok.json();
+  if (!AccessToken) throw new Error('ITI Capital не вернул AccessToken');
+  const headers = { Authorization: `Bearer ${AccessToken}` };
+  const [rSum, rPos] = await Promise.all([
+    fetch(`${api}/md/v2/Clients/MOEX/${encodeURIComponent(acc.accountId)}/summary`, { headers, signal: AbortSignal.timeout(15000) }),
+    fetch(`${api}/md/v2/Clients/MOEX/${encodeURIComponent(acc.accountId)}/positions`, { headers, signal: AbortSignal.timeout(15000) }),
+  ]);
+  if (!rSum.ok) throw new Error(`ITI Capital summary: HTTP ${rSum.status}`);
+  const sum = await rSum.json();
+  const posList = rPos.ok ? await rPos.json() : [];
+  let cashRub = round(Number(sum.buyingPower || sum.cash || 0), 2);
+  const positions = [];
+  for (const p of Array.isArray(posList) ? posList : []) {
+    if (p.isCurrency || p.symbol === 'RUB') { cashRub = round(Number(p.qtyUnits || p.qty || cashRub), 2); continue; }
+    const qty = Number(p.qtyUnits || p.qty || 0);
+    const val = Number(p.volume || 0);
+    positions.push({ symbol: p.symbol, qty, price: qty ? round(val / qty, 4) : 0, valueRub: round(val, 2), pnlRub: round(Number(p.unrealisedPl || 0), 2) });
+  }
+  return { accountId: acc.accountId, marginEnabled: true, totalRub: round(Number(sum.portfolioLiquidationValue || cashRub), 2), cashRub, positions };
+}
+
+async function syncQuikOrManual(acc) {
+  const tokenStr = String(acc.token || '').trim();
+  if (tokenStr.startsWith('http://') || tokenStr.startsWith('https://')) {
+    const base = tokenStr.replace(/\/+$/, '');
+    const r = await fetch(`${base}/portfolio?account=${encodeURIComponent(acc.accountId || '')}`, { signal: AbortSignal.timeout(12000) });
+    if (!r.ok) throw new Error(`QUIK HTTP-шлюз: HTTP ${r.status}`);
+    const j = await r.json();
+    const positions = (j.positions || []).map((p) => ({
+      symbol: p.symbol || p.secCode,
+      name: p.name || p.symbol || p.secCode,
+      qty: Number(p.qty || p.currentBal || 0),
+      price: round(Number(p.price || p.lastPrice || 0), 4),
+      valueRub: round(Number(p.valueRub || 0), 2),
+      pnlRub: round(Number(p.pnlRub || 0), 2),
+    }));
+    const cashRub = round(Number(j.cashRub ?? j.cash ?? acc.maxCapitalRub ?? 100000), 2);
+    const totalRub = round(Number(j.totalRub ?? (cashRub + positions.reduce((s, x) => s + x.valueRub, 0))), 2);
+    return { accountId: acc.accountId || 'QUIK', marginEnabled: Boolean(j.marginEnabled), totalRub, cashRub, positions };
+  }
+  // Режим подтверждения заявок (СберИнвестиции / ВТБ / Альфа без QUIK-шлюза): учёт позиций и лимита внутри платформы
+  const specs = await ensureBoardSpecs();
+  const prevPos = acc.lastSync?.positions || [];
+  let posVal = 0, pnlSum = 0;
+  const positions = prevPos.filter((p) => p.qty !== 0).map((p) => {
+    const px = specs[p.symbol]?.lastPrice || p.price || 0;
+    const avg = p.avgPrice || p.price || px;
+    const valueRub = round(p.qty * px, 2);
+    const pnlRub = round(p.qty * (px - avg), 2);
+    posVal += Math.abs(valueRub);
+    pnlSum += pnlRub;
+    return { ...p, avgPrice: avg, price: round(px, 4), valueRub, pnlRub };
+  });
+  const baseCap = acc.maxCapitalRub || 100000;
+  const cashRub = acc.lastSync?.cashRub !== undefined ? round(acc.lastSync.cashRub, 2) : round(Math.max(0, baseCap - posVal), 2);
+  const totalRub = round(cashRub + posVal, 2);
+  return { accountId: acc.accountId || 'Ручное подтверждение', marginEnabled: false, totalRub, cashRub, totalPnlRub: round(pnlSum, 2), positions };
+}
+
 export async function syncBrokerAccount(id) {
   const list = loadRawAccounts();
   const acc = list.find((x) => x.id === id);
   if (!acc) throw new Error('Счёт не найден');
-  if (!acc.token) throw new Error('У счёта не задан токен API');
+  const isManualCapable = ['sber', 'vtb', 'alfa'].includes(acc.broker);
+  if (!acc.token && !isManualCapable) throw new Error('У счёта не задан токен API');
   const today = new Date(Date.now() + MSK).toISOString().slice(0, 10);
   try {
     let data;
@@ -679,15 +958,48 @@ export async function syncBrokerAccount(id) {
     else if (acc.broker === 'finam') data = await syncFinam(acc);
     else if (acc.broker === 'alor') data = await syncAlor(acc);
     else if (acc.broker === 'bcs') data = await syncBcs(acc);
+    else if (acc.broker === 'cifra') data = await syncCifra(acc);
+    else if (acc.broker === 'iticapital') data = await syncItiCapital(acc);
+    else if (isManualCapable) data = await syncQuikOrManual(acc);
     else throw new Error(`Неизвестный брокер: ${acc.broker}`);
     if (data.accountId && !acc.accountId) acc.accountId = data.accountId;
+    const specs = await ensureBoardSpecs();
+    if (Array.isArray(data.positions)) {
+      data.positions = data.positions.map((p) => {
+        const issueSize = specs[p.symbol]?.issueSize || 0;
+        const ownershipPct = issueSize > 0 && p.qty > 0 ? (p.qty / issueSize) * 100 : null;
+        return { ...p, issueSize, ownershipPct };
+      });
+    }
     if (data.accountName) acc.tbankAccountName = data.accountName;
     if ((!acc.name || acc.name === 'Т-Банк (T-Invest API)') && data.accountName) {
       acc.name = `Т-Банк · ${data.accountName}`;
     }
-    // При первой синхронизации (или если старый снимок был пустым, а бумаги на счёте есть) запоминаем стартовый портфель
+    // При первой синхронизации запоминаем стартовый портфель и стартовую базу капитала;
+    // а при продаже старых бумаг (в режиме «Плавный переход» или вручную) автоматически уменьшаем baselineQty до фактического остатка,
+    // чтобы новые покупки стратегии по тем же тикерам никогда не путались со старым портфелем
     if (!acc.baselineQty || (!Object.keys(acc.baselineQty).length && data.positions?.length)) {
       acc.baselineQty = Object.fromEntries((data.positions || []).filter((p) => p.qty !== 0).map((p) => [p.symbol, p.qty]));
+    } else if (acc.baselineQty && Array.isArray(data.positions)) {
+      const curPosMap = new Map(data.positions.map((p) => [p.symbol, p.qty]));
+      for (const [sym, bq] of Object.entries(acc.baselineQty)) {
+        const curQ = Number(curPosMap.get(sym) || 0);
+        if (bq > 0 && curQ < bq) {
+          if (curQ <= 0) delete acc.baselineQty[sym];
+          else acc.baselineQty[sym] = curQ;
+        } else if (bq < 0 && curQ > bq) {
+          if (curQ >= 0) delete acc.baselineQty[sym];
+          else acc.baselineQty[sym] = curQ;
+        }
+      }
+    }
+    if (!acc.initialTotalRub && data.totalRub > 0) {
+      acc.initialTotalRub = round(data.totalRub, 2);
+    }
+    // С началом нового календарного дня автоматически сбрасываем вчерашний дневной стоп по просадке
+    if (acc.lastSync?.day && acc.lastSync.day !== today && acc.haltedReason && acc.haltedReason.startsWith('Сработал дневной стоп')) {
+      acc.haltedReason = null;
+      acc.ddBreachCount = 0;
     }
     const prevDay = acc.lastSync?.day === today ? acc.lastSync.dayStartRub : data.totalRub;
     const dayStartRub = prevDay > 0 ? prevDay : data.totalRub;
@@ -695,7 +1007,13 @@ export async function syncBrokerAccount(id) {
     if (data.autoFollowDetected || /автослед|сигнал|copy|follow|comon/i.test(acc.name || '')) {
       acc.haltedReason = 'Заблокировано: на счёте обнаружено Автоследование (использование счетов автоследования запрещено Публичной офертой и правилами платформы)';
     } else if (ddPct >= acc.maxDailyDrawdownPct) {
-      acc.haltedReason = `Сработал дневной стоп по просадке: −${ddPct}% (порог ${acc.maxDailyDrawdownPct}%)`;
+      // Требуем подтверждения просадки на 2 синхронизациях подряд (защита от секундного переходного состояния API брокера в момент исполнения лимитной заявки)
+      acc.ddBreachCount = (acc.ddBreachCount || 0) + 1;
+      if (acc.ddBreachCount >= 2) {
+        acc.haltedReason = `Сработал дневной стоп по просадке: −${ddPct}% (порог ${acc.maxDailyDrawdownPct}%)`;
+      }
+    } else {
+      acc.ddBreachCount = 0;
     }
     // История оценки счёта (сохраняется на диске и переживает перезапуск сервера)
     const hist = Array.isArray(acc.equityHistory) ? acc.equityHistory : [];
@@ -705,6 +1023,17 @@ export async function syncBrokerAccount(id) {
       if (hist.length > 500) hist.splice(0, hist.length - 500);
     }
     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;
+    }
+    for (const s of Object.keys(entryMap)) {
+      if (!curSymbols.has(s)) delete entryMap[s];
+    }
+    acc.entryTsBySymbol = entryMap;
     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 };
@@ -715,6 +1044,7 @@ export async function syncBrokerAccount(id) {
   saveRawAccounts(list);
   const st = brokersState();
   hub.emit({ type: 'brokers:update', state: st });
+  hub.emit({ type: 'trading:pulse', kind: 'broker_sync', ts: Date.now(), accountId: acc.id, name: acc.name });
   return st;
 }
 
@@ -753,51 +1083,106 @@ function sessionEdgeWarning(now = Date.now()) {
 
 // ---------- формирование и исполнение пакета лимитных заявок ----------
 export async function prepareBrokerOrders(id) {
-  const list = loadRawAccounts();
-  const acc = list.find((x) => x.id === id);
+  let list = loadRawAccounts();
+  let acc = list.find((x) => x.id === id);
   if (!acc) throw new Error('Счёт не найден');
   if (acc.haltedReason) throw new Error(acc.haltedReason);
   const edgeWarn = acc.skipEdgeMinutes ? sessionEdgeWarning() : null;
 
   const plan = effectivePlan(currentUser());
   if ((plan.maxBrokerAccounts ?? 0) < 1) {
-    throw new Error(`На бесплатном тарифе «${plan.name}» работа с реальными брокерскими счетами недоступна (доступно тестирование в Экспериментах и виртуальный счёт). Оформите тариф «Инвестор», «Профи» или «VIP».`);
+    throw new Error('Для работы с брокерскими счетами оформите подписку «Инвестор» (3 900 ₽/мес), «Профи» (9 900 ₽/мес) или «VIP» в разделе «Подписка и уведомления».');
   }
-  const baseRun = acc.baseRunId ? getRun(Number(acc.baseRunId)) : null;
-  const params = normalizeParams(baseRun?.params || getSettings());
-  const [fc, specs] = await Promise.all([
+  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) {
+    await cancelBrokerOrder(id, 'all').catch(() => {});
+    list = loadRawAccounts();
+    acc = list.find((x) => x.id === id) || acc;
+  } else if (acc.token && (!acc.lastSync || Date.now() - (acc.lastSync.at || 0) > 45000)) {
+    await syncBrokerAccount(id).catch(() => {});
+    list = loadRawAccounts();
+    acc = list.find((x) => x.id === id) || acc;
+  }
+  const params = normalizeParams(getSettings());
+  const [fc, rawSpecs, shortableMap] = await Promise.all([
     forecastNow(params),
     ensureBoardSpecs(),
+    ensureTbankShortableMap(acc),
   ]);
+  const specs = { ...rawSpecs };
+  if (acc.broker === 'tbank') {
+    const tbSpecs = kvGet('tbankShortableMap')?.specMap || {};
+    for (const [sym, ts] of Object.entries(tbSpecs)) {
+      specs[sym] = { ...(specs[sym] || { lastPrice: 0, issueSize: 0 }), ...ts };
+    }
+  }
   const capCeiling = plan.maxCapitalPerAccountRub > 0 ? plan.maxCapitalPerAccountRub : 1000000000;
   const effectiveMaxCap = Math.min(acc.maxCapitalRub, capCeiling);
-  const budget = Math.min(effectiveMaxCap, acc.lastSync?.totalRub > 0 ? acc.lastSync.totalRub : effectiveMaxCap);
-  const K = params.modelTopK || 3;
+  // Лимит тарифа (1 млн ₽ на Инвесторе/Профи) ограничивает СТАРТОВУЮ выделенную сумму на счёте,
+  // а вся заработанная стратегией сверху прибыль автоматически реинвестируется в рабочий бюджет (сложный процент):
+  const curTotalRub = acc.lastSync?.totalRub > 0 ? acc.lastSync.totalRub : effectiveMaxCap;
+  const initBaseRub = acc.initialTotalRub > 0 ? acc.initialTotalRub : (acc.equityHistory?.[0]?.totalRub > 0 ? acc.equityHistory[0].totalRub : curTotalRub);
+  const reinvestedProfitRub = round(Math.max(0, curTotalRub - Math.max(initBaseRub, effectiveMaxCap)), 0);
+  const allowedTotalCapRub = effectiveMaxCap + reinvestedProfitRub;
+  const budget = round(Math.min(allowedTotalCapRub, curTotalRub), 0);
+  const autoAdapt = params.modelAutoAdapt !== false;
+  const rawTopK = Number(params.modelTopK ?? 2);
+  const autoK = rawTopK === 0 || autoAdapt;
+  const K = rawTopK > 0 ? rawTopK : 4;
+  const filterBrokerDynamicTopK = (cands, needVal, maxCount) => {
+    if (!cands.length || maxCount <= 0) return [];
+    const lim = Math.min(cands.length, maxCount);
+    if (!autoK || lim <= 1) return cands.slice(0, lim);
+    const bestE = Math.abs(cands[0].expectedPct || 0);
+    const out = [cands[0]];
+    for (let m = 1; m < lim; m++) {
+      const curE = Math.abs(cands[m].expectedPct || 0);
+      const relMin = m === 1 ? 0.62 : 0.78;
+      const absMin = m === 1 ? needVal * 1.15 : needVal * 1.45;
+      if (curE >= bestE * relMin && curE >= absMin) out.push(cands[m]);
+      else break;
+    }
+    return out;
+  };
   // Автоматическая подстройка направления и мощности торговли под тариф и реальные данные счёта:
   const marginAllowed = acc.lastSync?.marginEnabled !== false;
   const planAllowsShorts = Boolean(plan.allowShorts);
   const vipBoost = Boolean(plan.allowVipBoost);
   const rawDir = params.modelDirection || 'long';
   const dir = (marginAllowed && planAllowsShorts) ? rawDir : 'long';
-  const autoAdapt = params.modelAutoAdapt !== false;
   const exitRatio = autoAdapt ? 0.95 : Number(params.modelExitRatio ?? 0.5);
   const exitThresholdPct = round((fc.thresholdPct || 0) * exitRatio, 3);
+  const earlyExitThresholdPct = round((fc.thresholdPct || 0) * 0.35, 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);
+  const isInCooldown = (sym) => autoAdapt && exitCooldownMap[sym] && (nowTs - exitCooldownMap[sym] < 60 * 60000);
   const slots = dir === 'long' ? K : 2 * K;
   // Фильтр мощности слота по тарифу:
-  // • Инвестор (до 50% годовых): только покупки (без шортов), консервативный слот 1 / (K + 1) (до 22% капитала)
-  // • Профи (до 100% годовых): покупки + шорты, стандартный равный слот 1 / (2K) (до 25% капитала, шаг раз в полный горизонт H)
-  // • VIP (без ограничений): полный форсаж (Conviction Slot Sizing до 42% капитала в лучших сигналах + полушаговый перехват H/2)
+  // • Инвестор (до 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);
   let slotRub;
-  if (vipBoost && autoAdapt) {
-    const maxSlotWeight = dir === 'long' ? Math.min(0.48, Math.max(1 / K, 1.4 / K)) : Math.min(0.48, 1.9 / (2 * K));
+  if (isOwnerPlan && autoAdapt) {
+    const maxSlotWeight = dir === 'long' ? Math.min(0.58, Math.max(1 / K, 1.8 / K)) : Math.min(0.75, 3.0 / (2 * K));
+    slotRub = budget * maxSlotWeight;
+  } else if (vipBoost && autoAdapt) {
+    const maxSlotWeight = dir === 'long' ? Math.min(0.45, Math.max(1 / K, 1.4 / K)) : Math.min(0.48, 1.9 / (2 * K));
     slotRub = budget * maxSlotWeight;
   } else if (plan.id === 'pro') {
-    slotRub = budget * Math.min(0.25, 1 / Math.max(2, slots));
+    slotRub = budget * Math.min(0.28, 1.15 / Math.max(2, slots));
   } else {
-    slotRub = budget * Math.min(0.22, 1 / Math.max(3, K + 1));
+    slotRub = budget * Math.min(0.24, 1.05 / Math.max(3, K + 1));
   }
-  // Дополнительный мягкий дроссель при опережении годового потолка доходности тарифа (50% для Инвестора, 100% для Профи)
-  if (!vipBoost && plan.maxAnnualReturnPct > 0 && Array.isArray(acc.equityHistory) && acc.equityHistory.length >= 2) {
+  // Мягкий дроссель при опережении годового потолка доходности тарифа (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);
@@ -810,14 +1195,29 @@ export async function prepareBrokerOrders(id) {
     }
   }
   const needPct = Math.max(0.01, Number(fc.thresholdPct || 0));
-  const convOf = (r) => (vipBoost && autoAdapt && r.expectedPct ? Math.min(1.25, Math.max(0.85, 0.80 + 0.25 * (Math.abs(r.expectedPct) / needPct))) : 1);
+  const convOf = (r) => {
+    if (!autoAdapt || !r.expectedPct) return 1;
+    if (isOwnerPlan) return Math.min(1.65, Math.max(0.85, 0.80 + 0.30 * (Math.abs(r.expectedPct) / needPct)));
+    if (vipBoost) return Math.min(1.30, Math.max(0.85, 0.80 + 0.25 * (Math.abs(r.expectedPct) / needPct)));
+    return 1;
+  };
   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(baseRun?.extra?.adaptation?.quarantined || []);
+  const quarantined = new Set();
   const nb = params.newsFilter ? blockingNews(6) : null;
 
-  const buyCands = fc.rows.filter((r) => r.signal && !quarantined.has(r.symbol) && !nb?.get(r.symbol)?.bad).sort((a, b) => b.expectedPct - a.expectedPct).slice(0, K);
-  const rawShortCands = rawDir !== 'long' ? fc.rows.filter((r) => r.shortSignal && !quarantined.has(r.symbol) && !nb?.get(r.symbol)?.good).sort((a, b) => a.expectedPct - b.expectedPct).slice(0, K) : [];
+  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 nonShortableSkipped = [];
+  const rawShortCands = [];
+  for (const r of allShortSignals) {
+    if (shortableMap && shortableMap[r.symbol] === false) {
+      nonShortableSkipped.push(r);
+      continue;
+    }
+    rawShortCands.push(r);
+    if (rawShortCands.length >= K) break;
+  }
   const shortCands = (marginAllowed && planAllowsShorts) ? rawShortCands : [];
 
   const legacyMode = acc.legacyMode || 'isolate';
@@ -843,38 +1243,42 @@ 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);
+    // Как в эталонном симуляторе (research.js): первые 65 минут после открытия позиции действует мягкий порог удержания (0.35),
+    // чтобы не резать сделку от рыночного шума каждые 30 минут; затем включается плотный порог фиксации (0.95)
+    const curExitThr = (autoAdapt && heldMs <= 65 * 60000) ? earlyExitThresholdPct : exitThresholdPct;
     if (aQty > 0) {
       const lots = Math.floor(aQty / sp.lotSize);
-      const keep = r.liquid && r.expectedPct > exitThresholdPct;
+      const keep = r.liquid && r.expectedPct > curExitThr;
       if (lots >= 1 && !keep) {
         const limitPrice = roundToStep(pos.price * (1 - acc.limitOffsetPct / 100), sp.minStep, sp.decimals);
         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}% ниже порога удержания +${exitThresholdPct}%`,
+          reason: `Выход из покупки: ожидание ${r.expectedPct > 0 ? '+' : ''}${r.expectedPct}% ниже порога удержания +${curExitThr}%`,
         });
         closing.add(sym);
       }
     } else if (aQty < 0) {
       const lots = Math.floor(Math.abs(aQty) / sp.lotSize);
-      const keep = dir !== 'long' && r.liquid && r.expectedPct < -exitThresholdPct;
+      const keep = dir !== 'long' && r.liquid && r.expectedPct < -curExitThr;
       if (lots >= 1 && !keep) {
         const limitPrice = roundToStep(pos.price * (1 + acc.limitOffsetPct / 100), sp.minStep, sp.decimals);
         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}% выше порога удержания −${exitThresholdPct}%`,
+          reason: `Закрытие шорта: ожидание ${r.expectedPct > 0 ? '+' : ''}${r.expectedPct}% выше порога удержания −${curExitThr}%`,
         });
         closing.add(sym);
       }
     }
     // В режиме «Плавный переход» (smooth) проверяем начальные акции:
-    // если по старой акции вышел сильный сигнал падения (shortSignal), защищаем счёт и закрываем её;
-    // иначе сохраняем в список кандидатов на плавное высвобождение капитала под новые покупки
+    // 1) если по старой акции вышел сильный медвежий сигнал (ожидание ниже −needPct), сразу закрываем всю позицию для защиты счёта;
+    // 2) иначе добавляем бумагу в пул плавной ротации (в первую очередь высвобождаются бумаги с отрицательным/слабым прогнозом под новые лонги и шорты)
     if (legacyMode === 'smooth' && baseQty > 0 && !closing.has(sym)) {
       const bLots = Math.floor(baseQty / sp.lotSize);
       if (bLots >= 1 && !(r.liquid && r.expectedPct > exitThresholdPct)) {
-        if (r.expectedPct < -needPct) {
+        if (r.expectedPct <= -needPct) {
           const limitPrice = roundToStep(pos.price * (1 - acc.limitOffsetPct / 100), sp.minStep, sp.decimals);
           orders.push({
             symbol: sym, action: 'sell', lotSize: sp.lotSize, lots: bLots, shares: bLots * sp.lotSize,
@@ -895,63 +1299,95 @@ export async function prepareBrokerOrders(id) {
   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) вход в лучшие сигналы (с учётом лотности Мосбиржи и свободного лимита)
-  const newBuys = buyCands.filter((r) => !(algoQtyOf(r.symbol, heldMap.get(r.symbol)?.qty || 0) > 0 && !closing.has(r.symbol))).slice(0, Math.max(0, K - activeLongs));
-  const newShorts = shortCands.filter((r) => !(algoQtyOf(r.symbol, heldMap.get(r.symbol)?.qty || 0) < 0 && !closing.has(r.symbol))).slice(0, Math.max(0, K - activeShorts));
-
-  // В режиме «Плавный переход», если под новые покупки не хватает свободных рублей, плавно высвобождаем из начального портфеля
-  // (в первую очередь бумаги в плюсе или с наименьшим прогнозом, не более 2 бумаг за шаг)
-  if (legacyMode === 'smooth' && newBuys.length > 0 && smoothSellPool.length > 0) {
-    const neededRub = newBuys.reduce((s, r) => s + (params.modelAllocMode === 'invvol' && r.weight ? slotRub * r.weight : slotRub) * convOf(r), 0);
-    let shortfall = Math.min(Math.max(0, budget * 0.99 - usedRub), neededRub) - availRub;
+    // 2) вход в лучшие сигналы (с учётом лотности Мосбиржи, свободного лимита и адаптивного отбора числа акций Dynamic Top-K)
+  const rawNewBuys = buyCands.filter((r) => !(algoQtyOf(r.symbol, heldMap.get(r.symbol)?.qty || 0) > 0 && !closing.has(r.symbol)));
+  // Не открываем шорт по тикеру, в котором ещё лежит непроданный остаток старого портфеля (baseQty > 0), чтобы брокер не превратил шорт в продажу старой позиции
+  const rawNewShorts = shortCands.filter((r) => {
+    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 totalNew = newBuys.length + newShorts.length;
+  const activeTotal = Math.max(2, activeLongs + activeShorts + totalNew);
+  const dynSlotRub = (isOwnerPlan && autoAdapt)
+    ? budget * Math.min(dir === 'long' ? 0.58 : 0.75, Math.max(slotRub / Math.max(1, budget), (dir === 'long' ? 1.8 : 3.0) / Math.min(slots, activeTotal + 1)))
+    : (vipBoost && autoAdapt)
+      ? budget * Math.min(0.48, Math.max(slotRub / Math.max(1, budget), (dir === 'long' ? 1.4 : 1.9) / Math.min(slots, activeTotal + 1)))
+      : slotRub;
+
+  // В режиме «Плавный переход» (smooth):
+  // • высвобождаем кэш из старого портфеля как под новые ПОКУПКИ, так и под новые ШОРТЫ (чтобы шорты открывались полным рабочим слотом dynSlotRub, а не на остаток копеек);
+  // • даже если прямо сейчас нет нового входа, но свободного кэша на счёте меньше 1 рабочего слота, плавно продаём на каждом шаге по 1–2 самые слабые старые акции с отрицательным прогнозом (expectedPct <= -0.02%), заранее формируя рублёвый резерв;
+  // • сортируем кандидатов строго по худшему прогнозу ИИ (сначала акции с отрицательным ожиданием, среди близких — позиции в плюсе или с минимальным убытком), до 4 бумаг за шаг при активном сигнале.
+  if (legacyMode === 'smooth' && smoothSellPool.length > 0) {
+    const activeEntries = [...newBuys, ...newShorts];
+    const neededForSignalsRub = activeEntries.reduce((s, r) => s + (params.modelAllocMode === 'invvol' && r.weight ? dynSlotRub * r.weight : dynSlotRub) * convOf(r), 0);
+    const hasWeakLegacy = smoothSellPool.some((x) => (x.r.expectedPct || 0) <= -0.02);
+    const proactiveReserveRub = (!activeEntries.length && hasWeakLegacy && availRub < slotRub) ? slotRub : 0;
+    const targetNeedRub = Math.max(neededForSignalsRub, proactiveReserveRub);
+    let shortfall = Math.min(Math.max(0, budget * 0.99 - usedRub), targetNeedRub) - availRub;
     if (shortfall > 1000) {
-      smoothSellPool.sort((a, b) => ((b.pos.pnlRub >= 0 ? 1 : 0) - (a.pos.pnlRub >= 0 ? 1 : 0)) || (a.r.expectedPct - b.r.expectedPct));
-      for (const item of smoothSellPool.slice(0, 2)) {
+      smoothSellPool.sort((a, b) => {
+        const ea = Number(a.r.expectedPct || 0);
+        const eb = Number(b.r.expectedPct || 0);
+        // Сначала бумаги с явно худшим прогнозом (разница > 0.03%), при близком прогнозе — сначала плюсовые/околонулевые
+        if (Math.abs(ea - eb) > 0.03) return ea - eb;
+        return ((b.pos.pnlRub >= 0 ? 1 : 0) - (a.pos.pnlRub >= 0 ? 1 : 0)) || (ea - eb);
+      });
+      const maxSteps = activeEntries.length > 0 ? 4 : 2;
+      const poolToUse = activeEntries.length > 0
+        ? smoothSellPool.slice(0, maxSteps)
+        : 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 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);
+        const sigReason = activeEntries.length > 0
+          ? `под сигнал стратегии (${activeEntries.map((x) => x.symbol).join(', ')})`
+          : 'упреждающее освобождение кэша из слабой бумаги';
         orders.push({
           symbol: item.sym, action: 'sell', lotSize: item.sp.lotSize, lots: lotsToSell, shares: lotsToSell * item.sp.lotSize,
           refPrice: item.pos.price, limitPrice, amountRub,
-          reason: `Плавный переход: высвобождение ${fmtRubSimple(amountRub)} ₽ из старого портфеля (ожидание ${item.r.expectedPct > 0 ? '+' : ''}${item.r.expectedPct}%) под новый сигнал покупки`,
+          reason: `Плавный переход: высвобождение ${fmtRubSimple(amountRub)} ₽ из старого портфеля (прогноз ${item.r.expectedPct > 0 ? '+' : ''}${item.r.expectedPct}%) ${sigReason}`,
         });
         availRub += amountRub;
         shortfall -= amountRub;
       }
     }
   }
-  const totalNew = newBuys.length + newShorts.length;
   let remNew = totalNew;
-
-  for (const r of newBuys) {
-    const rawSum = (params.modelAllocMode === 'invvol' && r.weight ? slotRub * r.weight : slotRub) * convOf(r);
-    const sum = Math.min(rawSum, availRub / Math.max(1, remNew));
-    remNew--;
-    const refPx = specs[r.symbol]?.lastPrice || 0;
-    const ord = calcLotOrder(r.symbol, sum, refPx, 'buy', acc.limitOffsetPct, specs);
-    if (ord) {
-      availRub = Math.max(0, availRub - ord.amountRub);
-      orders.push({
-        ...ord,
-        expectedPct: r.expectedPct,
-        reason: `Покупка (${MODELS[params.modelType]?.label || params.modelType}): ожидание ${r.expectedPct > 0 ? '+' : ''}${r.expectedPct}% за ${params.modelHorizon} ч`,
-      });
-    }
+  const combinedNew = [
+    ...newBuys.map((r) => ({ r, side: 'buy' })),
+    ...newShorts.map((r) => ({ r, side: 'short' })),
+  ];
+  if (autoAdapt && combinedNew.length > 1) {
+    combinedNew.sort((a, b) => Math.abs(b.r.expectedPct || 0) - Math.abs(a.r.expectedPct || 0));
   }
-  for (const r of newShorts) {
-    const rawSum = (params.modelAllocMode === 'invvol' && r.weight ? slotRub * r.weight : slotRub) * convOf(r);
-    const sum = Math.min(rawSum, availRub / Math.max(1, remNew));
+  let remWeightSum = combinedNew.reduce((s, x) => s + Math.max(0.01, Math.abs(x.r.expectedPct || 0)), 0);
+
+  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 refPx = specs[r.symbol]?.lastPrice || 0;
-    const ord = calcLotOrder(r.symbol, sum, refPx, 'short', acc.limitOffsetPct, specs);
+    const rawSum = (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);
     if (ord) {
       availRub = Math.max(0, availRub - ord.amountRub);
       orders.push({
         ...ord,
         expectedPct: r.expectedPct,
-        reason: `Продажа без покупки: ожидание ${r.expectedPct}% за ${params.modelHorizon} ч`,
+        reason: side === 'buy'
+          ? `Покупка (${MODELS[params.modelType]?.label || params.modelType}): ожидание ${r.expectedPct > 0 ? '+' : ''}${r.expectedPct}% за ${params.modelHorizon} ч`
+          : `Продажа без покупки: ожидание ${r.expectedPct}% за ${params.modelHorizon} ч`,
       });
     }
   }
@@ -960,9 +1396,13 @@ export async function prepareBrokerOrders(id) {
   let planThrottleNote = '';
   if (plan.id === 'investor') {
     const shInfo = rawShortCands.length ? ` (пропущены сигналы на шорт: ${rawShortCands.map((r) => `${r.symbol} ${r.expectedPct}%`).join(', ')})` : '';
-    planThrottleNote = `Тариф «Инвестор» (целевой потолок до 50% годовых, лимит до 1 млн ₽/счёт): активен режим «Только в рост (без шорта)» и консервативный слот 22%${shInfo}. Для включения заработка на падении акций (шорты, до 100% годовых и до 10 млн ₽/счёт) перейдите на тариф «Профи».`;
+    const reinvNote = reinvestedProfitRub > 0 ? ` + реинвестировано прибыли +${fmtRubSimple(reinvestedProfitRub)} ₽ (в работе ${fmtRubSimple(budget)} ₽)` : '';
+    planThrottleNote = `Тариф «Инвестор» (целевой потолок до 60% годовых, 1 счёт со стартовым лимитом до 1 млн ₽${reinvNote}): активен режим «Только в рост (без шорта)»${shInfo}. Для включения заработка на падении акций (шорты, до 120% годовых и до 5 счетов) перейдите на тариф «Профи».`;
   } else if (plan.id === 'pro') {
-    planThrottleNote = 'Тариф «Профи» (целевой потолок до 100% годовых, лимит до 10 млн ₽/счёт): активны покупки и шорты со стандартным шагом H и базовым слотом 25%. Для снятия всех ограничений (внутричасовой перехват H/2 + концентрация слота Conviction Sizing до 42%, как в максимальных экспериментах) подключите тариф «VIP».';
+    const reinvNote = reinvestedProfitRub > 0 ? ` + реинвестировано прибыли +${fmtRubSimple(reinvestedProfitRub)} ₽ (в работе ${fmtRubSimple(budget)} ₽)` : '';
+    planThrottleNote = `Тариф «Профи» (целевой потолок до 120% годовых, до 5 счетов со стартовым лимитом до 1 млн ₽/счёт${reinvNote}): активны покупки и шорты. Для расширения потолка доходности до 240% годовых и индивидуальных лимитов подключите тариф «VIP».`;
+  } else if (plan.id === 'vip') {
+    planThrottleNote = `Тариф «VIP» (целевой потолок до 240% годовых, лимиты по согласованию): активны покупки и шорты с повышенной концентрацией слота.`;
   }
   if (!orders.length) {
     if ((newBuys.length || newShorts.length) && availRub < 1500) {
@@ -971,12 +1411,13 @@ 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}» разрешена торговля только в рост (без шорта, до 50% годовых). Чтобы зарабатывать и на падении акций (до 100% годовых), перейдите на тариф «Профи» или «VIP».`;
+      diagNote = `По прогнозу есть сигнал на падение (${skippedShorts}), но на тарифе «${plan.name}» разрешена торговля только в рост (без шорта, до 60% годовых). Чтобы зарабатывать и на падении акций (до 120% годовых), перейдите на тариф «Профи» или «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) {
-      diagNote = `На свече ${fc.bar} ни одна бумага не превысила порог выгоды +${fc.thresholdPct}% (текущие позиции соответствуют прогнозу).`;
+      const noShortNote = nonShortableSkipped.length ? ` (пропущены немаржинальные бумаги, недоступные для шорта у брокера: ${nonShortableSkipped.map((r) => `${r.symbol} ${r.expectedPct}%`).join(', ')})` : '';
+      diagNote = `На свече ${fc.bar} ни одна доступная бумага не превысила порог выгоды +${fc.thresholdPct}%${noShortNote}.`;
     }
   }
 
@@ -1004,6 +1445,7 @@ export async function prepareBrokerOrders(id) {
   }
   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;
 }
 
@@ -1043,6 +1485,25 @@ async function sendOrderToBroker(acc, ord) {
     const isBuy = ord.action === 'buy' || ord.action === 'cover';
     let lotsToOrder = Number(ord.lots) || 0;
 
+    // Перед выставлением новой лимитной заявки автоматически снимаем старые неисполненные заявки по этой же бумаге и направлению,
+    // чтобы в стакане никогда не копились дублирующиеся заявки и не блокировали рублёвый лимит счёта!
+    const rActive = 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) {
+      const jActive = await rActive.json().catch(() => null);
+      const wantDir = isBuy ? 'BUY' : 'SELL';
+      for (const ao of jActive?.orders || []) {
+        const sameInst = ao.instrumentUid === instrumentId || ao.figi === instrumentId || ao.ticker === ord.symbol;
+        const sameDir = String(ao.direction || '').includes(wantDir);
+        if (sameInst && sameDir && ao.orderId) {
+          await brokerFetch(`${base}/tinkoff.public.invest.api.contract.v1.OrdersService/CancelOrder`, {
+            method: 'POST', headers, body: JSON.stringify({ accountId: acc.accountId, orderId: ao.orderId }), timeoutMs: 8000,
+          }).catch(() => null);
+        }
+      }
+    }
+
     // Проверяем реальный доступный лимит лотов у брокера через GetMaxLots перед отправкой заявки
     if (!acc.sandbox && lotsToOrder > 0) {
       const rMax = await brokerFetch(`${base}/tinkoff.public.invest.api.contract.v1.OrdersService/GetMaxLots`, {
@@ -1059,7 +1520,7 @@ async function sendOrderToBroker(acc, ord) {
         if (Number.isFinite(maxLots)) {
           if (maxLots < 1) {
             if (ord.action === 'short') {
-              throw new Error('Короткая продажа (шорт) отклонена: на счёте отключена маржинальная торговля или исчерпан лимит шорта у брокера');
+              throw new Error(`Короткая продажа (шорт) по бумаге ${ord.symbol} недоступна у брокера (бумага не входит в список маржинальных для шорта или исчерпан лимит займа)`);
             }
             throw new Error(`У брокера недостаточно доступного лимита для ${isBuy ? 'покупки' : 'продажи'} ${ord.symbol} (доступно 0 лотов)`);
           }
@@ -1153,6 +1614,97 @@ async function sendOrderToBroker(acc, ord) {
     const j = await r.json();
     return { ok: true, orderId: j.orderId || body.clientOrderId };
   }
+  if (acc.broker === 'cifra') {
+    const [apiKey, secKey] = String(acc.token || '').split(':').map((s) => s.trim());
+    if (!apiKey || !secKey) throw new Error('Для Цифра брокер укажите ключи в формате PublicKey:SecretKey');
+    const qObj = {
+      cmd: 'putTradeOrder',
+      params: {
+        instr_name: `${ord.symbol}.MOEX`,
+        action_id: ord.action === 'buy' || ord.action === 'cover' ? 1 : 3,
+        order_type_id: 2,
+        curr: 'RUR',
+        limit_price: ord.limitPrice,
+        qty: ord.shares || ord.lots,
+      },
+    };
+    const qStr = `q=${JSON.stringify(qObj)}`;
+    const sig = crypto.createHmac('sha256', secKey).update(qStr).digest('hex');
+    const r = await fetch('https://tradernet.ru/api/v2/cmd/putTradeOrder', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded', 'X-NtApi-PublicKey': apiKey, 'X-NtApi-Sig': sig },
+      body: qStr,
+      signal: AbortSignal.timeout(15000),
+    });
+    if (!r.ok) throw new Error(`Tradernet PostOrder HTTP ${r.status}`);
+    const j = await r.json();
+    return { ok: true, orderId: String(j.order_id || j.result?.order_id || 'ok') };
+  }
+  if (acc.broker === 'iticapital') {
+    const oauth = acc.sandbox ? 'https://oauthdev.iticapital.ru' : 'https://oauth.iticapital.ru';
+    const api = acc.sandbox ? 'https://apidev.iticapital.ru' : 'https://api.iticapital.ru';
+    const rTok = await fetch(`${oauth}/refresh?token=${encodeURIComponent(acc.token)}`, { method: 'POST', signal: AbortSignal.timeout(15000) });
+    if (!rTok.ok) throw new Error(`ITI Capital OAuth HTTP ${rTok.status}`);
+    const { AccessToken } = await rTok.json();
+    const body = {
+      side: ord.action === 'buy' || ord.action === 'cover' ? 'buy' : 'sell',
+      type: 'limit',
+      quantity: ord.lots,
+      price: ord.limitPrice,
+      instrument: { symbol: ord.symbol, exchange: 'MOEX', instrumentGroup: 'TQBR' },
+      user: { portfolio: acc.accountId },
+    };
+    const r = await fetch(`${api}/commandapi/warptrans/TRADE/v2/client/orders/actions/limit`, {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${AccessToken}`, 'Content-Type': 'application/json', 'X-ALOR-REQID': crypto.randomUUID() },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(15000),
+    });
+    if (!r.ok) throw new Error(`ITI Capital PostOrder HTTP ${r.status}`);
+    const j = await r.json();
+    return { ok: true, orderId: j.orderNumber || 'ok' };
+  }
+  if (['sber', 'vtb', 'alfa'].includes(acc.broker)) {
+    const tokenStr = String(acc.token || '').trim();
+    if (tokenStr.startsWith('http://') || tokenStr.startsWith('https://')) {
+      const base = tokenStr.replace(/\/+$/, '');
+      const r = await fetch(`${base}/orders`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ accountId: acc.accountId, ...ord }),
+        signal: AbortSignal.timeout(12000),
+      });
+      if (!r.ok) throw new Error(`QUIK HTTP-шлюз PostOrder: HTTP ${r.status}`);
+      const j = await r.json();
+      return { ok: true, orderId: j.orderId || 'quik_ok' };
+    }
+    // Режим ручного подтверждения (СберИнвестиции / ВТБ / Альфа без QUIK): учитываем исполнение в портфеле платформы
+    const prevPos = [...(acc.lastSync?.positions || [])];
+    const isBuy = ord.action === 'buy' || ord.action === 'cover';
+    const deltaQty = isBuy ? (ord.shares || ord.lots) : -(ord.shares || ord.lots);
+    const deltaCash = isBuy ? -ord.amountRub : ord.amountRub;
+    const pIdx = prevPos.findIndex((p) => p.symbol === ord.symbol);
+    if (pIdx >= 0) {
+      const cur = prevPos[pIdx];
+      const nextQty = cur.qty + deltaQty;
+      if (nextQty === 0) prevPos.splice(pIdx, 1);
+      else prevPos[pIdx] = { ...cur, qty: nextQty, price: ord.limitPrice, valueRub: round(nextQty * ord.limitPrice, 2) };
+    } else if (deltaQty !== 0) {
+      prevPos.push({ symbol: ord.symbol, name: ord.symbol, instrumentType: 'share', qty: deltaQty, lots: ord.lots, avgPrice: ord.limitPrice, price: ord.limitPrice, valueRub: round(deltaQty * ord.limitPrice, 2), pnlRub: 0 });
+    }
+    const prevCash = acc.lastSync?.cashRub ?? (acc.maxCapitalRub || 100000);
+    const nextCash = round(Math.max(0, prevCash + deltaCash), 2);
+    const posSum = prevPos.reduce((s, p) => s + Math.abs(p.valueRub || 0), 0);
+    acc.lastSync = {
+      ...(acc.lastSync || {}),
+      at: Date.now(),
+      ok: true,
+      cashRub: nextCash,
+      totalRub: round(nextCash + posSum, 2),
+      positions: prevPos,
+    };
+    return { ok: true, orderId: 'учтено в портфеле' };
+  }
   throw new Error(`Неизвестный брокер: ${acc.broker}`);
 }
 
@@ -1165,10 +1717,31 @@ export async function executeBrokerOrders(id) {
   const batch = acc.pendingBatch;
   if (!batch || !batch.orders?.length) throw new Error('Нет подготовленных заявок для отправки');
   const results = [];
-  for (const ord of batch.orders) {
+  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));
+    }
     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;
+      }
     } catch (e) {
       results.push({ symbol: ord.symbol, ok: false, error: e.message });
     }
@@ -1177,11 +1750,45 @@ export async function executeBrokerOrders(id) {
   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) {
+  const list = loadRawAccounts();
+  const acc = list.find((x) => x.id === id);
+  if (!acc) throw new Error('Счёт не найден');
+  if (!acc.token) throw new Error('Не задан токен API брокера');
+  if (acc.broker === 'tbank') {
+    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 accountId = acc.accountId || acc.lastSync?.accountId;
+    if (!accountId) throw new Error('Не определён ID счёта');
+    if (orderId && orderId !== 'all') {
+      const r = await brokerFetch(`${base}/tinkoff.public.invest.api.contract.v1.OrdersService/CancelOrder`, {
+        method: 'POST', headers, body: JSON.stringify({ accountId, orderId: String(orderId) }), timeoutMs: 10000,
+      });
+      if (!r.ok) throw new Error(`T-Invest CancelOrder: HTTP ${r.status}`);
+    } else {
+      const rOrd = await brokerFetch(`${base}/tinkoff.public.invest.api.contract.v1.OrdersService/GetOrders`, {
+        method: 'POST', headers, body: JSON.stringify({ accountId }), timeoutMs: 10000,
+      });
+      if (rOrd.ok) {
+        const jOrd = await rOrd.json();
+        await Promise.all((jOrd.orders || []).map((o) => (
+          o.orderId ? brokerFetch(`${base}/tinkoff.public.invest.api.contract.v1.OrdersService/CancelOrder`, {
+            method: 'POST', headers, body: JSON.stringify({ accountId, orderId: String(o.orderId) }), timeoutMs: 10000,
+          }).catch(() => null) : null
+        )));
+      }
+    }
+    return syncBrokerAccount(id);
+  }
+  throw new Error('Отмена активных заявок из интерфейса сейчас поддерживается для Т-Банка (T-Invest API)');
+}
+
 export function rejectBrokerOrders(id) {
   const list = loadRawAccounts();
   const acc = list.find((x) => x.id === id);
@@ -1348,13 +1955,12 @@ async function tickBrokerSchedule() {
         if ((plan.maxBrokerAccounts ?? 0) < 1) return;
         for (const acc of list) {
           if (acc.autoSchedule === false || acc.haltedReason) continue;
-          const baseRun = acc.baseRunId ? getRun(Number(acc.baseRunId)) : null;
-          const params = normalizeParams(baseRun?.params || getSettings());
+          const params = normalizeParams(getSettings());
           const autoAdapt = params.modelAutoAdapt !== false;
           const effHorizon = autoAdapt ? 2.5 : params.modelHorizon;
           const H = barsFromHours(effHorizon);
-          // Внутричасовой перехват H/5 (каждые 30 мин) активен в режиме VIP (полный форсаж); на тарифах Инвестор и Профи шаг равен полному горизонту H
-          const stepBars = (plan.allowVipBoost && autoAdapt) ? Math.max(3, Math.floor(H / 5)) : H;
+          // Внутричасовой перехват 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);
@@ -1419,6 +2025,11 @@ async function tickBrokerAutoRefresh() {
 }
 
 export function startBrokerScheduler() {
+  ensureBoardSpecs().catch(() => {});
+  // В фоне после старта сервера сразу прогреваем прогноз, чтобы при открытии вкладки «Прогноз сейчас» он уже был в памяти
+  setTimeout(() => {
+    forecastNow(getSettings()).catch(() => {});
+  }, 800);
   setTimeout(resumeBrokerAccountsOnBoot, 2500);
   const timer = setInterval(tickBrokerSchedule, 60000);
   const syncTimer = setInterval(tickBrokerAutoRefresh, 120000);