freegate 0.6.14 → 0.6.16

package/lib/economics.js

@@ -0,0 +1,43 @@
+// lib/economics.js — оценка экономии Freegate против платных API.
+// Freegate бесплатен (маршрутизация по free-моделям), но пользователь получил
+// бы объём работы. Оцениваем, сколько стоил бы этот же трафик у платных
+// провайдеров, показываем экономию в $. Цены — репрезентативные (USD / 1M
+// токенов), усреднённые по индустрии; расчёт консервативный (в пользу «дорого»,
+// чтобы не преувеличивать экономию).
+
+// Репрезентативные цены за 1M токенов (input / output), USD. Усреднено по
+// популярным моделям (GPT-4o, Claude, Gemini Pro): input ~$3-5, output ~$15.
+const PRICE_PER_M_INPUT = 3;
+const PRICE_PER_M_OUTPUT = 15;
+
+// Расчёт стоимости заданного объёма токенов.
+function costOfTokens(promptTokens = 0, completionTokens = 0) {
+  const inputCost = (promptTokens / 1000000) * PRICE_PER_M_INPUT;
+  const outputCost = (completionTokens / 1000000) * PRICE_PER_M_OUTPUT;
+  return { usd: inputCost + outputCost, inputUsd: inputCost, outputUsd: outputCost };
+}
+
+// Агрегация по всем провайдерам из tokenUsage. Возвращает итоговую экономию.
+function aggregateSavings(tokenUsage = {}) {
+  let prompt = 0, completion = 0;
+  for (const [_, tu] of Object.entries(tokenUsage)) {
+    prompt += tu.promptTokens || 0;
+    completion += tu.completionTokens || 0;
+  }
+  const total = prompt + completion;
+  const cost = costOfTokens(prompt, completion);
+  // Экономия = стоимость платного аналога (Freegate этого не стоит — 0).
+  return {
+    promptTokens: prompt,
+    completionTokens: completion,
+    totalTokens: total,
+    savedUsd: cost.usd,
+    savedInputUsd: cost.inputUsd,
+    savedOutputUsd: cost.outputUsd,
+    costPerMInput: PRICE_PER_M_INPUT,
+    costPerMOutput: PRICE_PER_M_OUTPUT,
+    basis: `input $${PRICE_PER_M_INPUT}/M, output $${PRICE_PER_M_OUTPUT}/M (репрезентативно)`,
+  };
+}
+
+module.exports = { PRICE_PER_M_INPUT, PRICE_PER_M_OUTPUT, costOfTokens, aggregateSavings };

package/lib/health.js

@@ -2,12 +2,14 @@
 const fs = require('fs');
 const path = require('path');
 const logger = require('./logger');
+const { ContextStats } = require('./contextstats');
 
-const STATE_PATH = path.join(__dirname, '..', 'state.json');
+const STATE_PATH = process.env.STATE_PATH || path.join(__dirname, '..', 'state.json');
 
 let health = {};
 let circuitBreakers = {};
-let stats = { totalRequests: 0, successfulRequests: 0, failedRequests: 0, providerUsage: {}, errors: {}, startTime: Date.now(), tokenUsage: {}, bandit: { low: {}, med: {}, high: {} } };
+let stats = { totalRequests: 0, successfulRequests: 0, failedRequests: 0, providerUsage: {}, errors: {}, errorsDay: '', startTime: Date.now(), tokenUsage: {}, bandit: { low: {}, med: {}, high: {} } };
+const contextStats = new ContextStats();
 let lastSelection = null;
 
 const MAX_RECENT = 50;
@@ -27,12 +29,21 @@ function loadState() {
       failedRequests: saved.failedRequests || 0,
       providerUsage: saved.providerUsage || {},
       errors: saved.errors || {},
+      errorsDay: saved.errorsDay || '',
       startTime: saved.startTime || Date.now(),
       tokenUsage: saved.tokenUsage || {},
       dailyUsage: saved.dailyUsage || {},
       reliability: saved.reliability || {},
       bandit: saved.bandit || { low: {}, med: {}, high: {} },
     };
+    contextStats.load(saved.context);
+    // Reset the error counter for a new day. state.json may have been written
+    // on a previous day (or lack errorsDay), so clear all-time errors now.
+    const today = new Date().toISOString().slice(0, 10);
+    if (stats.errorsDay !== today) {
+      stats.errorsDay = today;
+      stats.errors = {};
+    }
     logger.info('State loaded', { healthKeys: Object.keys(health) });
   } catch {
     logger.info('No state file, starting fresh');
@@ -52,7 +63,8 @@ function getLastSelection() { return lastSelection; }
 
 function saveState() {
   try {
-    fs.writeFileSync(STATE_PATH, JSON.stringify({ health, circuitBreakers, stats }, null, 2));
+    const context = contextStats.serialize();
+    fs.writeFileSync(STATE_PATH, JSON.stringify({ health, circuitBreakers, stats: { ...stats, context } }, null, 2));
   } catch (err) {
     logger.error('Failed to save state', { error: err.message });
   }
@@ -82,13 +94,13 @@ function recordSuccess(key) {
   health[key].score = Math.min(100, health[key].score + 10);
 }
 
-function recordFailure(key, statusCode) {
+function recordFailure(key, statusCode, opts) {
   if (!circuitBreakers[key]) circuitBreakers[key] = { failures: 0, lastFailure: 0, openUntil: null };
   const cb = circuitBreakers[key];
   cb.failures++;
   cb.lastFailure = Date.now();
   // Classify errors: hard errors open the breaker much longer than soft ones
-  const openMs = classifyErrorMs(statusCode);
+  const openMs = classifyErrorMs(statusCode, opts);
   if (cb.failures >= 3 || openMs > 60000) {
     cb.openUntil = Date.now() + Math.max(openMs, 60000);
     cb.failures = 0;
@@ -99,12 +111,19 @@ function recordFailure(key, statusCode) {
 
 // How long to hold the breaker open for a given HTTP status.
 // 401/403 = bad key (long), 429 = rate limit (medium), 5xx = overload (short, retry soon)
-function classifyErrorMs(statusCode) {
+function classifyErrorMs(statusCode, opts) {
   const s = statusCode || 0;
   if (s === 401 || s === 403) return 300000;      // 5 min — key is dead
   if (s === 429) return 120000;                    // 2 min — rate limited, wait for reset
   if (s >= 500) return 30000;                      // 30s — transient overload
-  if (s === 404) return 300000;                    // 5 min — model/endpoint gone
+  if (s === 404) {
+    // provider-side 404 (upstream temporarily failing) → short break so the
+    // periodic health-check gets a chance to re-enable; only a TRUE "model
+    // does not exist" 404 (handled in server.js as permanent disable) gets the
+    // long trip.
+    if (opts && opts.providerSide) return 70000;   // 70s — Nvidia/etc. quota/overload
+    return 300000;                                 // 5 min — model/endpoint gone
+  }
   return 60000;                                    // default
 }
 
@@ -112,6 +131,8 @@ function recordRequest(providerKey, success, error = null) {
   recordRpm();
   stats.totalRequests++;
   const today = new Date().toISOString().slice(0, 10);
+  // Error counter is all-time by default; reset it once per UTC day (like reliability).
+  if (stats.errorsDay !== today) { stats.errorsDay = today; stats.errors = {}; }
   if (success) {
     stats.successfulRequests++;
     stats.providerUsage[providerKey] = (stats.providerUsage[providerKey] || 0) + 1;
@@ -153,6 +174,7 @@ function recordTokens(providerKey, usage) {
 
 function getHealth() { return health; }
 function getStats() { return stats; }
+function getCircuitBreakers() { return circuitBreakers; }
 
 function recordRecent(entry) {
   recent.unshift({ timestamp: Date.now(), ...entry });
@@ -185,6 +207,30 @@ function recordBandit(bucketName, key, success) {
   else stats.bandit[bucketName][key].b += 1;
 }
 
+// Warm start for bandit priors: a brand-new (or auto-disabled-then-re-enabled)
+// provider enters with Beta(1,1) = uniform, which makes Thompson sampling pick it
+// with ~random weight at first and explore for a LONG time before trusting it —
+// even if its weight/score is good. This biases those providers toward a mild
+// optimistic prior (a=6,b=2 → mean 75%, ~8 trials of confidence) so they get
+// selected soon after going live, without ever dominating hardened favorites
+// (e.g. or-ox-alpha with dozens of real outcomes).
+function warmBanditPriors(enabledKeys, bucketKeys) {
+  if (!Array.isArray(enabledKeys) || bucketKeys.length === 0) return 0;
+  let warmed = 0;
+  for (const key of enabledKeys) {
+    for (const bucketName of bucketKeys) {
+      stats.bandit[bucketName] = stats.bandit[bucketName] || {};
+      const p = stats.bandit[bucketName][key];
+      // Only touch true cold-starts or tiny dead priors; NEVER reset proven ones.
+      if (!p || (p.a === 1 && p.b === 1) || (p.a + p.b <= 4)) {
+        stats.bandit[bucketName][key] = { a: 6, b: 2 };
+        warmed++;
+      }
+    }
+  }
+  return warmed;
+}
+
 // Auto-save every 30 seconds
 const _saveTimer = setInterval(saveState, 30000);
 
@@ -193,10 +239,11 @@ function _stopTimers() { clearInterval(_saveTimer); }
 module.exports = {
   loadState, saveState, initHealth, isCircuitOpen,
   recordSuccess, recordFailure, recordRequest, recordTokens,
-  getHealth, getStats,
+  getHealth, getStats, getCircuitBreakers,
   recordRecent, recordRpm, getRecent, getRpm,
   getDailyUsage, getReliability,
   recordSelection, getLastSelection,
-  getBandit, recordBandit,
+  getBandit, recordBandit, warmBanditPriors,
+  getContextStats: () => contextStats,
   _stopTimers,
 };

package/lib/logger.js

@@ -2,7 +2,7 @@
 const fs = require('fs');
 const path = require('path');
 
-const LOG_PATH = path.join(__dirname, '..', 'proxy.log');
+const LOG_PATH = process.env.LOG_PATH || path.join(__dirname, '..', 'proxy.log');
 const MAX_LOG_SIZE = 10 * 1024 * 1024; // 10MB
 const MAX_ROTATIONS = 3;
 

package/lib/memory-store.js

@@ -0,0 +1,68 @@
+// lib/memory-store.js
+// Персистентность долговременной памяти (memory.json) поверх MemStore из memory.js.
+// Zero deps, corrupt-safe (аналогично state.json/cache.json).
+
+const fs = require('fs');
+const path = require('path');
+const { MemStore } = require('./memory');
+
+const DEFAULT_PATH = path.join(__dirname, '..', 'memory.json');
+const TRANSACTION_SUFFIX = '.tmp';
+
+class MemoryStore extends MemStore {
+  constructor(opts = {}) {
+    const capacity = opts.capacity ?? 800;
+    super(capacity);
+    this.filePath = opts.filePath || DEFAULT_PATH;
+    this.saveTimeout = null;
+    this.load();
+  }
+
+  load() {
+    try {
+      const raw = fs.readFileSync(this.filePath, 'utf8');
+      const data = JSON.parse(raw);
+      if (data && Array.isArray(data.facts)) {
+        const entries = data.facts.map(f => ({ text: f.text, sourceHash: f.sourceHash, created: f.created, access: f.access }));
+        const added = this.import(entries);
+        if (added > 0 && entries.length !== added) {
+          // частичная дедупликация при загрузке — норм
+        }
+      }
+    } catch (err) {
+      // отсутствует или битый файл → пустой старт, не падаем
+    }
+  }
+
+  save() {
+    try {
+      const facts = this._facts.map(f => ({
+        text: f.text,
+        sourceHash: f.sourceHash || null,
+        created: f.created,
+        access: f.access,
+      }));
+      const payload = JSON.stringify({ version: 1, saved: Date.now(), facts }, null, 2);
+      const tmp = this.filePath + TRANSACTION_SUFFIX;
+      fs.writeFileSync(tmp, payload);
+      fs.renameSync(tmp, this.filePath); // atomic-ish write
+      return true;
+    } catch (err) {
+      try { fs.unlinkSync(this.filePath + TRANSACTION_SUFFIX); } catch {}
+      return false;
+    }
+  }
+
+  // Debounce: не писать на каждый add — асинхронный приверженный по таймеру.
+  scheduleSave(delayMs = 10000) {
+    if (this.saveTimeout) clearTimeout(this.saveTimeout);
+    this.saveTimeout = setTimeout(() => { this.saveTimeout = null; this.save(); }, delayMs);
+    if (this.saveTimeout.unref) this.saveTimeout.unref();
+  }
+
+  stopTimer() {
+    if (this.saveTimeout) { clearTimeout(this.saveTimeout); this.saveTimeout = null; }
+  }
+}
+
+module.exports = { create: (opts) => new MemoryStore(opts || {}), MemoryStore, DEFAULT_PATH };

package/lib/memory.js

@@ -0,0 +1,167 @@
+// lib/memory.js
+// Долговременная память Freegate: факты, извлечённые при компакции контекста,
+// с поиском по лёгкому вектору в стиле TF-IDF/Jaccard (без внешних зависимостей).
+// Токенизация учитывает русскую морфологию через суффикс-триграммы.
+
+const crypto = require('crypto');
+
+// Минимальный стоп-лист (рус + англ). Токены короче 3 символов и пунктуация
+// выпадают вместе с ними — это снимает большинство «служебного» шума.
+const STOP_WORDS = new Set([
+  'как', 'что', 'чем', 'кому', 'кем', 'где', 'куда', 'откуда', 'когда', 'почему',
+  'зачем', 'кто', 'наш', 'нам', 'нами', 'вам', 'все', 'всё', 'это', 'этот', 'эта',
+  'при', 'про', 'без', 'для', 'до', 'из', 'на', 'над', 'не', 'ни', 'но', 'и', 'или',
+  'о', 'об', 'от', 'по', 'под', 'с', 'со', 'у', 'в', 'во', 'же', 'бы', 'был', 'быть',
+  'есть', 'будет', 'будем', 'было', 'его', 'её', 'их', 'my', 'the', 'and', 'for',
+  'with', 'does', 'what', 'how', 'why', 'when', 'from', 'into', 'would',
+]);
+
+// Suffix-trigram-маркер: последние 3 символа слова, чтобы русские словоформы
+// («отчёт», «отчётами») пересекались. Префикс '_' исключает конфликт с токенами.
+function trigram(word) {
+  if (word.length < 4) return '';
+  return '_' + word.slice(-3);
+}
+
+// wordCounts: частоты токенов в тексте (схлопывает «keepAlive» → «keepalive»).
+function tokenize(text) {
+  const counts = {};
+  const add = (t) => { if (t && t.length >= 3 && !STOP_WORDS.has(t)) { counts[t] = (counts[t] || 0) + 1; } };
+  const words = String(text).toLowerCase().split(/[^\p{L}\p{N}_]+/u).filter(Boolean);
+  for (const w of words) {
+    add(w);
+    const tr = trigram(w);
+    if (tr) add(tr);
+  }
+  return Object.keys(counts);
+}
+
+// Хранилище фактов. capacity → вытеснение least-accessed.
+class MemStore {
+  constructor(capacity = 800) {
+    this.capacity = capacity;
+    this._facts = [];        // { id, text, tokens:Set<string>, access, created, sourceHash }
+    this._docFreq = {};      // token → сколько фактов его содержит
+    this._hashIndex = new Map(); // textHash → id
+  }
+
+  size() { return this._facts.length; }
+
+  _refreshDocFreq() {
+    this._docFreq = {};
+    for (const f of this._facts) {
+      for (const t of f.tokens) this._docFreq[t] = (this._docFreq[t] || 0) + 1;
+    }
+  }
+
+  // idf влазит в [0, ln(пул+1)] — редкие токены важнее частых.
+  _idf(token) {
+    const n = this._docFreq[token] || 0;
+    if (n === 0) return Math.log(this._facts.length + 1) || 1;
+    return Math.log((this._facts.length + 1) / n);
+  }
+
+  add(text, meta = {}) {
+    const normalized = String(text).trim().replace(/\s+/g, ' ');
+    if (!normalized) return null;
+    const hash = crypto.createHash('sha1').update(normalized).digest('hex').slice(0, 16);
+    if (this._hashIndex.has(hash)) return null; // дедупликация
+    const tokens = new Set(tokenize(normalized));
+    // Prefix-expand: «запросы» покрывает «запрос», «погодный» → «погод» и т.п.
+    // Даёт словоформам/словосочетаниям пересекаться без стеммера. Минимум 4
+    // символа, чтобы не плодить ложные «год» из «погода».
+    const expanded = new Set(tokens);
+    for (const t of tokens) {
+      if (t.startsWith('_') || t.length < 4) continue;
+      for (let L = 4; L < t.length; L++) expanded.add(t.slice(0, L));
+    }
+    if (expanded.size === 0) return null;
+    const fact = {
+      id: 'f' + Date.now().toString(36) + Math.random().toString(36).slice(2, 6),
+      text: normalized,
+      tokens: expanded,
+      access: 0,
+      created: Date.now(),
+      sourceHash: meta.sourceHash || null,
+    };
+    this._facts.push(fact);
+    this._hashIndex.set(hash, fact.id);
+    for (const t of expanded) this._docFreq[t] = (this._docFreq[t] || 0) + 1;
+    this._evictIfNeeded();
+    return fact;
+  }
+
+  _evictIfNeeded() {
+    if (this._facts.length <= this.capacity) return;
+    // least-accessed, при равенстве — старейший
+    this._facts.sort((a, b) => (a.access - b.access) || (a.created - b.created));
+    const victims = this._facts.slice(0, this._facts.length - this.capacity);
+    for (const v of victims) this._remove(v.id);
+  }
+
+  _remove(id) {
+    const idx = this._facts.findIndex(f => f.id === id);
+    if (idx === -1) return;
+    const [f] = this._facts.splice(idx, 1);
+    // убрать из hashIndex: нужен исходный hash — пересчитаем по тексту
+    const h = crypto.createHash('sha1').update(f.text).digest('hex').slice(0, 16);
+    if (this._hashIndex.get(h) === id) this._hashIndex.delete(h);
+    for (const t of f.tokens) this._docFreq[t] = Math.max(0, (this._docFreq[t] || 1) - 1);
+  }
+
+  // recall: скор = сумма idf по общим токенам (полные слова вес 1, триграммы 0.5),
+  // нормализованный по sqrt(len запроса) — масштаб одинаков внутри одного вызова
+  // (не зависит от длины факта). 0 общих токенов → 0, unrelated отсекается любым
+  // порогом > 0.
+  recall(query, opts = {}) {
+    const topK = opts.topK ?? 3;
+    const minSimilarity = opts.minSimilarity ?? 0.05;
+    const qTokens = tokenize(query);
+    if (qTokens.length === 0) return [];
+    const qSet = new Set(qTokens);
+    const norm = Math.sqrt(qTokens.length);
+    const scored = [];
+    for (const f of this._facts) {
+      let score = 0;
+      for (const t of qSet) {
+        if (f.tokens.has(t)) {
+          const w = t.startsWith('_') ? 0.5 : 1;
+          score += w * this._idf(t);
+        }
+      }
+      const final = score / norm;
+      if (final >= minSimilarity) scored.push({ text: f.text, score: final });
+    }
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, topK);
+  }
+
+  // Дедупликация при подмешивании: факт не нужен, если его текст почти весь
+  // покрыт другим текстом (например, резюме компактора в этой же сессии).
+  isCovered(text, others) {
+    const words = tokenize(text).filter(t => !t.startsWith('_'));
+    if (words.length === 0) return false;
+    for (const other of others) {
+      const foreign = tokenize(other);
+      const overlap = words.filter(w => foreign.includes(w)).length;
+      if (overlap / words.length >= 0.6) return true;
+    }
+    return false;
+  }
+
+  export() {
+    return this._facts.map(f => ({ text: f.text, sourceHash: f.sourceHash, created: f.created, access: f.access }));
+  }
+
+  import(entries) {
+    if (!Array.isArray(entries)) return 0;
+    let added = 0;
+    for (const e of entries) {
+      if (e && typeof e.text === 'string' && this.add(e.text, { sourceHash: e.sourceHash })) added++;
+    }
+    if (added > 0) this._refreshDocFreq();
+    return added;
+  }
+}
+
+module.exports = { tokenize, MemStore };

package/lib/methodology.js

@@ -0,0 +1,70 @@
+// Методолог — краткий системный промпт, дающий модели «инженерную дисциплину»
+// по мотивам superpowers (plan-before-code, tests-first, reasoning). Не является
+// копией — это сжатый производный текст, встроенный в запрос к провайдеру.
+// Механика субагентов/инструментов работает на стороне клиента (opencode, Cursor),
+// здесь — только стиль ответа.
+
+const METHODOLOGIES = {
+  coding: [
+    'Методолог (craft): перед тем как давать код — составь план в 1-2 строки.',
+    'Сначала набросай approach, потом пиши реализации. Не выдумывай API.',
+    'Предложи (или опиши) короткий тест, который проверит поведение.',
+    'Если правишь код — укажи файл и строку; если есть сомнение — спроси.',
+    'После решения дай в одну строку, как это проверить.',
+  ].join('\n'),
+  reasoning: [
+    'Методолог (thinking): рассуждай пошагово, прежде чем дать вывод.',
+    'Покажи ключевые предположения, чтобы ответ можно было проверить.',
+    'Сначала краткий ход мысли, затем краткий ответ.',
+  ].join('\n'),
+  search: [
+    'Методолог (search): дай короткий фактологичный ответ по существу.',
+    'Если отвечаешь по внешнему источнику — не выдумывай, укажи источник или скажи, что не уверен.',
+    'Без воды и лишних вступлений.',
+  ].join('\n'),
+  chat: [
+    'Методолог (chat): отвечай по существу и кратко, по-русски.',
+    'Если просят код или план — переключись на соответствующий стиль.',
+  ].join('\n'),
+};
+
+function getMethodology(category, options) {
+  const opts = options || {};
+  const prompts = (opts.prompts && typeof opts.prompts === 'object') ? opts.prompts : {};
+  if (prompts[category] && typeof prompts[category] === 'string' && prompts[category].trim().length > 0) {
+    return prompts[category];
+  }
+  return METHODOLOGIES[category] || METHODOLOGIES.chat;
+}
+
+function enabledByDefault() {
+  return true;
+}
+
+// Вставляет системное сообщение-методолог после системного промпта клиента и
+// после memory-инъекции, но перед первым активным user-сообщением.
+function injectMethodology(messages, category, options) {
+  const opts = options || {};
+  if (opts.enabled === false) return messages;
+  const text = getMethodology(category, opts);
+  if (!messages || !Array.isArray(messages)) return messages;
+
+  // Конец вводных: после последнего system и после исчерпания «заголовочных»
+  // user-вставок вида [Память: ...] / [Факты: ...].
+  let insertAt = 0;
+  for (let i = 0; i < messages.length; i++) {
+    const m = messages[i];
+    if (!m) continue;
+    if (m.role === 'system') { insertAt = i + 1; continue; }
+    if (m.role === 'user' && typeof m.content === 'string' && /^\[(Память|Факты|Memory|Facts)[:\]]/.test(m.content)) {
+      insertAt = i + 1; continue;
+    }
+    break;
+  }
+
+  const copy = messages.slice();
+  copy.splice(insertAt, 0, { role: 'system', content: text });
+  return copy;
+}
+
+module.exports = { getMethodology, injectMethodology, enabledByDefault, METHODOLOGIES };

package/lib/modeldb.js

@@ -0,0 +1,125 @@
+// lib/modeldb.js — структурированная база моделей Freegate.
+// Паспорт каждой модели: источник, категория, контекст-окно, латентность,
+// success-rate, скор, статус, история проверок. Хранение: models-db.json
+// (атомарная запись через tmp+rename). Zero-dependency.
+//
+// Статусы: untested → active | dead (404/402) | disabled (авто-отключён,
+// перепроверяется) | user-disabled (решение пользователя, не трогаем).
+
+const fs = require('fs');
+
+const CHECK_HISTORY_MAX = 20;
+const SCORE_WEIGHTS = { success: 0.4, latency: 0.3, context: 0.2, freshness: 0.1 };
+const LATENCY_PENALTY_MS = 5000;   // латентность ≥5s → latencyScore 0
+const FRESH_DECAY_DAYS = 14;       // после 14 дней без успеха freshness 0
+const CONTEXT_REF_MS = 1000000;    // 1M окна достаточно для contextScore 1
+
+function clamp01(v) {
+  const n = Number(v) || 0;
+  return Math.max(0, Math.min(1, n));
+}
+
+// Технический скор 0..100: success-rate + латентность + окно + свежесть.
+function computeScore({ successRate = 0.5, latencyEma = 0, contextWindow = 0, lastOkAt = 0, now = Date.now() } = {}) {
+  const sSuccess = clamp01(successRate);
+  const sLatency = 1 - clamp01((Number(latencyEma) || 0) / LATENCY_PENALTY_MS);
+  const sContext = clamp01((Number(contextWindow) || 0) / CONTEXT_REF_MS);
+  const days = (Number(lastOkAt) > 0) ? Math.max(0, (now - lastOkAt) / 86400000) : FRESH_DECAY_DAYS + 1;
+  const sFresh = days <= 1 ? 1 : Math.max(0, 1 - days / FRESH_DECAY_DAYS);
+  const raw = sSuccess * SCORE_WEIGHTS.success +
+    sLatency * SCORE_WEIGHTS.latency +
+    sContext * SCORE_WEIGHTS.context +
+    sFresh * SCORE_WEIGHTS.freshness;
+  return Math.round(clamp01(raw) * 100);
+}
+
+class ModelDB {
+  constructor(filePath) {
+    this.filePath = filePath;
+    this.models = new Map(); // key -> entry
+  }
+
+  load() {
+    this.models = new Map();
+    try {
+      if (!fs.existsSync(this.filePath)) return this;
+      const raw = JSON.parse(fs.readFileSync(this.filePath, 'utf8'));
+      for (const [key, m] of Object.entries(raw.models || {})) {
+        if (m && typeof m === 'object' && m.model && m.endpoint) this.models.set(key, m);
+      }
+    } catch {
+      // повреждённый файл → пустая база, перезапишется при первом save
+    }
+    return this;
+  }
+
+  save() {
+    const out = { version: 1, updatedAt: Date.now(), models: Object.fromEntries(this.models) };
+    const tmp = this.filePath + '.tmp';
+    fs.writeFileSync(tmp, JSON.stringify(out, null, 2) + '\n');
+    fs.renameSync(tmp, this.filePath); // атомарно: читатели не видят полузапись
+    return this;
+  }
+
+  get(key) { return this.models.get(key) || null; }
+
+  all() { return [...this.models.values()]; }
+
+  // Слияние: новые поля поверх старых, существующие (status/history) сохраняются.
+  upsert(entry) {
+    if (!entry || !entry.key || !entry.model || !entry.endpoint) return null;
+    const prev = this.models.get(entry.key) || {};
+    const merged = {
+      status: 'untested',
+      category: 'general',
+      source: 'unknown',
+      contextWindow: 0,
+      dailyLimit: 0,
+      checkHistory: [],
+      score: 0,
+      addedAt: Date.now(),
+      ...prev,
+      ...entry,
+    };
+    this.models.set(entry.key, merged);
+    return merged;
+  }
+
+  // Результат проверки модели. dead только для 404/402 (перманентно для аккаунта).
+  // 429 и прочее — транзитное, статус не меняет. user-disabled не трогаем никогда.
+  markChecked(key, result, opts = {}) {
+    const m = this.models.get(key);
+    if (!m) return null;
+    const now = opts.now || Date.now();
+    const ok = !!(result && result.ok);
+    m.lastCheckedAt = now;
+    if (m.status !== 'user-disabled') {
+      if (ok) { m.status = 'active'; m.lastOkAt = now; }
+      else if (result.status === 404 || result.status === 402) m.status = 'dead';
+    } else if (ok) {
+      m.lastOkAt = now;
+    }
+    const history = Array.isArray(m.checkHistory) ? m.checkHistory : [];
+    history.push({ ts: now, ok, status: (result && result.status) || 0, latencyMs: (result && result.latencyMs) || 0 });
+    m.checkHistory = history.slice(-CHECK_HISTORY_MAX);
+    return m;
+  }
+
+  setStatus(key, status) {
+    const m = this.models.get(key);
+    if (m && status) m.status = status;
+    return m;
+  }
+
+  stats() {
+    const byCategory = {}, byStatus = {}, bySource = {};
+    for (const m of this.models.values()) {
+      byCategory[m.category] = (byCategory[m.category] || 0) + 1;
+      byStatus[m.status] = (byStatus[m.status] || 0) + 1;
+      bySource[m.source] = (bySource[m.source] || 0) + 1;
+    }
+    return { total: this.models.size, byCategory, byStatus, bySource };
+  }
+}
+
+module.exports = { ModelDB, computeScore, SCORE_WEIGHTS };