micro-models-agent 0.63.0 → 1.1.0

package/dist/core/prompt-overflow.js

@@ -0,0 +1,307 @@
+// src/core/prompt-overflow.ts
+import { createHash } from "crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { PromptBuilder } from "./prompt-builder";
+import { estimateTokens } from "../llm/token-counter";
+import { t } from "../i18n/index";
+/** How many tokens the model-facing hint block costs (upper bound for allocation). */
+export const HINT_BLOCK_TOKENS = 60;
+/** Rough chars-per-token factor used for hard truncation fallback. */
+const CHARS_PER_TOKEN = 4;
+const KIND_ORDER = ["instructions", "project-map"];
+const KIND_LABEL = {
+    instructions: "project instructions (AGENTS.md)",
+    "project-map": "project map",
+};
+const KIND_SOURCE_FILE = {
+    instructions: "AGENTS.md",
+    "project-map": "",
+};
+/**
+ * Static dry-run of the system-prompt budget: which kind-carrying blocks do
+ * not fit. Used by bootstrap for the startup banner and by Agent before the
+ * first LLM call (the real resolution).
+ */
+export function dryRunOverflow(allBlocks, systemBudget) {
+    const builder = new PromptBuilder(systemBudget);
+    builder.addBlocks(allBlocks);
+    const result = builder.build();
+    const includedTokens = result.blocks
+        .filter((b) => b.included)
+        .reduce((sum, b) => sum + b.tokens, 0);
+    const overflow = result.excludedBlocks.filter((b) => Boolean(b.kind));
+    return { includedTokens, overflow };
+}
+function cacheKey(kind, content, maxTokens) {
+    return createHash("sha256").update(`${kind}|${maxTokens}|${content}`).digest("hex").slice(0, 24);
+}
+function readCache(cacheDir, key) {
+    try {
+        const path = join(cacheDir, `${key}.md`);
+        if (!existsSync(path))
+            return null;
+        const raw = readFileSync(path, "utf-8").trim();
+        if (!raw)
+            return null;
+        try {
+            const parsed = JSON.parse(raw);
+            if ((parsed.mode === "summary" || parsed.mode === "truncate") && typeof parsed.text === "string" && parsed.text) {
+                return parsed;
+            }
+        }
+        catch {
+            // Legacy plain-text entry — treat as a summary hit
+            return { mode: "summary", text: raw };
+        }
+        return null;
+    }
+    catch {
+        // Corrupted cache — fall through to re-summarize
+    }
+    return null;
+}
+function writeCache(cacheDir, key, entry) {
+    try {
+        mkdirSync(cacheDir, { recursive: true });
+        writeFileSync(join(cacheDir, `${key}.md`), JSON.stringify(entry), "utf-8");
+    }
+    catch {
+        // Best-effort — cache failure must not crash the agent
+    }
+}
+/** Collect a full text response from the streaming provider API. */
+async function collectText(provider, prompt, maxTokens) {
+    let text = "";
+    // Reasoning must be off: a thinking model would burn the completion cap on
+    // <think> before emitting any summary content (observed on qwen3.5-9b).
+    // 2x headroom over the target: token estimates are heuristics, and the
+    // clamp below enforces the real cap no matter what the model returns.
+    for await (const chunk of provider.chat([{ role: "user", content: prompt }], undefined, undefined, {
+        maxTokens: maxTokens * 2,
+        reasoningEffort: "none",
+    })) {
+        if (chunk.type === "text" && chunk.content)
+            text += chunk.content;
+    }
+    return text.trim();
+}
+function truncateToTokens(content, maxTokens) {
+    const maxChars = Math.max(200, maxTokens * CHARS_PER_TOKEN);
+    if (content.length <= maxChars)
+        return content;
+    let cut = content.slice(0, maxChars);
+    const lastBreak = cut.lastIndexOf("\n");
+    if (lastBreak > maxChars * 0.5)
+        cut = cut.slice(0, lastBreak);
+    return `${cut.trimEnd()}\n\n[...truncated — read the full file for details...]`;
+}
+/** One-line first-line label for warnings/logs. */
+function blockLabel(content) {
+    const first = content.split("\n")[0].trim();
+    return first.length > 60 ? `${first.slice(0, 57)}...` : first;
+}
+/**
+ * Summarize (or, failing that, truncate) prompt blocks that exceeded the
+ * system-prompt budget so the project instructions / project map still reach
+ * the model. Summaries are cached on disk keyed by kind + content + budget.
+ * Blocks are resolved in KIND_ORDER priority; the first gets the full
+ * remaining budget, later blocks get whatever is left.
+ */
+export async function resolvePromptOverflow(opts) {
+    const { overflow, includedTokens, systemBudget, provider, cacheDir, logger } = opts;
+    const sorted = [...overflow].sort((a, b) => KIND_ORDER.indexOf(a.kind) - KIND_ORDER.indexOf(b.kind));
+    const replacements = [];
+    const warnings = [];
+    let used = includedTokens;
+    let unresolved = [];
+    // The bootstrap dry-run only warns that blocks "will be summarized before the
+    // first run". Without a notice here the first prompt appears to hang while
+    // the model rewrites AGENTS.md / the project map — surface it.
+    if (sorted.length > 0) {
+        logger?.warn(t("prompt.overflow.compressing", { count: String(sorted.length) }));
+    }
+    for (const block of sorted) {
+        const kind = block.kind;
+        const maxTokens = systemBudget - used - HINT_BLOCK_TOKENS;
+        if (maxTokens < 100) {
+            unresolved.push(kind);
+            continue;
+        }
+        let mode = "summary";
+        let text = "";
+        const key = cacheKey(kind, block.content, maxTokens);
+        const cached = readCache(cacheDir, key);
+        if (cached) {
+            text = cached.text;
+            mode = cached.mode;
+            logger?.debug(`Prompt overflow: cache hit for ${kind} (${key}, ${mode})`);
+        }
+        else if (provider) {
+            const targetChars = Math.floor(maxTokens * (CHARS_PER_TOKEN - 1));
+            logger?.warn(t("prompt.overflow.summarizing", {
+                label: blockLabel(block.content),
+                original: String(block.estimatedTokens),
+                budget: String(maxTokens),
+            }));
+            try {
+                const prompt = [
+                    `Summarize the following ${KIND_LABEL[kind]} document.`,
+                    // 3 chars/token (not 4): non-Latin text (Cyrillic etc.) is ~2-3 chars
+                    // per token, so a 4x target lands the summary over the clamp.
+                    `Target length: at most ${targetChars} characters (~${maxTokens} tokens). Be strict about it.`,
+                    `Preserve concrete facts: file paths, commands, rules, naming conventions, workflow steps.`,
+                    `Keep the structure (headings / bullet lists). Output ONLY the summary text.`,
+                    ``,
+                    `--- DOCUMENT START ---`,
+                    block.content,
+                    `--- DOCUMENT END ---`,
+                ].join("\n");
+                text = await collectText(provider, prompt, maxTokens);
+                // Small models routinely ignore length instructions (observed: the 9B
+                // model produced ~4700 chars against a 3170-char target). One
+                // self-compression retry on the overshoot — the shorter input makes
+                // compliance much likelier — before falling back to the hard clamp.
+                let retries = 0;
+                while (text && estimateTokens(text) > maxTokens && retries < 1) {
+                    retries++;
+                    logger?.debug(`Prompt overflow: ${kind} summary overshot (${estimateTokens(text)} > ${maxTokens} tok), compressing (retry ${retries})`);
+                    text = await collectText(provider, [
+                        `Compress the following text to at most ${targetChars} characters.`,
+                        `Keep the structure (headings / bullet lists) and all concrete facts: file paths, commands, rules.`,
+                        `Output ONLY the compressed text.`,
+                        ``,
+                        `--- TEXT START ---`,
+                        text,
+                        `--- TEXT END ---`,
+                    ].join("\n"), maxTokens);
+                }
+            }
+            catch (err) {
+                logger?.warn(t("prompt.overflow.summarize_failed", {
+                    label: blockLabel(block.content),
+                    error: String(err?.message ?? err),
+                }));
+                text = "";
+            }
+        }
+        if (!text) {
+            // No provider or summarization failed — hard truncation fallback.
+            mode = "truncate";
+            logger?.warn(t("prompt.overflow.truncating", {
+                label: blockLabel(block.content),
+                original: String(block.estimatedTokens),
+            }));
+            text = truncateToTokens(block.content, maxTokens);
+        }
+        // LLMs overshoot: enforce the cap no matter what produced the text.
+        if (estimateTokens(text) > maxTokens) {
+            if (mode === "summary") {
+                mode = "truncate";
+            }
+            text = truncateToTokens(text, maxTokens);
+        }
+        const resolvedTokens = estimateTokens(text);
+        used += resolvedTokens;
+        writeCache(cacheDir, key, { mode, text });
+        replacements.push({
+            content: text,
+            priority: "high",
+            essential: false,
+            estimatedTokens: resolvedTokens,
+            kind,
+        });
+        warnings.push({
+            kind,
+            label: blockLabel(block.content),
+            originalTokens: block.estimatedTokens,
+            resolvedTokens,
+            mode,
+        });
+    }
+    const hintBlock = replacements.length > 0
+        ? {
+            content: [
+                `[Instructions note] Some project blocks exceeded the system-prompt budget and were compressed:`,
+                ...warnings.map((w) => `- ${KIND_LABEL[w.kind]}: ${w.originalTokens} tokens → ${w.resolvedTokens} tokens (${w.mode})`),
+                ...(unresolved.length > 0
+                    ? unresolved.map((k) => `- ${KIND_LABEL[k]}: did not fit at all — read it yourself if needed`)
+                    : []),
+                ...warnings
+                    .filter((w) => KIND_SOURCE_FILE[w.kind])
+                    .map((w) => `Read the full ${KIND_SOURCE_FILE[w.kind]} with read_file if details are missing.`),
+            ].join("\n"),
+            priority: "high",
+            essential: true,
+            estimatedTokens: HINT_BLOCK_TOKENS,
+        }
+        : null;
+    return { replacements, hintBlock, warnings };
+}
+export function resolveContextWindowSource(config) {
+    const entries = config.provider.entries ?? [];
+    const activeLabel = config.provider.active;
+    const activeEntry = entries.find((e) => e.label && e.label === activeLabel) ??
+        (entries.length === 1 ? entries[0] : undefined);
+    if (activeEntry?.contextWindow) {
+        return { source: "entry", label: activeEntry.label, value: activeEntry.contextWindow };
+    }
+    return { source: "global", value: config.contextWindow };
+}
+/**
+ * Human-facing hint on how to raise the context window, aware of whether the
+ * active value comes from the global config (`mma context <N>`) or from a
+ * provider entry override (must be edited in the provider domain file).
+ */
+export function contextWindowHint(config, configDir, recommended) {
+    const src = resolveContextWindowSource(config);
+    if (src.source === "global") {
+        return `run "mma context ${recommended}"`;
+    }
+    return `edit "${join(configDir, "config", "provider.json")}" → provider.entries[label="${src.label}"].contextWindow = ${recommended}`;
+}
+/**
+ * Recommend the next standard context size whose system budget (10%)
+ * accommodates `neededSystemTokens`. Falls back to the largest known size.
+ */
+export function recommendContextSize(neededSystemTokens) {
+    const sizes = [8192, 16384, 32768, 65536, 131072, 262144];
+    return (sizes.find((s) => Math.floor(s * 0.1) >= neededSystemTokens) ?? sizes[sizes.length - 1]);
+}
+/** Context window needed so that `systemFraction` of it covers `neededTokens`. */
+export function requiredContextWindow(neededTokens, systemFraction) {
+    const fraction = systemFraction > 0 ? systemFraction : 0.1;
+    return Math.ceil(neededTokens / fraction);
+}
+/** System-prompt share of the CURRENT window needed to cover `neededTokens`. */
+export function requiredSystemFraction(neededTokens, contextWindow) {
+    if (contextWindow <= 0)
+        return 1;
+    return Math.min(1, Math.ceil((neededTokens / contextWindow) * 100) / 100);
+}
+/**
+ * Localized, concrete fix for an oversized system prompt. Instead of only
+ * snapping to a coarse standard size (which makes a 32K project jump straight
+ * to 131072), it states the raw requirement and both levers: a bigger window
+ * or a bigger share of the current window.
+ */
+export function overflowHint(config, configDir, neededTokens) {
+    const fraction = config.contextBudget?.systemPrompt ?? 0.1;
+    const budget = Math.floor(config.contextWindow * fraction);
+    const recommended = recommendContextSize(neededTokens);
+    const requiredWindow = requiredContextWindow(neededTokens, fraction);
+    const requiredFraction = requiredSystemFraction(neededTokens, config.contextWindow);
+    const how = configDir
+        ? contextWindowHint(config, configDir, recommended)
+        : `increase contextWindow (e.g. to ${recommended})`;
+    return [
+        t("prompt.overflow.hint_needed", {
+            needed: neededTokens,
+            window: config.contextWindow,
+            fraction,
+            budget,
+        }),
+        t("prompt.overflow.hint_window", { required: requiredWindow, recommended, how }),
+        t("prompt.overflow.hint_fraction", { fraction: requiredFraction }),
+    ].join(" ");
+}

package/dist/core/session-logger.js

@@ -88,7 +88,7 @@ export class SessionLogger {
         const caller = this.getCaller?.();
         this.session?.appendMessage({
             role: "assistant",
-            content: content.slice(0, 500),
+            content,
             timestamp: new Date().toISOString(),
             provider: caller?.provider,
             model: caller?.model,
@@ -117,7 +117,7 @@ export class SessionLogger {
         const caller = this.getCaller?.();
         this.session?.appendMessage({
             role: "tool",
-            content: sanitizeLogMessage(result.output.slice(0, 500)),
+            content: sanitizeLogMessage(result.output),
             name: call.name,
             timestamp: new Date().toISOString(),
             provider: caller?.provider,
@@ -191,6 +191,11 @@ export class SessionLogger {
             totalTokens: usage.totalTokens,
             source: usage.source,
             durationMs: usage.durationMs,
+            cacheStable: usage.prefix ? Number(usage.prefix.stableRatio.toFixed(4)) : undefined,
+            cacheCause: usage.prefix?.cause,
+            cachedTokens: usage.cache?.cachedTokens,
+            cacheWriteTokens: usage.cache?.cacheWriteTokens,
+            cacheSource: usage.cache?.source,
         });
     }
     logError(message) {
@@ -248,4 +253,31 @@ export class SessionLogger {
             skills: data.skills,
         });
     }
+    /**
+     * Log a reasoning control event (level set, policy evaluation).
+     */
+    logReasoningControl(data) {
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: "reasoning_control",
+            content: `reasoning level: ${data.level} (source: ${data.source ?? "policy"})`,
+            iteration: data.iteration,
+            level: data.level,
+            strategy: data.strategy,
+            probePassed: data.probePassed,
+            source: data.source,
+        });
+    }
+    /**
+     * Log a MoE observability event (moe_plan / moe_subtask / moe_replan /
+     * moe_verify). Emitted by runWithMoE and MoEExecutor (Plan 4.2).
+     */
+    logMoE(event, data) {
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: event,
+            content: data.detail ?? data.explanation ?? event,
+            ...data,
+        });
+    }
 }

package/dist/i18n/en.json

@@ -44,6 +44,7 @@
   "error.llm_stream_idle_toolcall": "LLM stream stalled after a tool_call started — no data for {timeout}ms. The provider most likely buffers SSE instead of streaming tool-call argument deltas (seen with LM Studio). Raise \"retry.noDataTimeoutMs\" in ~/.mma/config.json (restart required)",
   "error.llm_truncated": "Response hit the completion token limit ({tokens}) and was cut off before any content arrived. Split the task into smaller outputs or raise \"maxCompletionTokens\" in the config",
   "error.llm_truncated_toolcall": "Response hit the completion token limit ({tokens}) in the middle of a tool_call — its arguments were cut off. Write the file in smaller chunks (several write_file/edit_file calls) or raise \"maxCompletionTokens\" in the config",
+  "error.llm_output_truncated": "The response hit the completion token limit ({tokens}) and was cut off — this answer is incomplete. Raise \"maxCompletionTokens\" in the config to allow longer replies",
   "error.llm_provider_stream_error": "Provider returned an error mid-stream: {error}",
   "error.llm_timeout": "LLM request timed out ({timeout}ms)",
   "env.runtime_node": "Running under Node (v{version}) — clipboard image paste, subagent performance and LSP spawn on Windows degrade. Install Bun (https://bun.sh) for full features.",
@@ -339,6 +340,7 @@
   "cli.show_details": "Show session details",
   "cli.delete_session": "Delete a session",
   "cli.first_run": "First run detected. Running setup wizard...",
+  "cli.setup_saved_restart": "Settings saved. Restarting with the new configuration...",
   "cli.unknown_cmd": "Unknown command: {name}.",
   "cli.unknown_command": "Unknown command \"{input}\". Did you mean \"{suggestion}\"?",
   "cli.help_hint": "Type /help for available commands.",
@@ -440,6 +442,8 @@
   "repl.skill_usage": "Usage: /skill [list|loaded|load|unload|search]",
   "repl.agent": "Agent: ",
   "repl.you": "You: ",
+  "repl.you_reasoning": "You [{level}]: ",
+  "repl.you_reasoning_cont": "You [{level}]… ",
   "repl.interrupt": "Interrupted (Esc)",
   "repl.title": "MMA REPL v{version}",
   "repl.model": "Model:",
@@ -508,6 +512,7 @@
   "setup.title": "\n  MMA Setup Wizard v2\n",
   "setup.select_provider": "\n  Select provider type:",
   "setup.select_provider_num": "\n  Select provider (1-{max})",
+  "setup.select_language_num": "\n  Select language (1-{max})",
   "setup.scanning": "  Scanning local LLM servers...",
   "setup.found_servers": "  Found {count} server(s):",
   "setup.no_servers": "  No local servers found. Enter URL manually.",
@@ -532,8 +537,6 @@
   "setup.scanning_spinner": "Scanning local LLM servers…",
   "setup.fetching_spinner": "Fetching model list…",
   "setup.testing_spinner": "Testing chat with \"{model}\"…",
-  "setup.summary_setting": "Setting",
-  "setup.summary_value": "Value",
   "setup.security_header": "\n  --- Security ---",
   "setup.security_status_off": "  Security: OFF (default — all commands allowed)",
   "setup.security_status_on": "  Security: ON (balanced policy by default)",
@@ -584,6 +587,7 @@
   "exec.error_search_failed": "Web search returned nothing for \"{query}\".",
   "exec.error_search_no_query": "Error output is not meaningful — skipping the web search.",
   "exec.npm_exec_hint": "\"could not determine executable to run\" — no \"bin\" for that package/script. Use \"npm run <script>\" (script must exist in package.json) or \"bunx <pkg>\" for a package that declares a bin.",
+  "exec.interactive_hint": "the command needed interactive input but the shell has no TTY (prompt aborted). Re-run it non-interactively — pass every required flag/argument (e.g. `bun create vite <name> --template react-ts` instead of a bare interactive scaffold).",
   "exec.hidden_tool_hint": "\"{tool}\" is not a shell command — it is an MMA tool that is currently hidden. Call the enable_tools tool with tags [\"shell\"] to unlock it; it becomes available on the next iteration.",
   "exec.task_reminder": "Task: {task}. Continue making progress — do not repeat failed actions.",
   "hall.max_retries_exhausted": "Model returned empty or insufficient responses after multiple retries",
@@ -761,9 +765,9 @@
   "prompt.overflow.hint_needed": "the prompt needs ~{needed} system tokens (current budget: {window} × {fraction} = {budget})",
   "prompt.overflow.hint_window": "raise contextWindow to at least {required} (standard size {recommended}) — {how}",
   "prompt.overflow.hint_fraction": "or keep the window and raise contextBudget.systemPrompt to ~{fraction} (run: mma context --system {fraction})",
-  "prompt.overflow.exceeded": "Prompt overflow: \"{label}\" ({original} tok) exceeded the system-prompt budget ({budget} tok) — {mode} to {resolved} tok. To fit fully, {hint}.",
+  "prompt.overflow.exceeded": "Prompt overflow: the system prompt needs ~{needed} tok (budget {budget} tok); \"{label}\" ({original} tok) was {mode} to {resolved} tok. To fit everything fully, {hint}.",
   "prompt.overflow.failed": "Prompt overflow resolution failed: {error} — oversized blocks will be dropped.",
-  "prompt.overflow.startup": "Startup check: {block} ({original} tok) exceeds the system-prompt budget ({budget} tok) — it will be summarized/truncated before the first run. To include it fully, {hint}.",
+  "prompt.overflow.startup": "Startup check: the system prompt needs ~{needed} tok (budget: {budget} tok); {block} ({original} tok) will be summarized/truncated before the first run. To include everything fully, {hint}.",
   "tool.session_info.no_active": "No active session",
   "tool.session_info.result": "Session: \"{name}\" ({id})\nModel: {model}\nProvider: {provider}\nContext window: {contextWindow} tokens\nMessages: {messages}\nCreated: {createdAt}\nUpdated: {updatedAt}",
   "tool.session_info.context": "Context used: {used} / {budget} tokens ({percent}%)",

package/dist/i18n/ru.json

@@ -43,6 +43,7 @@
   "error.llm_stream_idle_toolcall": "Поток LLM завис после начала tool_call — нет данных {timeout}мс. Скорее всего провайдер буферизирует SSE вместо потоковой передачи аргументов tool_call (наблюдается в LM Studio). Увеличьте \"retry.noDataTimeoutMs\" в ~/.mma/config.json (нужен рестарт)",
   "error.llm_truncated": "Ответ упёрся в лимит токенов генерации ({tokens}) и был обрезан до какого-либо содержимого. Разбейте задачу на меньшие порции вывода или увеличьте \"maxCompletionTokens\" в конфиге",
   "error.llm_truncated_toolcall": "Ответ упёрся в лимит токенов генерации ({tokens}) посреди tool_call — его аргументы обрезаны. Пишите файл частями (несколько вызовов write_file/edit_file) или увеличьте \"maxCompletionTokens\" в конфиге",
+  "error.llm_output_truncated": "Ответ упёрся в лимит токенов генерации ({tokens}) и был обрезан — этот ответ неполный. Увеличьте \"maxCompletionTokens\" в конфиге, чтобы разрешить длинные ответы",
   "error.llm_provider_stream_error": "Провайдер вернул ошибку посреди стрима: {error}",
   "error.llm_timeout": "Время запроса LLM истекло ({timeout}мс)",
   "env.runtime_node": "Запущено под Node (v{version}) — вставка изображений из буфера и LSP на Windows работают урезанно. Установите Bun (https://bun.sh) для полного функционала.",
@@ -333,6 +334,7 @@
   "cli.show_details": "Показать детали сессии",
   "cli.delete_session": "Удалить сессию",
   "cli.first_run": "Первый запуск. Запускаем мастер настройки...",
+  "cli.setup_saved_restart": "Настройки сохранены. Перезапуск с новой конфигурацией...",
   "cli.unknown_cmd": "Неизвестная команда: {name}.",
   "cli.unknown_command": "Неизвестная команда \"{input}\". Возможно, вы имели в виду \"{suggestion}\"?",
   "cli.help_hint": "Введите /help для списка команд.",
@@ -434,6 +436,8 @@
   "repl.skill_usage": "Использование: /skill [list|loaded|load|unload|search]",
   "repl.agent": "Агент: ",
   "repl.you": "Вы: ",
+  "repl.you_reasoning": "Вы [{level}]: ",
+  "repl.you_reasoning_cont": "Вы [{level}]… ",
   "repl.interrupt": "Прервано (Esc)",
   "repl.title": "MMA REPL v{version}",
   "repl.model": "Модель:",
@@ -506,6 +510,7 @@
   "setup.title": "\n  Мастер настройки MMA v2\n",
   "setup.select_provider": "\n  Выберите тип провайдера:",
   "setup.select_provider_num": "\n  Выберите провайдер (1-{max})",
+  "setup.select_language_num": "\n  Выберите язык (1-{max})",
   "setup.scanning": "  Сканирование локальных LLM-серверов...",
   "setup.found_servers": "  Найдено серверов: {count}",
   "setup.no_servers": "  Локальные серверы не найдены. Введите URL вручную.",
@@ -530,8 +535,6 @@
   "setup.scanning_spinner": "Сканирование локальных LLM-серверов…",
   "setup.fetching_spinner": "Загрузка списка моделей…",
   "setup.testing_spinner": "Проверка чата с \"{model}\"…",
-  "setup.summary_setting": "Параметр",
-  "setup.summary_value": "Значение",
   "setup.security_header": "\n  --- Безопасность ---",
   "setup.security_status_off": "  Безопасность: ВЫКЛ (по умолчанию — все команды разрешены)",
   "setup.security_status_on": "  Безопасность: ВКЛ (по умолчанию — политика balanced)",
@@ -582,6 +585,7 @@
   "exec.error_search_failed": "Поиск в интернете для \"{query}\" ничего не дал.",
   "exec.error_search_no_query": "Текст ошибки незначимый — поиск в интернете пропущен.",
   "exec.npm_exec_hint": "\"could not determine executable to run\" — у пакета/скрипта нет \"bin\". Используй \"npm run <script>\" (скрипт должен быть в package.json) или \"bunx <pkg>\" для пакета с объявленным bin.",
+  "exec.interactive_hint": "команде нужен интерактивный ввод, но у шелла нет TTY (запрос отменён). Запусти её неинтерактивно — передай все нужные флаги/аргументы (например, `bun create vite <name> --template react-ts` вместо голого интерактивного скаффолда).",
   "exec.hidden_tool_hint": "\"{tool}\" — не команда оболочки, это инструмент MMA, который сейчас скрыт. Вызови тул enable_tools с tags [\"shell\"], чтобы включить его; он станет доступен на следующей итерации.",
   "exec.task_reminder": "Задача: {task}. Продолжай работу — не повторяй неудачные действия.",
   "hall.max_retries_exhausted": "Модель вернула пустой или недостаточный ответ после нескольких попыток",
@@ -761,9 +765,9 @@
   "prompt.overflow.hint_needed": "промпту нужно ~{needed} токенов системного бюджета (сейчас: {window} × {fraction} = {budget})",
   "prompt.overflow.hint_window": "подними contextWindow минимум до {required} (стандартный размер {recommended}) — {how}",
   "prompt.overflow.hint_fraction": "или оставь окно и подними contextBudget.systemPrompt до ~{fraction} (выполни: mma context --system {fraction})",
-  "prompt.overflow.exceeded": "Промпт переполнен: \"{label}\" ({original} токенов) превысил бюджет системного промпта ({budget} токенов) — {mode} до {resolved} токенов. Чтобы включить полностью, {hint}.",
+  "prompt.overflow.exceeded": "Промпт переполнен: системному промпту нужно ~{needed} токенов (бюджет {budget} токенов); \"{label}\" ({original} токенов) было {mode} до {resolved} токенов. Чтобы включить всё полностью, {hint}.",
   "prompt.overflow.failed": "Не удалось разрешить переполнение промпта: {error} — слишком большие блоки будут отброшены.",
-  "prompt.overflow.startup": "Проверка при старте: {block} ({original} токенов) превышает бюджет системного промпта ({budget} токенов) — будет суммаризован/обрезан перед первым запуском. Чтобы включить полностью, {hint}.",
+  "prompt.overflow.startup": "Проверка при старте: системному промпту нужно ~{needed} токенов (бюджет: {budget} токенов); {block} ({original} токенов) будет суммаризован/обрезан перед первым запуском. Чтобы включить всё полностью, {hint}.",
   "tool.session_info.no_active": "Нет активной сессии",
   "tool.session_info.result": "Сессия: \"{name}\" ({id})\nМодель: {model}\nПровайдер: {provider}\nКонтекстное окно: {contextWindow} токенов\nСообщений: {messages}\nСоздана: {createdAt}\nОбновлена: {updatedAt}",
   "tool.session_info.context": "Использовано контекста: {used} / {budget} токенов ({percent}%)",

package/dist/index.js

@@ -7,16 +7,20 @@ export { MigrationDetector, BackupManager } from "./migration/index";
 import { MigrationDetector } from "./migration/detect";
 import { BackupManager } from "./migration/backup";
 import { t } from "./i18n/index";
+import { defaultOutputBus, getDefaultChannel } from "./output";
 import { homedir } from "os";
 import { join } from "path";
 export function checkMigration(configDir) {
     const dir = configDir || join(homedir(), ".mma");
     const detector = new MigrationDetector(dir);
     if (detector.needsMigration()) {
+        // Ensure a terminal subscriber exists before emitting to the bus; library
+        // consumers have no other eager channel creation.
+        getDefaultChannel();
         const backup = new BackupManager(dir);
         backup.backupConfig();
         backup.backupAll();
         const summary = backup.getBackupSummary();
-        console.log(t("migration.summary", { summary }));
+        defaultOutputBus.log("info", "mma", t("migration.summary", { summary }));
     }
 }

package/dist/llm/cache-usage.js

@@ -0,0 +1,76 @@
+/** Безопасно приводит значение к конечному числу; иначе undefined. */
+function num(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+/** Объект ли это (для защиты от null/строк в ответе). */
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+/**
+ * Разбирает usage-объект провайдера в нормализованный `CacheUsage` согласно
+ * формату отчёта. Возвращает undefined, когда провайдер не сообщает о кеше —
+ * вызывающий не должен выдавать отсутствие данных за «cache miss».
+ *
+ * `estimatedPromptTokens` нужен только для формата `ollama`, который не
+ * отдаёт cache-полей: кешированное вычисляется как разница оценки и
+ * `prompt_eval_count`.
+ */
+export function parseCacheUsage(usage, format, estimatedPromptTokens) {
+    if (!isRecord(usage))
+        return undefined;
+    switch (format) {
+        case "openai": {
+            const details = usage.prompt_tokens_details;
+            if (!isRecord(details))
+                return undefined;
+            const cached = num(details.cached_tokens);
+            if (cached === undefined)
+                return undefined;
+            const prompt = num(usage.prompt_tokens) ?? cached;
+            const write = num(details.cache_write_tokens) ?? 0;
+            return {
+                cachedTokens: cached,
+                cacheWriteTokens: write,
+                uncachedTokens: Math.max(0, prompt - cached),
+                source: "api",
+            };
+        }
+        case "deepseek": {
+            const hit = num(usage.prompt_cache_hit_tokens);
+            const miss = num(usage.prompt_cache_miss_tokens);
+            if (hit === undefined && miss === undefined)
+                return undefined;
+            return {
+                cachedTokens: hit ?? 0,
+                cacheWriteTokens: 0,
+                uncachedTokens: miss ?? 0,
+                source: "api",
+            };
+        }
+        case "anthropic": {
+            const read = num(usage.cache_read_input_tokens);
+            const creation = num(usage.cache_creation_input_tokens);
+            if (read === undefined && creation === undefined)
+                return undefined;
+            return {
+                cachedTokens: read ?? 0,
+                cacheWriteTokens: creation ?? 0,
+                uncachedTokens: num(usage.input_tokens) ?? 0,
+                source: "api",
+            };
+        }
+        case "ollama": {
+            const evaluated = num(usage.prompt_eval_count);
+            if (evaluated === undefined || estimatedPromptTokens === undefined)
+                return undefined;
+            return {
+                cachedTokens: Math.max(0, estimatedPromptTokens - evaluated),
+                cacheWriteTokens: 0,
+                uncachedTokens: evaluated,
+                source: "derived",
+            };
+        }
+        default:
+            return undefined;
+    }
+}

package/dist/llm/image-utils.js

@@ -41,27 +41,31 @@ async function readClipboardFallback() {
     const { execSync } = await import("child_process");
     const { readFileSync, unlinkSync } = await import("fs");
     const { join } = await import("path");
+    if (platform() !== "linux")
+        return null; // macOS/Windows use Bun.Image
     const tmpPath = join(process.env.TEMP || process.env.TMP || "/tmp", `mma-clip-${Date.now()}.png`);
-    try {
-        if (platform() === "linux") {
-            execSync(`xclip -selection clipboard -t image/png -o > "${tmpPath}" 2>/dev/null`, {
-                timeout: 5000,
-            });
-        }
-        else {
-            return null; // macOS/Windows should use Bun.Image
-        }
-        const buf = readFileSync(tmpPath);
-        unlinkSync(tmpPath);
-        return buf.length > 0 ? buf : null;
-    }
-    catch {
+    // Try Wayland (wl-paste) first, then X11 (xclip)
+    const commands = [
+        `wl-paste --type image/png > "${tmpPath}" 2>/dev/null`,
+        `xclip -selection clipboard -t image/png -o > "${tmpPath}" 2>/dev/null`,
+    ];
+    for (const cmd of commands) {
         try {
+            execSync(cmd, { timeout: 5000 });
+            const buf = readFileSync(tmpPath);
             unlinkSync(tmpPath);
+            if (buf.length > 0)
+                return buf;
         }
-        catch { }
-        return null;
+        catch {
+            // try next command
+        }
+    }
+    try {
+        unlinkSync(tmpPath);
     }
+    catch { }
+    return null;
 }
 /**
  * Load an image from a file path, resize via Bun.Image, return as JPEG data URL.