micro-models-agent 2.11.0 → 2.12.0

package/dist/llm/provider-context.js

@@ -0,0 +1,233 @@
+import { lookupModelsDevContext } from "./models-dev";
+/**
+ * Спрашивает нативный API бэкенда (LM Studio `/api/v1/models`) о длине
+ * контекста загруженной модели И заявленных capabilities. Длина — из живого
+ * инстанса (`loaded_instances[].config.context_length`), фолбэк —
+ * `max_context_length`. Capabilities читаются из `capabilities` (`vision`,
+ * `trained_for_tool_use`), если есть — это единый источник правды вместо
+ * гадания по имени.
+ *
+ * Null, если эндпоинт недоступен (не LM Studio), модели нет/снята или запрос
+ * упал — вызывающий деградирует молча.
+ */
+export async function probeModel(baseUrl, model, timeoutMs = 3000) {
+    const base = baseUrl.replace(/\/$/, "").replace(/\/v1\/?$/, "");
+    try {
+        const response = await fetch(`${base}/api/v1/models`, {
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (!response.ok)
+            return null;
+        const data = (await response.json());
+        const models = data.models ?? [];
+        const found = models.find((m) => m.key === model || m.name === model || (m.key ? model.includes(m.key) : false));
+        if (!found)
+            return null;
+        const loadedInstance = (found.loaded_instances ?? [])[0];
+        const contextLength = loadedInstance?.config?.context_length ?? found.max_context_length;
+        if (typeof contextLength !== "number" || contextLength <= 0)
+            return null;
+        const raw = found.capabilities;
+        let capabilities;
+        if (raw && typeof raw.vision === "boolean") {
+            capabilities = { vision: raw.vision };
+            if (typeof raw.trained_for_tool_use === "boolean") {
+                capabilities.tools = raw.trained_for_tool_use;
+            }
+        }
+        return { model: found.key ?? found.name ?? model, contextLength, capabilities };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Тонкая context-only проекция {@link probeModel}. Для вызывающих, кому нужно
+ * только окно контекста (баннер, диагностика context-probe).
+ */
+export async function getLoadedContextLength(baseUrl, model, timeoutMs = 3000) {
+    const probe = await probeModel(baseUrl, model, timeoutMs);
+    return probe ? { model: probe.model, actual: probe.contextLength } : null;
+}
+/** Числовые context-подобные поля, что может нести запись `/models`. */
+const CONTEXT_KEYS = [
+    "context_length",
+    "context_window",
+    "max_context_length",
+    "max_context_window",
+    "max_model_len",
+    "maxModelLen",
+    "n_ctx",
+    "num_ctx",
+    "contextLength",
+    "contextWindow",
+];
+function asPositiveInt(v) {
+    const n = typeof v === "string" && v.trim() !== "" ? Number(v) : v;
+    return typeof n === "number" && Number.isFinite(n) && n > 0 ? Math.floor(n) : null;
+}
+/**
+ * Первое положительное среди известных context-полей объекта. OpenRouter
+ * кладёт per-endpoint значение в `top_provider.context_length`, поэтому один
+ * уровень вложенности тоже покрыт.
+ */
+function pickContextField(obj) {
+    for (const k of CONTEXT_KEYS) {
+        const n = asPositiveInt(obj[k]);
+        if (n !== null)
+            return n;
+    }
+    const top = obj.top_provider ?? obj.topProvider;
+    if (top && typeof top === "object") {
+        for (const k of CONTEXT_KEYS) {
+            const n = asPositiveInt(top[k]);
+            if (n !== null)
+                return n;
+        }
+    }
+    return null;
+}
+function matchesModel(entry, model) {
+    for (const k of ["id", "name", "model", "key"]) {
+        const v = entry[k];
+        if (typeof v === "string" && v && (v === model || model.includes(v) || v.includes(model))) {
+            return true;
+        }
+    }
+    return false;
+}
+async function fetchJson(url, timeoutMs, init) {
+    try {
+        const response = await fetch(url, { ...init, signal: AbortSignal.timeout(timeoutMs) });
+        if (!response.ok)
+            return null;
+        return (await response.json());
+    }
+    catch {
+        return null;
+    }
+}
+/** Context-поля живого инстанса из Ollama `/api/ps`, если есть. */
+async function probeOllamaPs(origin, model, timeoutMs) {
+    const ps = await fetchJson(`${origin}/api/ps`, timeoutMs);
+    const running = ps?.models;
+    if (!Array.isArray(running))
+        return null;
+    const found = running.find((m) => m && typeof m === "object" && matchesModel(m, model));
+    if (!found)
+        return null;
+    return pickContextField(found);
+}
+function contextFromModelInfo(bag) {
+    for (const [k, v] of Object.entries(bag)) {
+        if (k.toLowerCase().includes("context_length") || k.toLowerCase().endsWith("n_ctx")) {
+            const n = asPositiveInt(v);
+            if (n !== null)
+                return n;
+        }
+    }
+    return pickContextField(bag);
+}
+/** Ollama `/api/show`: детали модели, пробуем полное и короткое имя. */
+async function probeOllamaShow(origin, model, timeoutMs) {
+    const short = model.split(":")[0];
+    for (const name of [model, short]) {
+        const show = await fetchJson(`${origin}/api/show`, timeoutMs, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ name }),
+        });
+        const info = show;
+        const bag = info?.model_info ?? info?.modelInfo;
+        if (bag && typeof bag === "object") {
+            const n = contextFromModelInfo(bag);
+            if (n !== null)
+                return n;
+        }
+    }
+    return null;
+}
+/** Нативный Ollama: живые инстансы (`/api/ps`) + детали (`/api/show`). */
+async function probeOllama(origin, model, timeoutMs) {
+    // `/api/show` сообщает контекст модели (напр. `llama.context_length` в
+    // `model_info`), даже когда `/api/ps` размерных полей не несёт.
+    return ((await probeOllamaPs(origin, model, timeoutMs)) ??
+        (await probeOllamaShow(origin, model, timeoutMs)));
+}
+/** Сервер llama.cpp: одномодельный `/props` несёт загруженный `n_ctx`. */
+async function probeLlamaCpp(origin, timeoutMs) {
+    const props = await fetchJson(`${origin}/props`, timeoutMs);
+    if (!props || typeof props !== "object")
+        return null;
+    const bag = props;
+    const direct = pickContextField(bag);
+    if (direct !== null)
+        return direct;
+    const gen = bag.default_generation_settings;
+    if (gen && typeof gen === "object") {
+        return pickContextField(gen);
+    }
+    return null;
+}
+/**
+ * OpenAI-совместимый `/models` с расширенными метаданными. Серверы с голыми id
+ * (чистый OpenAI, Zen/Go) context-полей не несут → null.
+ */
+async function probeOpenAICompatModels(baseUrl, model, apiKey, timeoutMs) {
+    const url = `${baseUrl.replace(/\/+$/, "")}/models`;
+    const headers = { "Content-Type": "application/json" };
+    if (apiKey && apiKey !== "not-needed")
+        headers.Authorization = `Bearer ${apiKey}`;
+    const data = await fetchJson(url, timeoutMs, { headers });
+    const list = data?.data;
+    if (!Array.isArray(list))
+        return null;
+    const found = list.find((m) => !!m && typeof m === "object" && matchesModel(m, model));
+    if (!found)
+        return null;
+    return pickContextField(found);
+}
+/**
+ * Лукап каталога models.dev — последний шанс для OpenCode Zen/Go. Их `/models`
+ * отдаёт голые id, а models.dev (открытая БД, что использует сам opencode)
+ * держит модели провайдера `opencode` под теми же id с `limit.context`.
+ * Гейт на Zen-URL/тип: локальные бэкенды ради этого в сеть не ходят.
+ */
+async function probeModelsDev(baseUrl, model, providerType) {
+    const isZen = providerType === "opencode-zen" ||
+        providerType === "opencode-go" ||
+        /opencode\.ai\/zen/.test(baseUrl);
+    if (!isZen)
+        return null;
+    return lookupModelsDevContext(model);
+}
+/**
+ * Пробует все источники по порядку, возвращает первый давший окно.
+ * @param baseUrl базовый URL провайдера; @param model имя модели;
+ * @param opts ключ/таймаут/тип; @returns окно контекста либо null (fail-open).
+ */
+export async function probeProviderContext(baseUrl, model, opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? 3000;
+    const origin = baseUrl.replace(/\/$/, "").replace(/\/v1\/?$/, "");
+    try {
+        const lm = await probeModel(baseUrl, model, timeoutMs);
+        if (lm)
+            return { model: lm.model, actual: lm.contextLength };
+        const ollama = await probeOllama(origin, model, timeoutMs);
+        if (ollama !== null)
+            return { model, actual: ollama };
+        const llama = await probeLlamaCpp(origin, timeoutMs);
+        if (llama !== null)
+            return { model, actual: llama };
+        const compat = await probeOpenAICompatModels(baseUrl, model, opts.apiKey, timeoutMs);
+        if (compat !== null)
+            return { model, actual: compat };
+        const catalog = await probeModelsDev(baseUrl, model, opts.providerType);
+        if (catalog !== null)
+            return { model, actual: catalog };
+    }
+    catch {
+        // Fail-open: любая ошибка пробы оставляет настроенный contextWindow.
+    }
+    return null;
+}

package/dist/llm/provider.js

@@ -1,4 +1,4 @@
-/** Helper: extract plain text from message content (for token counting, logging, etc.) */
+/** Хелпер: плоский текст из контента (подсчёт токенов, логи и т.п.). */
 export function getMessageText(content) {
     if (typeof content === "string")
         return content;

package/dist/llm/response.js

@@ -1,3 +1,8 @@
+/**
+ * Сворачивает чанки стрима в ответ (текст склеивается, reasoning копится,
+ * аргументы тулов JSON-парсятся с фолбэком {}).
+ * @param chunks чанки стрима; @returns распарсенный ответ.
+ */
 export function parseChunks(chunks) {
     let text = "";
     let reasoning;

package/dist/llm/token-counter.js

@@ -1,14 +1,13 @@
-// src/llm/token-counter.ts
+/** Подсчёт токенов: точный (tiktoken) и дешёвая эвристика для блоков. */
 import { encodingForModel, getEncoding } from "js-tiktoken";
 import { getMessageText } from "./provider";
 /**
- * Script-aware token ESTIMATE (cheap, no full tokenization). Cheap enough for
- * every hand-built PromptBlock; used at block-build time where the exact
- * TokenCounter may not be in scope. Measured on cl100k_base: Latin AND
- * Cyrillic both encode at ~3.3-5 chars/token (the old flat len/4 was actually
- * close for Cyrillic — the "cyr ≈ /2" assumption was wrong); CJK/Hangul are
- * the real outliers at ~1-1.5 tokens/char, so they get /1.5. Within ±30% of
- * tiktoken for Russian text.
+ * Скриптозависимая ОЦЕНКА токенов (дешёвая, без полной токенизации). Достаточно
+ * дешёвая для каждого PromptBlock; на этапе сборки точного TokenCounter может
+ * не быть в scope. Замерено на cl100k_base: латиница И кириллица — ~3.3–5
+ * символов/токен (старый плоский len/4 для кириллицы был почти верен —
+ * гипотеза «кириллица ≈ /2» ошибочна); CJK/хангыль — выбросы ~1–1.5 токена/
+ * символ, им /1.5. В пределах ±30% от tiktoken на русском.
  */
 export function estimateTokens(text) {
     if (!text)
@@ -29,6 +28,7 @@ export function estimateTokens(text) {
     }
     return Math.ceil(cjk / 1.5 + rest / 4);
 }
+/** Точный счётчик токенов поверх tiktoken (энкодинг по модели). */
 export class TokenCounter {
     encoder;
     constructor(model = "gpt-4o") {
@@ -36,31 +36,47 @@ export class TokenCounter {
             this.encoder = encodingForModel(model);
         }
         catch {
-            // Fallback to cl100k_base for unknown models
+            // Фолбэк на cl100k_base для неизвестных моделей
             this.encoder = getEncoding("cl100k_base");
         }
     }
+    /**
+     * Считает токены текста.
+     * @param text текст; @returns число токенов.
+     */
     count(text) {
         if (!text)
             return 0;
         return this.encoder.encode(text).length;
     }
+    /**
+     * Считает токены сообщений с оверхедом ролей/границ (~4/сообщение).
+     * @param messages сообщения чата; @returns суммарные токены.
+     */
     countMessages(messages) {
         let total = 0;
         for (const msg of messages) {
-            // ~4 tokens per message overhead (role, boundaries)
+            // ~4 токена оверхеда на сообщение (роль, границы)
             total += 4;
             const text = getMessageText(msg.content);
             total += this.count(text);
             if (msg.role === "tool")
                 total += 2; // tool_call_id
         }
-        total += 2; // assistant priming
+        total += 2; // прайминг ассистента
         return total;
     }
+    /**
+     * Кодирует текст в токены.
+     * @param text текст; @returns массив id токенов.
+     */
     encode(text) {
         return this.encoder.encode(text);
     }
+    /**
+     * Декодирует токены в текст.
+     * @param tokens id токенов; @returns текст.
+     */
     decode(tokens) {
         return this.encoder.decode(tokens);
     }

package/dist/logger/app-logger.js

@@ -1,9 +1,11 @@
+// Логер: шина вывода + файловые логи (.log, app.jsonl), чистка секретов.
 import { appendFileSync, mkdirSync, existsSync } from "fs";
 import { join } from "path";
 import { sanitizeLogMessage } from "../modules/security/data-sanitizer";
 import { FileLogWriter } from "./file-log";
 import { defaultOutputBus } from "../output";
 const LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
+/** Центральный логер: консоль через шину, файлы, JSONL, тегированные хелперы. */
 export class Logger {
     level;
     prefix;
@@ -36,36 +38,47 @@ export class Logger {
     clearSessionDir() {
         this.sessionDir = null;
     }
-    /** Open a per-session `.log` file (legacy v1 behavior). */
+    /** Открывает посессионный `.log`-файл (поведение legacy v1). */
     initSessionLog(sessionId) {
         this.fileLog.initSessionLog(sessionId);
     }
-    /** Fall back to daily log files when no session is active. */
+    /** Возврат к дневным лог-файлам, когда нет активной сессии. */
     closeSessionLog() {
         this.fileLog.closeSessionLog();
     }
+    /** Путь к текущему лог-файлу (сессионный или дневной). */
     getLogPath() {
         return this.fileLog.getLogPath();
     }
+    /** Удаляет старые логи по возрасту/количеству. */
     cleanupOldLogs(maxDays, maxFiles) {
         this.fileLog.cleanupOldLogs(maxDays, maxFiles);
     }
-    // --- Tagged helpers (legacy v1 API) ---
+    // Тегированные хелперы (API legacy v1).
+    /** Пишет запрос к LLM в файловый лог. */
     logLLMRequest(model, messagesCount, promptPreview, caller) {
         this.fileLog.logLLMRequest(model, messagesCount, sanitizeLogMessage(promptPreview), caller);
     }
+    /** Пишет ответ LLM (или ошибку) в файловый лог. */
     logLLMResponse(model, responseLength, genTimeMs, error, caller) {
         this.fileLog.logLLMResponse(model, responseLength, genTimeMs, error, caller);
     }
+    /** Пишет вызов тула и превью результата в файловый лог. */
     logToolCall(tool, preview, result) {
         this.fileLog.logToolCall(tool, sanitizeLogMessage(preview), result !== undefined ? sanitizeLogMessage(result) : undefined);
     }
+    /** Пишет вывод тула с кодом выхода в файловый лог. */
     logToolOutput(tool, output, exitCode) {
         this.fileLog.logToolOutput(tool, sanitizeLogMessage(output), exitCode);
     }
+    /** Пишет реплику REPL (user/assistant/system) в файловый лог. */
     logREPL(tag, content) {
         this.fileLog.logREPL(tag, sanitizeLogMessage(content));
     }
+    /**
+     * Дочерний логер с расширенным префиксом; наследует уровень, sink и каталоги.
+     * @param prefix суффикс префикса. @returns новый Logger.
+     */
     child(prefix) {
         const childLogger = new Logger(this.level, this.prefix ? `${this.prefix}:${prefix}` : prefix, this.sink);
         if (this.logDir)
@@ -86,42 +99,55 @@ export class Logger {
     error(msg, meta) {
         this.log("error", msg, meta);
     }
-    log(level, msg, meta) {
+    /**
+     * Внутренняя диагностика петли (ретраи галлюцинаций, аудит/компакция,
+     * вердикты критика, …). Персистентность та же, что у warn/info, но событие
+     * шины несёт `data.diagnostic = true`, и чат дропает его, пока
+     * `ui.verbosity !== "verbose"`.
+     */
+    diagnostic(level, msg, meta) {
+        this.log(level, msg, meta, true);
+    }
+    log(level, msg, meta, diagnostic) {
         if (LEVELS[level] < LEVELS[this.level])
             return;
-        // Sanitize log message to remove sensitive data
+        // Чистим сообщение — вырезаем секреты.
         const sanitizedMsg = sanitizeLogMessage(msg);
         const sanitizedMeta = meta ? this.sanitizeMeta(meta) : undefined;
         const ts = new Date().toISOString();
         const metaStr = sanitizedMeta ? ` ${JSON.stringify(sanitizedMeta)}` : "";
         const line = `${sanitizedMsg}${metaStr}`;
         try {
-            this.sink.emit({ level, source: this.prefix || "mma", kind: "log", text: line });
+            this.sink.emit({
+                level,
+                source: this.prefix || "mma",
+                kind: "log",
+                text: line,
+                data: diagnostic ? { diagnostic: true } : undefined,
+            });
         }
         catch {
             /* terminal output is best-effort; file logging below must still run */
         }
-        // Legacy v1 behavior: also append to the tagged `.log` file (session or daily).
+        // Поведение legacy v1: дубль в тегированный `.log` (сессионный или дневной).
         this.fileLog.log(level.toUpperCase(), this.prefix || "MMA", `${ts} — ${sanitizedMsg}${metaStr}`);
         const logTarget = this.sessionDir ?? this.logDir;
         if (logTarget) {
             try {
-                appendFileSync(join(logTarget, "app.jsonl"), JSON.stringify({
+                appendFileSync(join(logTarget, "app.jsonl"), `${JSON.stringify({
                     level,
                     ts,
                     prefix: this.prefix,
                     msg: sanitizedMsg,
                     meta: sanitizedMeta ?? null,
-                }) + "\n", "utf-8");
+                })}\n`, "utf-8");
             }
             catch {
                 /* file logging is best-effort */
             }
         }
     }
-    /**
-     * Sanitize metadata object to remove sensitive data
-     */
+    /** Рекурсивно чистит секреты в объекте метаданных. */
     sanitizeMeta(meta) {
         const sanitized = {};
         for (const [key, value] of Object.entries(meta)) {
@@ -138,30 +164,30 @@ export class Logger {
         return sanitized;
     }
     /**
-     * Write a structured record to app.jsonl only (no console / .log output).
-     * Used for machine-readable reports (environment, etc.) that would be too
-     * noisy on the terminal but are valuable for cross-device diagnosis.
+     * Структурная запись только в app.jsonl (без консоли и .log).
+     * Для машиночитаемых отчётов (окружение и т.п.), слишком шумных для терминала,
+     * но ценных для кросс-девайс диагностики.
      */
     logStructured(type, data) {
         const logTarget = this.sessionDir ?? this.logDir;
         if (!logTarget)
             return;
         try {
-            appendFileSync(join(logTarget, "app.jsonl"), JSON.stringify({
+            appendFileSync(join(logTarget, "app.jsonl"), `${JSON.stringify({
                 level: "info",
                 ts: new Date().toISOString(),
                 type,
                 meta: this.sanitizeMeta(data),
-            }) + "\n", "utf-8");
+            })}\n`, "utf-8");
         }
         catch {
             /* file logging is best-effort */
         }
     }
     /**
-     * Write a log entry to app.jsonl only — no console output, no .log file.
-     * Use this for noisy subsystems (LSP, probes) whose warnings should be
-     * diagnosable from session files but not pollute the user's terminal.
+     * Запись только в app.jsonl — без консоли и .log. Для шумных подсистем
+     * (LSP, пробники): предупреждения диагностируются по файлам сессии,
+     * но не мусорят в терминале.
      */
     logSilent(level, msg, meta) {
         const logTarget = this.sessionDir ?? this.logDir;
@@ -171,13 +197,13 @@ export class Logger {
         const sanitizedMsg = sanitizeLogMessage(msg);
         const sanitizedMeta = meta ? this.sanitizeMeta(meta) : undefined;
         try {
-            appendFileSync(join(logTarget, "app.jsonl"), JSON.stringify({
+            appendFileSync(join(logTarget, "app.jsonl"), `${JSON.stringify({
                 level,
                 ts,
                 prefix: this.prefix,
                 msg: sanitizedMsg,
                 meta: sanitizedMeta ?? null,
-            }) + "\n", "utf-8");
+            })}\n`, "utf-8");
         }
         catch {
             /* file logging is best-effort */

package/dist/logger/file-log.js

@@ -1,3 +1,4 @@
+// Файловый логер legacy v1: тегированные строки, ротация, чистка старых логов.
 import { appendFileSync, mkdirSync, existsSync, readdirSync, renameSync, statSync, unlinkSync, } from "node:fs";
 import { join } from "node:path";
 const MAX_LOG_SIZE = 5 * 1024 * 1024;
@@ -5,27 +6,28 @@ const MAX_LOG_FILES = 30;
 const DEFAULT_MAX_DAYS = 30;
 const TOOL_OUTPUT_LIMIT = 2000;
 /**
- * Tagged file logger (legacy MMA v1 behavior).
+ * Тегированный файловый логер (поведение legacy MMA v1).
  *
- * Writes human-readable log lines to `~/.mma/logs/`:
- * - `<sessionId>.log` while a session is active
- * - `YYYY-MM-DD.log` for everything outside a session
+ * Пишет читаемые строки в `~/.mma/logs/`:
+ * - `<sessionId>.log`, пока сессия активна;
+ * - `YYYY-MM-DD.log` для всего вне сессии.
  *
- * Features restored from v1:
- * - size-based rotation (5 MB → file.log.1, file.log.2, ...)
- * - cleanup of old logs (age + max file count)
- * - tagged helpers: LLM request/response, tool calls, REPL
+ * Фичи из v1:
+ * - ротация по размеру (5 МБ → file.log.1, file.log.2, …);
+ * - чистка старых логов (возраст + лимит файлов);
+ * - тегированные хелперы: запрос/ответ LLM, вызовы тулов, REPL.
  */
 export class FileLogWriter {
     logDir = null;
     sessionLogPath = null;
+    /** Задаёт каталог логов (создаёт при отсутствии). */
     setLogDir(dir) {
         this.logDir = dir;
         if (!existsSync(dir)) {
             mkdirSync(dir, { recursive: true });
         }
     }
-    /** Open a per-session log file. Triggers cleanup of old logs. */
+    /** Открывает посессионный лог-файл. Триггерит чистку старых логов. */
     initSessionLog(sessionId) {
         if (!this.logDir)
             return;
@@ -35,10 +37,11 @@ export class FileLogWriter {
         this.sessionLogPath = join(this.logDir, `${sessionId}.log`);
         this.cleanupOldLogs();
     }
-    /** Fall back to daily log files when no session is active. */
+    /** Возврат к дневным лог-файлам, когда нет активной сессии. */
     closeSessionLog() {
         this.sessionLogPath = null;
     }
+    /** Путь к текущему лог-файлу (сессионный или дневной). */
     getLogPath() {
         if (this.sessionLogPath)
             return this.sessionLogPath;
@@ -47,7 +50,7 @@ export class FileLogWriter {
         const date = new Date().toISOString().slice(0, 10);
         return join(this.logDir, `${date}.log`);
     }
-    /** Rotate the file if it exceeds the size limit. */
+    /** Ротирует файл при превышении лимита размера. */
     rotateIfNeeded(filePath) {
         if (!existsSync(filePath))
             return;
@@ -59,6 +62,7 @@ export class FileLogWriter {
             idx++;
         renameSync(filePath, `${filePath}.${idx}`);
     }
+    /** Пишет одну строку. Файловый лог — best-effort, ошибки глотаются. */
     log(level, tag, message) {
         const fp = this.getLogPath();
         if (!fp)
@@ -75,10 +79,12 @@ export class FileLogWriter {
             /* file logging is best-effort */
         }
     }
+    /** Пишет запрос к LLM (модель, число сообщений, превью промпта). */
     logLLMRequest(model, messagesCount, promptPreview, caller) {
         const tag = caller ? `LLM/${caller}` : "LLM";
         this.log("INFO", tag, `→ ${model} | ${messagesCount} messages | "${promptPreview.slice(0, 100)}"`);
     }
+    /** Пишет ответ LLM (длина, время) или ошибку. */
     logLLMResponse(model, responseLength, genTimeMs, error, caller) {
         const tag = caller ? `LLM/${caller}` : "LLM";
         if (error) {
@@ -88,16 +94,18 @@ export class FileLogWriter {
             this.log("INFO", tag, `← ${model} | ${responseLength} chars | ${genTimeMs}ms`);
         }
     }
+    /** Пишет вызов тула с обрезанными превью аргументов и результата. */
     logToolCall(tool, preview, result) {
-        const previewTrimmed = preview.length > 200 ? preview.slice(0, 200) + "..." : preview;
+        const previewTrimmed = preview.length > 200 ? `${preview.slice(0, 200)}...` : preview;
         if (result !== undefined) {
-            const resultTrimmed = result.length > 200 ? result.slice(0, 200) + "..." : result;
+            const resultTrimmed = result.length > 200 ? `${result.slice(0, 200)}...` : result;
             this.log("INFO", "TOOL", `${tool} | ${previewTrimmed} → ${resultTrimmed}`);
         }
         else {
             this.log("INFO", "TOOL", `${tool} | ${previewTrimmed}`);
         }
     }
+    /** Пишет вывод тула с кодом выхода (тело режется лимитом). */
     logToolOutput(tool, output, exitCode) {
         const trimmed = output.length > TOOL_OUTPUT_LIMIT
             ? output.slice(0, TOOL_OUTPUT_LIMIT) +
@@ -105,14 +113,15 @@ export class FileLogWriter {
             : output;
         this.log("DEBUG", "TOOL_OUTPUT", `${tool} exit:${exitCode}\n${trimmed}`);
     }
+    /** Пишет реплику REPL (тело режется до 400 символов). */
     logREPL(tag, content) {
-        const trimmed = content.length > 400 ? content.slice(0, 400) + "..." : content;
+        const trimmed = content.length > 400 ? `${content.slice(0, 400)}...` : content;
         this.log("INFO", `REPL/${tag}`, trimmed);
     }
     /**
-     * Clean up old log files.
-     * - Deletes files older than maxDays
-     * - Keeps at most maxFiles most recent .log files
+     * Чистит старые лог-файлы.
+     * - удаляет старше maxDays;
+     * - оставляет не более maxFiles самых свежих .log-файлов.
      */
     cleanupOldLogs(maxDays = DEFAULT_MAX_DAYS, maxFiles = MAX_LOG_FILES) {
         if (!this.logDir || !existsSync(this.logDir))
@@ -126,7 +135,7 @@ export class FileLogWriter {
             mtime: statSync(join(this.logDir, f)).mtimeMs,
         }))
             .sort((a, b) => b.mtime - a.mtime);
-        // 1. Delete by age.
+        // 1. Удаление по возрасту.
         for (const f of list()) {
             if (now - f.mtime > maxDays * 24 * 60 * 60 * 1000) {
                 try {
@@ -137,7 +146,7 @@ export class FileLogWriter {
                 }
             }
         }
-        // 2. Delete excess (fresh but more than maxFiles).
+        // 2. Удаление излишков (свежие, но сверх maxFiles).
         const remaining = list();
         for (let i = maxFiles; i < remaining.length; i++) {
             try {

package/dist/logger/index.js

@@ -1 +1,2 @@
+// Логер приложения: единая точка логирования (терминал, файлы, JSONL).
 export { Logger } from "./app-logger";