micro-models-agent 2.10.0 → 2.12.0

package/dist/ui/renderer.js

@@ -1,6 +1,9 @@
+// Рендерер чата: события агента в терминальные строки по STYLE.md.
 import { pc } from "./colors";
 import { FormattingStream } from "./md-formatter";
 import { Spinner } from "./spinner";
+import { actionMarkFor, failureMark, glyph, successMark, formatDuration, toolAccent, } from "./theme";
+import { recordLastAction } from "./action-log";
 import { getTerminalWidth } from "./table";
 import { t } from "../i18n/index";
 import { formatCost } from "../modules/pricing/prices";
@@ -9,7 +12,7 @@ import { isAbsolute, relative, sep } from "path";
 function formatUsd(cost) {
     return formatCost(cost);
 }
-/** Tools whose `path` argument is shown in the header. */
+/** Тулы, чей аргумент `path` показывается в шапке. */
 const PATH_TOOLS = new Set([
     "read_file",
     "write_file",
@@ -24,41 +27,53 @@ function toDisplayPath(baseDir, p) {
     if (!baseDir || !isAbsolute(p))
         return p;
     const rel = relative(baseDir, p);
-    // Outside baseDir (../ prefix) or another drive (absolute result) → keep as-is.
+    // Вне baseDir (префикс ../) или другой диск (абсолютный результат) — как есть.
     if (!rel || rel.startsWith("..") || isAbsolute(rel))
         return p;
     return rel.split(sep).join("/");
 }
 const GUTTER = "  ";
 const MAX_OUTPUT_LINES = 50;
-/** Tools that must NOT get a busy spinner — they block on a user prompt. */
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+function stripAnsi(text) {
+    return text.replace(ANSI_RE, "");
+}
+/** Тулы без busy-спиннера: висят на промпте пользователя. */
 const SPINNERLESS_TOOLS = new Set(["question", "approve"]);
-/** opencode-like leading marker per tool category. */
-export function toolMarker(tool) {
-    switch (tool) {
-        case "write_file":
-        case "edit_file":
-        case "create_dir":
-        case "move_file":
-        case "delete_file":
-            return "←";
-        case "read_file":
-        case "list_dir":
-        case "file_info":
-            return "→";
-        case "glob":
-        case "grep":
-            return "✱";
-        case "bash":
-            return "$";
-        default:
-            return "⚙";
-    }
+/**
+ * Read-only тулы разведки. В quiet прогон таких сворачивается в одну строку
+ * `│ N actions ✓`; мутирующие/исполняющие всегда видимы.
+ */
+const RECON_TOOLS = new Set([
+    "read_file",
+    "list_dir",
+    "glob",
+    "grep",
+    "file_info",
+    "project_map",
+    "chunk_query",
+    "web_search",
+    "web_fetch",
+    "web_browse",
+    "search_history",
+    "recall",
+    "session_info",
+    "process_list",
+    "process_log",
+]);
+/**
+ * Ведущий маркер каждого действия. В стиле один маркер (`◇`) на все тулы:
+ * категории передаются локализованным ярлыком, а не глифом.
+ * Функция ради вызывающих с явным `icon`.
+ */
+export function toolMarker(_tool) {
+    return glyph.action;
 }
+/** Rich-терминал: TTY и не CI. */
 export function isRichTerminal() {
     return Boolean(process.stdout.isTTY) && !process.env.CI;
 }
-/** Short human-friendly summary of tool arguments. */
+/** Короткая человекочитаемая сводка аргументов тула. */
 export function summarizeArgs(args) {
     const preferred = ["path", "file", "query", "url", "command", "name"];
     for (const key of preferred) {
@@ -72,15 +87,134 @@ export function summarizeArgs(args) {
         return "";
     return serialized.length > 60 ? `${serialized.slice(0, 57)}…` : serialized;
 }
+/** Скалярные ключи, показываемые как есть, в порядке приоритета, для обычных тулов. */
+const GENERIC_ARG_KEYS = [
+    "path",
+    "file",
+    "pattern",
+    "query",
+    "url",
+    "command",
+    "name",
+    "task",
+    "level",
+    "id",
+    "source",
+    "step",
+    "key",
+    "value",
+    "text",
+];
+function str(value) {
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "number")
+        return String(value);
+    return "";
+}
+function truncateArg(text, max = 60) {
+    return text.length > max ? `${text.slice(0, max - 3)}…` : text;
+}
+/**
+ * Человекочитаемая сводка аргументов. Структурные/экшен-тулы несут сырой JSON,
+ * который потёк бы в чат, — им короткая локализованная фраза вместо него.
+ */
+export function humanArgs(tool, args) {
+    if (tool === "plan") {
+        const action = typeof args.action === "string" ? args.action : "";
+        if (action === "update") {
+            const step = args.step ?? args.stepId;
+            const status = args.status;
+            if (step !== undefined || status !== undefined) {
+                return t("ui.plan_update", {
+                    step: String(step ?? "?"),
+                    status: String(status ?? "?"),
+                });
+            }
+        }
+        if (action === "create" && typeof args.title === "string")
+            return args.title;
+        if (action)
+            return action;
+    }
+    if (tool === "plan_step") {
+        const step = args.step;
+        const status = args.status;
+        if (step !== undefined || status !== undefined) {
+            return t("ui.plan_update", {
+                step: String(step ?? "?"),
+                status: String(status ?? "?"),
+            });
+        }
+    }
+    if (tool === "todo") {
+        const action = typeof args.action === "string" ? args.action : "";
+        const items = Array.isArray(args.items) ? args.items.length : undefined;
+        if (action && items !== undefined)
+            return t("ui.todo_action", { action, count: String(items) });
+        if (action)
+            return action;
+    }
+    // Обычные экшен-тулы (browser, project_map, lsp_check, …) несут `action` плюс
+    // пару коротких скаляров — рендерим фразу, а не сырой JSON.
+    if (typeof args.action === "string" && args.action) {
+        const extras = ["direction", "selector", "key", "name", "path", "url", "query", "text", "id"]
+            .map((k) => (typeof args[k] === "string" && args[k] ? args[k] : undefined))
+            .filter((v) => Boolean(v));
+        return truncateArg([args.action, ...extras].join(" "));
+    }
+    // Композиты, где один ключ уронил бы половину смысла.
+    if (tool === "move_file") {
+        const from = str(args.from);
+        const to = str(args.to);
+        if (from && to)
+            return truncateArg(`${from} → ${to}`);
+    }
+    if (tool === "mcp_call") {
+        const server = str(args.server);
+        const name = str(args.tool);
+        if (server && name)
+            return `${server}/${name}`;
+    }
+    if (tool === "remember") {
+        const category = str(args.category);
+        const key = str(args.key);
+        const entry = str(args.entry);
+        const body = key && args.value !== undefined ? `${key} = ${str(args.value)}` : key || entry;
+        const phrase = [category, body].filter(Boolean).join(" · ");
+        if (phrase)
+            return truncateArg(phrase);
+    }
+    if (tool === "enable_tools") {
+        const tags = Array.isArray(args.tags) ? args.tags.map(String).filter(Boolean) : [];
+        if (tags.length)
+            return tags.join(", ");
+    }
+    for (const key of GENERIC_ARG_KEYS) {
+        const value = str(args[key]);
+        if (value)
+            return truncateArg(value);
+    }
+    return summarizeArgs(args);
+}
+/**
+ * Локализованный человеческий ярлык тула. Системные имена (`read_file`, `bash`, …)
+ * НЕ показываются юзеру ни в одной локали — см. `docs/design/ui/STYLE.md`.
+ * Сырой идентификатор — лишь ключ поиска; без friendly-перевода откатываемся на
+ * общий локализованный ярлык, но не на сам идентификатор.
+ */
 function friendlyTool(tool) {
     const key = `tool.friendly.${tool}`;
     const value = t(key);
-    return value !== key ? value : tool;
+    if (value !== key)
+        return value;
+    const fallback = t("ui.action_fallback");
+    return fallback !== "ui.action_fallback" ? fallback : "Action";
 }
 /**
- * Streams agent events to the terminal. Rich mode (TTY) adds a spinner;
- * plain mode falls back to simple prefixed lines.
- * Colors come from `colors.ts`, disabled outside a TTY, in CI, or on NO_COLOR.
+ * Стримит события агента в терминал. Rich-режим (TTY) добавляет спиннер;
+ * plain — простые строки с префиксом.
+ * Цвета из `colors.ts`, вне TTY / в CI / при NO_COLOR выключены.
  */
 export class Renderer {
     rich;
@@ -89,17 +223,30 @@ export class Renderer {
     channel;
     width;
     baseDir;
+    verbosity;
     card = null;
     thoughtStarted = false;
     thoughtStartMs = 0;
     thoughtHeaderPrinted = false;
+    /** Чередует короткие человеческие ярлыки, чтобы повторы thinking не звучали роботно. */
+    thinkingCount = 0;
+    thinkingLabel = "";
     textStarted = false;
+    reconBuffer = [];
+    /**
+     * Отложенная на шаг строка действия (quiet): даёт идентичному повтору
+     * свернуться в строку `×N`. Всегда сбрасывается до печати чего-то новее.
+     */
+    pendingFooter = null;
+    repeatCount = 0;
+    repeatMs = 0;
     outputLineCount = 0;
     outputSuppressed = false;
     constructor(opts = {}) {
         this.rich = opts.rich ?? isRichTerminal();
         this.width = opts.width ?? getTerminalWidth();
         this.baseDir = opts.baseDir;
+        this.verbosity = opts.verbosity ?? "normal";
         this.channel = opts.channel ?? getDefaultChannel();
         this.spinner = new Spinner({
             enabled: this.rich && (opts.spinner ?? true),
@@ -108,42 +255,56 @@ export class Renderer {
         });
         this.fmt = new FormattingStream((line) => this.channel.writeRaw(`${line}\n`), this.width, (text) => this.channel.writeRaw(text), { reservedCols: 2, streamPartials: this.rich });
     }
-    /** Show a thinking spinner while waiting for LLM response. */
+    /** Спиннер обдумывания на время ожидания ответа LLM. */
     showLoader() {
         this.spinner.start(t("ui.thinking"));
     }
-    /** Final answer streamed from the model (markdown-formatted). */
+    /** Финальный ответ модели стримом (markdown-формат). */
     text(chunk) {
         this.endCard();
+        this.flushRecon();
+        this.closeThought();
         this.spinner.stop();
         if (!this.textStarted) {
             this.textStarted = true;
-            this.channel.writeRaw(`\n${pc.dim("-")} `);
+            // Ответ уже введён разделителем/ярлыком REPL; ведущий маркер конфликтовал
+            // бы с кодовым блоком, открывающим ответ.
+            this.channel.writeRaw("\n");
         }
         this.fmt.write(chunk);
     }
-    /** Arbitrary status/meta text (tool output, reasoning, MoE status). */
+    /** Произвольный статус/мета-текст (вывод тула, reasoning, статус MoE). */
     meta(chunk) {
         this.spinner.stop();
         if (this.thoughtStarted) {
-            if (!this.thoughtHeaderPrinted) {
-                this.channel.writeRaw(`\n${pc.dim("→")} Thought: `);
-                this.thoughtHeaderPrinted = true;
-            }
+            this.writeThoughtHeader();
             this.channel.writeRaw(pc.dim(chunk));
         }
         else if (this.card) {
             this.writeInlineBody(chunk);
         }
         else {
+            this.flushRecon();
             this.channel.writeRaw(chunk);
         }
     }
-    /** Stream tool body lines with the gutter prefix, skipping blank lines. */
+    /** Стримит строки тела тула с гуттером, пустые скипает. */
     writeInlineBody(chunk) {
         for (const line of chunk.split("\n")) {
             if (line.trim() === "")
                 continue;
+            const plain = stripAnsi(line).trim();
+            if (this.card) {
+                if (this.card.body.length < MAX_OUTPUT_LINES)
+                    this.card.body.push(plain);
+                if (!this.card.firstBody)
+                    this.card.firstBody = plain;
+            }
+            if (this.verbosity === "quiet") {
+                // Первую строку держим, чтобы у провала осталось короткое объяснение, но
+                // чат не заливаем: детали — через /verbose и Ctrl+O.
+                continue;
+            }
             this.outputLineCount++;
             if (this.outputLineCount > MAX_OUTPUT_LINES) {
                 this.outputSuppressed = true;
@@ -152,107 +313,272 @@ export class Renderer {
             this.channel.writeRaw(`${GUTTER}${line}\n`);
         }
     }
-    /** Dimmed reasoning stream (already colored by the agent). */
+    /** Dim-стрим рассуждений (красится здесь, а не агентом). */
     reasoning(chunk) {
         this.spinner.stop();
-        if (this.thoughtStarted && !this.thoughtHeaderPrinted) {
-            this.channel.writeRaw(`\n${pc.dim("→")} Thought: `);
-            this.thoughtHeaderPrinted = true;
-        }
+        this.flushRecon();
+        this.writeThoughtHeader();
         this.channel.writeRaw(pc.dim(chunk));
     }
-    /** Model is loading / generating — record start time. */
+    /**
+     * Открывает блок мысли: `✦ <акцентный ярлык> · ` — ярлык держит акцент
+     * рассуждений, разделитель и тело dim, чтобы глагол статуса не сливался
+     * с собственными словами модели.
+     */
+    writeThoughtHeader() {
+        if (!this.thoughtStarted || this.thoughtHeaderPrinted)
+            return;
+        this.channel.writeRaw(`\n${pc.magenta(glyph.thinking)} ${pc.magenta(this.thinkingLabel)} ${pc.dim("·")} `);
+        this.thoughtHeaderPrinted = true;
+    }
+    /** Модель грузится/генерирует — фиксируем старт. */
     thinkingStart() {
+        this.flushRecon();
         this.thoughtStarted = true;
         this.thoughtStartMs = Date.now();
         this.thoughtHeaderPrinted = false;
+        this.thinkingLabel = this.nextThinkingLabel();
         this.spinner.start(t("ui.thinking"));
     }
-    /** LLM call finished; print duration and close the thought block. */
+    /**
+     * Чередует несколько коротких человеческих ярлыков по фазам thinking. Первая
+     * фаза всегда канонична `ui.thinking_label` (стабильно в тестах/скринах).
+     */
+    nextThinkingLabel() {
+        const index = this.thinkingCount++;
+        const key = index === 0 ? "ui.thinking_label" : `ui.thinking_label_${(index % 3) + 1}`;
+        const value = t(key);
+        return value !== key ? value : t("ui.thinking_label");
+    }
+    /** Вызов LLM завершён; печатаем длительность и закрываем блок мысли. */
     thinkingEnd() {
         this.spinner.stop();
+        this.closeThought();
+    }
+    /**
+     * Закрывает открытый блок мысли с печатью длительности. Безопасно звать
+     * многократно: и финальный ответ, и следующий тул требуют закрытого блока,
+     * чтобы длительность не приземлилась внутрь текста ответа.
+     */
+    closeThought() {
         if (this.thoughtStarted && this.thoughtHeaderPrinted) {
             const duration = Date.now() - this.thoughtStartMs;
-            this.channel.writeRaw(pc.dim(` ${duration}ms\n`));
+            this.channel.writeRaw(pc.dim(` ${formatDuration(duration)}\n`));
         }
         this.thoughtStarted = false;
         this.thoughtHeaderPrinted = false;
     }
-    toolStart(tool, args, stepContext, icon) {
+    /** Старт тула: шапка действия + busy-спиннер (кроме интерактивных). */
+    toolStart(tool, args, stepContext, _icon) {
         this.spinner.stop();
         this.fmt.flushPartialNow();
         this.endCard();
+        this.closeThought();
         this.outputLineCount = 0;
         this.outputSuppressed = false;
         const displayArgs = PATH_TOOLS.has(tool) && typeof args.path === "string"
             ? { ...args, path: toDisplayPath(this.baseDir, args.path) }
             : args;
-        const summary = summarizeArgs(displayArgs);
-        const marker = icon || toolMarker(tool);
+        const summary = humanArgs(tool, displayArgs);
         const label = friendlyTool(tool);
-        this.card = { tool, args, start: Date.now() };
-        if (stepContext) {
-            this.channel.writeRaw(`\n${pc.dim("↓")} ${pc.cyan(stepContext)}\n`);
+        // Один глиф в цвете категории — пер-тул emoji-иконки не используются.
+        const mark = actionMarkFor(tool);
+        const accent = toolAccent(tool);
+        const deferred = this.verbosity === "quiet";
+        this.card = {
+            tool,
+            args,
+            start: Date.now(),
+            label,
+            summary,
+            mark,
+            deferred,
+            firstBody: "",
+            body: [],
+        };
+        if (stepContext && !deferred) {
+            this.channel.writeRaw(`\n${pc.dim(glyph.detail)} ${pc.cyan(stepContext)}\n`);
         }
-        this.channel.writeRaw(`${pc.dim(marker)} ${label}${summary ? ` ${pc.dim(summary)}` : ""}\n`);
-        // Busy indicator while the tool actually runs — read/write/edit/bash can
-        // take seconds; without this the chat looks frozen until the footer.
+        if (!deferred) {
+            this.channel.writeRaw(`${mark} ${accent(label)}${summary ? ` ${pc.dim("·")} ${pc.dim(summary)}` : ""}\n`);
+        }
+        // Busy-индикатор на время реального исполнения: read/write/edit/bash могут
+        // идти секунды; без него чат выглядит зависшим до футера.
         if (!SPINNERLESS_TOOLS.has(tool)) {
             this.spinner.start(`${label}${summary ? ` ${summary}` : ""}`);
         }
     }
-    /** Live plan checklist — prints the plan block as-is (already colored). */
+    /** Смена детализации рендера (использует `/verbose`). */
+    setVerbosity(verbosity) {
+        this.verbosity = verbosity;
+    }
+    /** Выпуск буферного прогона read-only действий (quiet). */
+    flushRecon() {
+        // Отложенная строка действия всегда старше любого буферного recon-прогона:
+        // печатаем её первой, чтобы чат остался хронологичным.
+        this.flushPendingFooter();
+        if (this.reconBuffer.length === 0)
+            return;
+        const items = this.reconBuffer;
+        this.reconBuffer = [];
+        if (items.length === 1) {
+            const it = items[0];
+            const accent = toolAccent(it.tool);
+            const head = `${it.mark} ${accent(it.label)}${it.summary ? ` ${pc.dim("·")} ${pc.dim(it.summary)}` : ""}`;
+            this.channel.writeRaw(`${head}  ${successMark()} ${pc.dim(formatDuration(it.duration))}\n`);
+            return;
+        }
+        const total = items.reduce((a, b) => a + b.duration, 0);
+        const label = t("ui.actions_summary", { count: String(items.length) });
+        this.channel.writeRaw(`${pc.dim(glyph.group)} ${label} ${successMark()} ${pc.dim(`· ${formatDuration(total)}`)} ${pc.dim("· /verbose")}\n`);
+    }
+    /** Печать отложенной строки, повторы сворачивает в одну строку `×N`. */
+    flushPendingFooter() {
+        const p = this.pendingFooter;
+        if (!p)
+            return;
+        this.pendingFooter = null;
+        const times = this.repeatCount + 1;
+        const total = p.duration + this.repeatMs;
+        this.repeatCount = 0;
+        this.repeatMs = 0;
+        const head = `${p.leadMark} ${toolAccent(p.tool)(p.label)}${p.summary ? ` ${pc.dim("·")} ${pc.dim(p.summary)}` : ""}`;
+        const timesPart = times > 1 ? ` ${pc.dim(`×${times}`)}` : "";
+        this.channel.writeRaw(`${head}  ${successMark()} ${pc.dim(formatDuration(total))}${timesPart}\n`);
+    }
+    /** Живой чеклист плана: печатает блок как есть (уже раскрашен). */
     planBlock(lines) {
         this.spinner.stop();
         this.fmt.flushPartialNow();
         this.endCard();
+        this.flushRecon();
         for (const line of lines) {
             this.channel.writeRaw(`${line}\n`);
         }
     }
+    /** Конец тула: футер с длительностью (ошибка → красный маркер + первая строка тела). */
     toolEnd(_tool, duration, error, ctxDelta, costUsd) {
         this.spinner.stop();
         this.fmt.flushPartialNow();
         if (!this.card)
             return;
-        const marker = error ? pc.red("✗") : pc.green("✓");
-        let footer = `${GUTTER}${marker} ${pc.dim(`${duration}ms`)}`;
+        const { label, summary, deferred } = this.card;
+        const mark = error ? failureMark() : successMark();
+        let tail = `${mark} ${pc.dim(formatDuration(duration))}`;
         if (ctxDelta !== undefined && ctxDelta !== 0) {
             const deltaStr = ctxDelta > 0 ? pc.green(`+${ctxDelta}`) : pc.yellow(`${ctxDelta} ↓`);
-            footer += `  ${pc.dim("ctx")} ${deltaStr}`;
+            tail += `  ${pc.dim("ctx")} ${deltaStr}`;
         }
         if (costUsd !== undefined && costUsd > 0) {
-            footer += `  ${pc.dim("cost")} ${pc.yellow(formatUsd(costUsd))}`;
+            tail += `  ${pc.dim("cost")} ${pc.yellow(formatUsd(costUsd))}`;
+        }
+        if (deferred) {
+            this.toolEndDeferred(tail, duration, error);
         }
-        this.channel.writeRaw(`${footer}\n`);
-        if (this.outputSuppressed) {
-            this.channel.writeRaw(`${GUTTER}${pc.dim(`... (${this.outputLineCount - MAX_OUTPUT_LINES} more lines)`)}\n`);
+        else {
+            const footer = `${GUTTER}${tail}`;
+            this.channel.writeRaw(`${footer}\n`);
+            if (this.outputSuppressed) {
+                this.channel.writeRaw(`${GUTTER}${pc.dim(`... (${this.outputLineCount - MAX_OUTPUT_LINES} more lines)`)}\n`);
+            }
         }
+        this.recordLast(label, summary, error, duration);
         this.card = null;
     }
-    /** Raw pre-formatted text (diff blocks, warnings). */
+    /**
+     * Quiet-футер: сворачивает отложенную шапку в одну строку действия.
+     * Успешные read-only тулы буферятся в recon-сводку; подряд идущие одинаковые
+     * успешные сворачиваются в строку `×N`; всё прочее буферится на шаг, чтобы
+     * повтор успел свернуться. Ошибки печатаются сразу.
+     */
+    toolEndDeferred(tail, duration, error) {
+        const card = this.card;
+        if (!card)
+            return;
+        const { label, summary, mark: leadMark, firstBody } = card;
+        // Прогон успешных read-only тулов буферится и суммируется.
+        if (!error && RECON_TOOLS.has(card.tool)) {
+            this.flushPendingFooter();
+            this.reconBuffer.push({ tool: card.tool, mark: leadMark, label, summary, duration });
+            return;
+        }
+        // Подряд идущие одинаковые успешные действия (poll-циклы, повторные
+        // статус-чеки) — в одну строку `×N` вместо N строк.
+        const repeatKey = `${card.tool}::${label}::${summary}`;
+        if (!error && this.pendingFooter?.key === repeatKey) {
+            this.repeatCount += 1;
+            this.repeatMs += duration;
+            return;
+        }
+        this.flushPendingFooter();
+        this.flushRecon();
+        if (!error) {
+            // Буфер на шаг: строка печатается на следующем действии (или любом сбросе),
+            // чтобы идентичный повтор успел свернуться.
+            this.pendingFooter = {
+                key: repeatKey,
+                leadMark,
+                tool: card.tool,
+                label,
+                summary,
+                duration,
+            };
+            return;
+        }
+        const head = `${leadMark} ${toolAccent(card.tool)(label)}${summary ? ` ${pc.dim("·")} ${pc.dim(summary)}` : ""}`;
+        this.channel.writeRaw(`${head}  ${tail}\n`);
+        if (error && firstBody) {
+            const soft = firstBody.startsWith("⚠");
+            const color = soft ? pc.yellow : pc.red;
+            this.channel.writeRaw(`${GUTTER}${pc.dim(glyph.detail)} ${color(firstBody)}\n`);
+        }
+    }
+    /** Запоминает действие для допечатки по `Ctrl+O` (живёт дольше прогона). */
+    recordLast(label, summary, error, duration) {
+        const firstBody = this.card?.firstBody ?? "";
+        const status = !error
+            ? "ok"
+            : firstBody.startsWith("⚠")
+                ? "warn"
+                : "error";
+        recordLastAction({
+            tool: this.card?.tool ?? "",
+            label,
+            args: summary,
+            status,
+            durationMs: duration,
+            body: this.card?.body ?? [],
+        });
+    }
+    /** Сырой предформатированный текст (диффы, предупреждения). */
     raw(text) {
         this.spinner.stop();
         this.fmt.flushPartialNow();
         this.endCard();
+        this.flushRecon();
         this.channel.writeRaw(text);
     }
+    /** Ошибка в stderr с красным маркером. */
     error(text) {
         this.spinner.stop();
         this.fmt.flushPartialNow();
         this.endCard();
-        this.channel.writeRaw(`${pc.red(text)}\n`, "stderr");
+        this.flushRecon();
+        this.channel.writeRaw(`${failureMark()} ${pc.red(text)}\n`, "stderr");
     }
+    /** Сброс всех буферов в конце хода. */
     flush() {
         this.endCard();
+        this.flushRecon();
         this.spinner.stop();
         this.fmt.flushPartialNow();
         this.fmt.flush();
         this.textStarted = false;
     }
-    /** Footer with model, provider, and total duration. */
+    /** Футер с моделью, провайдером и общей длительностью. */
     footer(model, provider, durationMs) {
-        this.channel.writeRaw(`\n${pc.dim("▣")} ${model} · ${provider} · ${pc.dim(`${durationMs}ms`)}\n`);
+        this.flushRecon();
+        this.channel.writeRaw(`\n${pc.dim(glyph.metric)} ${model} · ${provider} · ${pc.dim(formatDuration(durationMs))}\n`);
     }
     endCard() {
         if (!this.card)