micro-models-agent 2.11.0 → 2.13.1

package/dist/llm/orchestrator.js

@@ -85,8 +85,9 @@ Respond with JSON only (no markdown fences):
 or
 {"action": "reject", "explanation": "why"}`;
 const DEFAULT_BASE_URL = "http://localhost:1234/v1";
-/** Fallback context window when neither the provider entry nor the config sets one. */
+/** Запасное окно контекста, если ни запись провайдера, ни конфиг его не задают. */
 const DEFAULT_ORCH_CONTEXT_WINDOW = 32768;
+/** Клиент оркестратора: строит план, сливает результаты, роутит scope-запросы. */
 export class OrchestratorClient {
     config;
     provider = null;
@@ -110,11 +111,10 @@ export class OrchestratorClient {
         }
     }
     /**
-     * Build the orchestrator provider through ProviderManager so per-entry
-     * contextWindow/retry/rateLimits and failover entries are honored
-     * (legacy {type,baseUrl,apiKey} configs are normalized by the manager).
-     * Previously the provider was built directly with a hardcoded 32768 window
-     * and no retry/rate-limit/failover support at all.
+     * Строит провайдер оркестратора через ProviderManager: учитываются
+     * per-entry contextWindow/retry/rateLimits и failover-записи (легаси
+     * {type,baseUrl,apiKey} менеджер нормализует). Раньше провайдер строился
+     * напрямую с хардкодом окна 32768 — без ретраев/лимитов/failover вовсе.
      */
     buildManagedProvider(config) {
         const providerCfg = config.provider;
@@ -134,6 +134,10 @@ export class OrchestratorClient {
         }
         return provider;
     }
+    /**
+     * Включён ли оркестратор (задана ли модель).
+     * @returns true, если провайдер построен.
+     */
     isEnabled() {
         return this.provider !== null;
     }
@@ -171,6 +175,11 @@ export class OrchestratorClient {
             }
         }
     }
+    /**
+     * Строит MoE-план из задачи пользователя.
+     * @param userPrompt задача; @param _context неиспользуемый контекст;
+     * @returns план с сырым ответом либо ошибку.
+     */
     async plan(userPrompt, _context, signal) {
         if (!this.provider)
             return { error: "Orchestrator not enabled — no orchestrator model configured" };
@@ -180,11 +189,16 @@ export class OrchestratorClient {
         ];
         const text = await this.chat(messages, signal);
         const parsed = this.parseJSON(text);
-        if (parsed && parsed.subtasks && parsed.subtasks.length > 0) {
+        if (parsed?.subtasks && parsed.subtasks.length > 0) {
             return { plan: parsed, raw: text };
         }
         return { error: `Failed to parse plan from LLM output. Raw: ${text.slice(0, 500)}` };
     }
+    /**
+     * Сливает результаты сабтасков: финал либо запрос re-plan.
+     * @param input план, результаты, ошибки/варнинги верификатора;
+     * @returns финал с ответом либо replan с обновлённым планом.
+     */
     async verifyAndMerge(input, signal) {
         if (!this.provider)
             return { type: "final", finalAnswer: input.results.map((r) => r.summary).join("\n") };
@@ -195,7 +209,7 @@ export class OrchestratorClient {
         ];
         const text = await this.chat(messages, signal);
         const parsed = this.parseJSON(text);
-        if (parsed && parsed.type) {
+        if (parsed?.type) {
             return parsed;
         }
         return {
@@ -205,8 +219,8 @@ export class OrchestratorClient {
         };
     }
     /**
-     * Router decision on a sub-agent's scope request. Defaults to reject on any
-     * parse failure — scope must never expand silently.
+     * Решение роутера по scope-запросу субагента. Дефолт на любой ошибке
+     * парсинга — reject: scope молча не расширяется никогда.
      */
     async resolveScopeRequest(subtaskId, request, signal) {
         if (!this.provider)
@@ -223,7 +237,7 @@ export class OrchestratorClient {
         if (parsed && parsed.action === "approve") {
             const write = Array.isArray(parsed.write) ? parsed.write.map(String) : [];
             const read = Array.isArray(parsed.read) ? parsed.read.map(String) : [];
-            // An approve without any concrete files is meaningless — treat as reject.
+            // Approve без конкретных файлов бессмыслен — считаем reject.
             if (write.length === 0 && read.length === 0) {
                 return { action: "reject", explanation: "approve carried no files" };
             }
@@ -236,6 +250,10 @@ export class OrchestratorClient {
                 : `unparseable router decision: ${text.slice(0, 200)}`,
         };
     }
+    /**
+     * Строит простой план-список шагов (легаси-поверхность).
+     * @param task задача; @returns шаги плана (фолбэк — сама задача).
+     */
     async createPlan(task) {
         if (!this.provider)
             throw new Error("Orchestrator not enabled");
@@ -252,6 +270,10 @@ export class OrchestratorClient {
             return parsed;
         return { steps: [task] };
     }
+    /**
+     * Рекомендует путь разрешения конфликта.
+     * @param context описание ситуации; @returns рекомендация текстом.
+     */
     async resolveConflict(context) {
         if (!this.provider)
             throw new Error("Orchestrator not enabled");

package/dist/llm/provider-budget.js

@@ -1,10 +1,10 @@
-// src/llm/provider-budget
+/** Баланс провайдера: запрос расхода/остатка (только OpenRouter по API). */
 /**
  * Запрос баланса/расхода у провайдера. Поддерживается только OpenRouter —
  * единственный, кто отдаёт эти данные по API-ключу. Zen/Go баланс не
  * возвращают (только веб-дашборд), поэтому для них честно `unsupported`.
  */
-const DEFAULT_TIMEOUT_MS = 5000;
+import { PROVIDER_BUDGET_TIMEOUT_MS as DEFAULT_TIMEOUT_MS } from "../config/timeouts";
 /** Приводит значение к конечному числу; иначе undefined. */
 function num(value) {
     return typeof value === "number" && Number.isFinite(value) ? value : undefined;

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 */