@armadra/agent 0.2.1 → 0.4.0

package/dist/tui/components/editor-history.js

@@ -0,0 +1,45 @@
+/**
+ * 编辑器的历史文件（设计 §12.4）：JSONL，每行一个 JSON 字符串，保留最近 `limit` 条。[B4]
+ * 读写失败都不影响编辑（损坏的行跳过；写失败静默）。
+ */
+import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+export function loadHistoryFile(path, limit = 500) {
+    let text;
+    try {
+        text = readFileSync(path, "utf8");
+    }
+    catch {
+        return [];
+    }
+    const entries = [];
+    for (const line of text.split("\n")) {
+        if (line.trim() === "")
+            continue;
+        try {
+            const value = JSON.parse(line);
+            if (typeof value === "string" && value !== "")
+                entries.push(value);
+        }
+        catch {
+            // 损坏的行跳过
+        }
+    }
+    return entries.slice(-limit);
+}
+export function appendHistoryFile(path, entry, limit) {
+    try {
+        mkdirSync(dirname(path), { recursive: true });
+        appendFileSync(path, JSON.stringify(entry) + "\n", { mode: 0o600 });
+        const all = loadHistoryFile(path, Number.MAX_SAFE_INTEGER);
+        if (all.length > limit * 2) {
+            writeFileSync(path, all
+                .slice(-limit)
+                .map((e) => JSON.stringify(e) + "\n")
+                .join(""));
+        }
+    }
+    catch {
+        // 历史写失败不影响编辑
+    }
+}

package/dist/tui/components/editor-paste.d.ts

@@ -1,5 +1,5 @@
 /**
- * 大粘贴折叠（设计 §12.4）：超过 10 行或超过 1 000 字符的粘贴折叠为 `[paste #N +M lines]`，
+ * 大粘贴折叠（设计 §12.4）：超过 10 行或超过 1 000 字符的粘贴折叠为 `[粘贴 #N · M 行]`，
  * 在编辑器里是不可分割段；提交时展开为原文。[B4]
  *
  * - 换行规范化：`\r\n` / 单独的 `\r` → `\n`（括号粘贴里终端常把换行发成 `\r`）。

package/dist/tui/components/editor-paste.js

@@ -1,5 +1,5 @@
 /**
- * 大粘贴折叠（设计 §12.4）：超过 10 行或超过 1 000 字符的粘贴折叠为 `[paste #N +M lines]`，
+ * 大粘贴折叠（设计 §12.4）：超过 10 行或超过 1 000 字符的粘贴折叠为 `[粘贴 #N · M 行]`，
  * 在编辑器里是不可分割段；提交时展开为原文。[B4]
  *
  * - 换行规范化：`\r\n` / 单独的 `\r` → `\n`（括号粘贴里终端常把换行发成 `\r`）。
@@ -8,7 +8,7 @@
  */
 export const PASTE_LINE_THRESHOLD = 10;
 export const PASTE_CHAR_THRESHOLD = 1000;
-const MARKER_RE = /\[paste #(\d+) \+(\d+) lines\]/g;
+const MARKER_RE = /\[粘贴 #(\d+) · (\d+) 行\]/g;
 export function normalizePastedText(text) {
     return text.replace(/\r\n?/g, "\n");
 }
@@ -20,7 +20,7 @@ export function shouldCollapse(text) {
     return countLines(text) > PASTE_LINE_THRESHOLD || text.length > PASTE_CHAR_THRESHOLD;
 }
 export function formatMarker(id, lines) {
-    return `[paste #${id} +${lines} lines]`;
+    return `[粘贴 #${id} · ${lines} 行]`;
 }
 export class PasteStore {
     next = 1;
@@ -48,7 +48,7 @@ export class PasteStore {
     }
     /** 一行内已登记标记的区间（编辑器的不可分割段）。 */
     ranges(line) {
-        if (this.entries.size === 0 || !line.includes("[paste #"))
+        if (this.entries.size === 0 || !line.includes("[粘贴 #"))
             return [];
         const out = [];
         for (const m of line.matchAll(MARKER_RE)) {

package/dist/tui/components/editor.d.ts

@@ -1,17 +1,21 @@
 /**
  * 多行编辑器组件（设计 §12.3、§12.4）。[B4]
  *
- * - 渲染：上下边框之间按列宽折行（不切开字素与折叠标记）；超过 `maxVisibleLines` 时视窗跟随光标，
- *   边框上提示上 / 下方隐藏的行数；获焦时在光标处输出 CURSOR_MARKER 并反显光标格。
+ * - 渲染：上下规则线之间按列宽折行（不切开字素与折叠标记）；首行前是提示符 `› `（`user` 粗体，
+ *   `disableSubmit` 时 dim），续行缩进 2 列对齐；超过 `maxVisibleLines` 时视窗跟随光标，规则线上提示
+ *   上 / 下方隐藏的行数（dim）；获焦时在光标处输出 CURSOR_MARKER 并反显光标格。空文本显示占位
+ *   （获焦时也显示，光标反显占位首字）。
  * - 键位：`tui.editor.*`（见 keybindings.ts）。Enter 提交（`disableSubmit` 时忽略）；Shift+Enter / Ctrl+J 换行；
  *   Up/Down 在首 / 末视觉行时浏览历史（单行文本或空文本或已在浏览中），否则按视觉行移动。
  * - 括号粘贴（`ESC[200~…ESC[201~`，由 StdinBuffer 合成一次输入）：> 10 行或 > 1 000 字符折叠为
- *   `[paste #N +M lines]`，提交时展开；粘贴期间不触发补全；粘贴后紧随的 `\r` 是普通 Enter（提交）。
- * - 补全：提供者由外部注入（`/` 命令、`@` 文件等由 B7 实现）；同步或异步返回候选与替换起点。
+ *   `[粘贴 #N · M 行]`，提交时展开；粘贴期间不触发补全；粘贴后紧随的 `\r` 是普通 Enter（提交）。
+ * - 补全：提供者由外部注入（`/` 命令、`@` 文件等由 B7 实现）；同步或异步返回候选与替换起点；
+ *   弹层缩进 2 列，尾行 `(i/n) Tab 接受 · Esc 关闭`。
  * - 历史：会话内 + 可选历史文件（JSONL，每行一个 JSON 字符串，保留最近 500 条）。
  */
 import { type Component, type Focusable, type Theme } from "../component.js";
 import { type Keybindings } from "../keybindings.js";
+export { loadHistoryFile } from "./editor-history.js";
 export interface AutocompleteItem {
     /** 接受后替换进编辑器的文本。 */
     value: string;
@@ -52,7 +56,6 @@ export interface EditorOptions {
     onSubmit?(text: string): void;
     onChange?(text: string): void;
 }
-export declare function loadHistoryFile(path: string, limit?: number): string[];
 export declare class Editor implements Component, Focusable {
     private readonly options;
     focused: boolean;
@@ -103,7 +106,10 @@ export declare class Editor implements Component, Focusable {
     private applyCompletion;
     private acceptCompletion;
     private closeCompletion;
+    /** 文本列宽：去掉提示符与行尾光标格。 */
     private contentWidth;
+    private prompt;
+    private placeholderLine;
     /** 逻辑行 → 视觉行（按列宽折行，不切开字素与折叠标记）。 */
     private layout;
     private cursorRowIndex;

package/dist/tui/components/editor.js

@@ -1,65 +1,32 @@
 /**
  * 多行编辑器组件（设计 §12.3、§12.4）。[B4]
  *
- * - 渲染：上下边框之间按列宽折行（不切开字素与折叠标记）；超过 `maxVisibleLines` 时视窗跟随光标，
- *   边框上提示上 / 下方隐藏的行数；获焦时在光标处输出 CURSOR_MARKER 并反显光标格。
+ * - 渲染：上下规则线之间按列宽折行（不切开字素与折叠标记）；首行前是提示符 `› `（`user` 粗体，
+ *   `disableSubmit` 时 dim），续行缩进 2 列对齐；超过 `maxVisibleLines` 时视窗跟随光标，规则线上提示
+ *   上 / 下方隐藏的行数（dim）；获焦时在光标处输出 CURSOR_MARKER 并反显光标格。空文本显示占位
+ *   （获焦时也显示，光标反显占位首字）。
  * - 键位：`tui.editor.*`（见 keybindings.ts）。Enter 提交（`disableSubmit` 时忽略）；Shift+Enter / Ctrl+J 换行；
  *   Up/Down 在首 / 末视觉行时浏览历史（单行文本或空文本或已在浏览中），否则按视觉行移动。
  * - 括号粘贴（`ESC[200~…ESC[201~`，由 StdinBuffer 合成一次输入）：> 10 行或 > 1 000 字符折叠为
- *   `[paste #N +M lines]`，提交时展开；粘贴期间不触发补全；粘贴后紧随的 `\r` 是普通 Enter（提交）。
- * - 补全：提供者由外部注入（`/` 命令、`@` 文件等由 B7 实现）；同步或异步返回候选与替换起点。
+ *   `[粘贴 #N · M 行]`，提交时展开；粘贴期间不触发补全；粘贴后紧随的 `\r` 是普通 Enter（提交）。
+ * - 补全：提供者由外部注入（`/` 命令、`@` 文件等由 B7 实现）；同步或异步返回候选与替换起点；
+ *   弹层缩进 2 列，尾行 `(i/n) Tab 接受 · Esc 关闭`。
  * - 历史：会话内 + 可选历史文件（JSONL，每行一个 JSON 字符串，保留最近 500 条）。
  */
-import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
 import { CURSOR_MARKER } from "../component.js";
 import { truncateToWidth, visibleWidth } from "../ansi.js";
 import { defaultKeybindings } from "../keybindings.js";
 import { isPasteData, isPrintableText, unwrapPaste } from "../keys.js";
 import { plainTheme } from "../theme.js";
 import { EditorBuffer } from "./editor-buffer.js";
+import { appendHistoryFile, loadHistoryFile } from "./editor-history.js";
 import { PasteStore } from "./editor-paste.js";
 import { SelectList } from "./select-list.js";
+export { loadHistoryFile } from "./editor-history.js";
 const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
-export function loadHistoryFile(path, limit = 500) {
-    let text;
-    try {
-        text = readFileSync(path, "utf8");
-    }
-    catch {
-        return [];
-    }
-    const entries = [];
-    for (const line of text.split("\n")) {
-        if (line.trim() === "")
-            continue;
-        try {
-            const value = JSON.parse(line);
-            if (typeof value === "string" && value !== "")
-                entries.push(value);
-        }
-        catch {
-            // 损坏的行跳过
-        }
-    }
-    return entries.slice(-limit);
-}
-function appendHistoryFile(path, entry, limit) {
-    try {
-        mkdirSync(dirname(path), { recursive: true });
-        appendFileSync(path, JSON.stringify(entry) + "\n", { mode: 0o600 });
-        const all = loadHistoryFile(path, Number.MAX_SAFE_INTEGER);
-        if (all.length > limit * 2) {
-            writeFileSync(path, all
-                .slice(-limit)
-                .map((e) => JSON.stringify(e) + "\n")
-                .join(""));
-        }
-    }
-    catch {
-        // 历史写失败不影响编辑
-    }
-}
+/** 提示符 `› ` / 续行缩进的宽度。 */
+const PROMPT_WIDTH = 2;
+const COMPLETION_FOOTER = "Tab 接受 · Esc 关闭";
 export class Editor {
     options;
     focused = false;
@@ -380,7 +347,13 @@ export class Editor {
             ? { value: item.value, label: item.label }
             : { value: item.value, label: item.label, description: item.description });
         this.completion = {
-            list: new SelectList(items, { maxVisible: 8, theme: this.theme, keybindings: this.keys }),
+            list: new SelectList(items, {
+                maxVisible: 8,
+                theme: this.theme,
+                keybindings: this.keys,
+                footer: COMPLETION_FOOTER,
+                showCount: true,
+            }),
             from: result.from,
         };
     }
@@ -401,8 +374,22 @@ export class Editor {
         this.completionToken++;
     }
     // ---- 渲染 -----------------------------------------------------------------
+    /** 文本列宽：去掉提示符与行尾光标格。 */
     contentWidth(width) {
-        return Math.max(1, width - 1);
+        return Math.max(1, width - PROMPT_WIDTH - 1);
+    }
+    prompt() {
+        const glyph = this.theme.glyphs.prompt;
+        return this.theme.fg(this.disableSubmit ? "dim" : "user", this.theme.bold(glyph)) + " ";
+    }
+    placeholderLine(width) {
+        const text = this.options.placeholder ?? "";
+        if (!this.focused)
+            return truncateToWidth(this.prompt() + this.theme.fg("dim", text), width);
+        const first = nextGrapheme(text, 0);
+        const rest = text.slice(first.length);
+        const cursor = CURSOR_MARKER + `\x1b[7m${this.theme.fg("dim", first)}\x1b[27m`;
+        return truncateToWidth(this.prompt() + cursor + this.theme.fg("dim", rest), width);
     }
     /** 逻辑行 → 视觉行（按列宽折行，不切开字素与折叠标记）。 */
     layout(width) {
@@ -494,27 +481,34 @@ export class Editor {
             this.scrollTop = cursorRow - maxVisible + 1;
         this.scrollTop = Math.max(0, Math.min(this.scrollTop, rows.length - maxVisible));
         const end = Math.min(rows.length, this.scrollTop + maxVisible);
-        const lines = [this.border(width, this.scrollTop > 0 ? `↑ ${this.scrollTop}` : "")];
-        if (this.buffer.isEmpty() && this.options.placeholder && !this.focused) {
-            lines.push(truncateToWidth(theme.fg("dim", this.options.placeholder), width));
+        const g = theme.glyphs;
+        const lines = [this.border(width, this.scrollTop > 0 ? `${g.arrowUp} ${this.scrollTop}` : "")];
+        if (this.buffer.isEmpty() && this.options.placeholder) {
+            lines.push(this.placeholderLine(width));
         }
         else {
+            const indent = " ".repeat(PROMPT_WIDTH);
             for (let i = this.scrollTop; i < end; i++) {
-                lines.push(this.renderRow(rows[i], this.focused && i === cursorRow));
+                const prefix = i === 0 ? this.prompt() : indent;
+                lines.push(prefix + this.renderRow(rows[i], this.focused && i === cursorRow));
             }
         }
-        lines.push(this.border(width, end < rows.length ? `↓ ${rows.length - end}` : ""));
+        const below = rows.length - end;
+        lines.push(this.border(width, below > 0 ? `${g.arrowDown} ${below}` : ""));
         if (this.completion) {
-            for (const line of this.completion.list.render(width))
-                lines.push(line);
+            for (const line of this.completion.list.render(Math.max(1, width - 2))) {
+                lines.push("  " + line);
+            }
         }
         return lines;
     }
     border(width, label) {
-        if (label === "" || width < label.length + 6)
-            return this.theme.fg("border", "─".repeat(width));
-        const tail = "─".repeat(width - label.length - 5);
-        return (this.theme.fg("border", "─── ") +
+        const rule = this.theme.glyphs.rule;
+        const labelWidth = visibleWidth(label);
+        if (label === "" || width < labelWidth + 6)
+            return this.theme.fg("border", rule.repeat(width));
+        const tail = rule.repeat(width - labelWidth - 5);
+        return (this.theme.fg("border", rule.repeat(3) + " ") +
             this.theme.fg("dim", label) +
             this.theme.fg("border", " " + tail));
     }

package/dist/tui/components/key-value.d.ts

@@ -4,6 +4,7 @@
  * - 键列宽 = 最长键的可见宽度，但不超过总宽的 `maxKeyRatio`（缺省 0.4，至少 4 列），超出的键截断；
  * - 值在剩余宽度内截断（不换行，保留 ANSI 样式）；值里的换行折成 ` ⏎ `；
  * - 宽度连键列都放不下时退化为只显示截断后的键；空行（`key` 为空串）原样输出空行，可作分组间隔。
+ * - `wrap: true`：值按剩余宽度折行（值里的换行也换行），续行对齐值列。
  */
 import type { Component, SemanticColor, Theme } from "../component.js";
 export interface KeyValueRow {
@@ -17,6 +18,8 @@ export interface KeyValueOptions {
     /** 两列之间的空白，缺省 2。 */
     gap?: number;
     maxKeyRatio?: number;
+    /** 值折行（续行对齐值列），缺省 false（截断）。 */
+    wrap?: boolean;
 }
 export declare class KeyValue implements Component {
     private rows;

package/dist/tui/components/key-value.js

@@ -4,8 +4,9 @@
  * - 键列宽 = 最长键的可见宽度，但不超过总宽的 `maxKeyRatio`（缺省 0.4，至少 4 列），超出的键截断；
  * - 值在剩余宽度内截断（不换行，保留 ANSI 样式）；值里的换行折成 ` ⏎ `；
  * - 宽度连键列都放不下时退化为只显示截断后的键；空行（`key` 为空串）原样输出空行，可作分组间隔。
+ * - `wrap: true`：值按剩余宽度折行（值里的换行也换行），续行对齐值列。
  */
-import { padToWidth, truncateToWidth, visibleWidth } from "../ansi.js";
+import { padToWidth, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "../ansi.js";
 /** 键列至少保留的宽度（键更短时取键宽）；再窄就只显示键。 */
 const MIN_KEY_WIDTH = 4;
 export class KeyValue {
@@ -29,15 +30,24 @@ export class KeyValue {
         const keyWidth = Math.min(longest, Math.max(share, MIN_KEY_WIDTH));
         const valueWidth = width - keyWidth - gap;
         const { theme, keyColor = "dim" } = this.options;
-        const lines = this.rows.map(({ key, value }) => {
+        const wrap = this.options.wrap === true;
+        const lines = this.rows.flatMap(({ key, value }) => {
             if (key === "" && value === "")
-                return "";
+                return [""];
             const shownKey = truncateToWidth(key, Math.max(keyWidth, 1));
             const styledKey = theme ? theme.fg(keyColor, shownKey) : shownKey;
             if (valueWidth < 1)
-                return truncateToWidth(styledKey, width);
-            const flat = value.replace(/\r?\n/g, " ⏎ ");
-            return padToWidth(styledKey, keyWidth) + " ".repeat(gap) + truncateToWidth(flat, valueWidth);
+                return [truncateToWidth(styledKey, width)];
+            const head = padToWidth(styledKey, keyWidth) + " ".repeat(gap);
+            if (!wrap) {
+                const flat = value.replace(/\r?\n/g, " ⏎ ");
+                return [head + truncateToWidth(flat, valueWidth)];
+            }
+            const pieces = value
+                .split(/\r?\n/)
+                .flatMap((line) => (line === "" ? [""] : wrapTextWithAnsi(line, valueWidth)));
+            const indent = " ".repeat(keyWidth + gap);
+            return pieces.map((piece, i) => (i === 0 ? head : indent) + piece);
         });
         this.cache = { width, lines };
         return lines;

package/dist/tui/components/loader.d.ts

@@ -1,35 +1,65 @@
 /**
- * 旋转指示器（设计 §12.1、§12.6：运行中显示 Loader 与已用时）。[B4]
+ * 运行指示（设计 §12.1、§12.6；终端界面视觉设计 v1 §3.7）。[B4]
  *
- * 帧由定时器推进并调用 `requestRender`；`stop()` 后不再触发渲染。时钟可注入便于测试。
+ * 一行 `⠋ 动词 · 已用时 · 附加项…`：spinner `accent`、动词正文色、其余 `dim`，以 ` · ` 连接。
+ * - `setVerb(verb, extras, { elapsed })` 换动词（思考中 / 回复中 / 运行 bash / 等待确认……）；
+ *   `setMessage(text)` 是只换动词的旧接口。
+ * - 帧取 `theme.glyphs.spinner`（Unicode 10 帧 80 ms、ASCII 4 帧 250 ms）；`frame` 暴露当前帧字形，
+ *   `onFrame` 让别的组件（运行中的工具摘要行）与 Loader 同帧换字，保证一帧只多改一行。
+ * - `animation: false`：spinner 固定为 `glyphs.spinnerStatic`，定时器每秒一次，已用时变了才请求重绘。
+ * - `stop()` 后不再触发渲染。时钟可注入便于测试。
  */
 import type { Component, Theme } from "../component.js";
-export declare const LOADER_FRAMES: readonly ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+/** Unicode 帧表（兼容旧导出；实际帧取 `theme.glyphs.spinner`）。 */
+export declare const LOADER_FRAMES: readonly string[];
 export interface LoaderOptions {
+    /** 初始动词（旧名 message）。 */
     message?: string;
     theme?: Theme;
-    /** 帧间隔（ms），缺省 80。 */
+    /** 帧间隔（ms），缺省 Unicode 80、ASCII 250；`animation: false` 时为 1000。 */
     intervalMs?: number;
     /** 显示已用时（`12s`、`1m05s`），缺省 true。 */
     showElapsed?: boolean;
+    /** false：spinner 静止，缺省 true。 */
+    animation?: boolean;
     now?: () => number;
 }
+export interface LoaderVerbOptions {
+    /** 本动词是否显示已用时（缺省跟随 `showElapsed`）。 */
+    elapsed?: boolean;
+}
 export declare function formatElapsed(ms: number): string;
 export declare class Loader implements Component {
     private readonly requestRender;
     private readonly options;
-    private frame;
+    private frameIndex;
     private timer;
     private startedAt;
-    private message;
+    private verb;
+    private extras;
+    private verbElapsed;
+    private lastElapsed;
+    private readonly listeners;
     private readonly now;
     constructor(requestRender: () => void, options?: LoaderOptions);
     get running(): boolean;
+    private get frames();
+    private get animated();
+    /** 当前帧字形（静止时为 `spinnerStatic`）。 */
+    get frame(): string;
+    /** 订阅换帧（返回取消函数）。 */
+    onFrame(listener: (frame: string) => void): () => void;
+    /** 换动词与附加项（附加项 dim，排在已用时之后）。 */
+    setVerb(verb: string, extras?: readonly string[], options?: LoaderVerbOptions): void;
+    /** 旧接口：只换动词。 */
     setMessage(message: string): void;
+    /** 已用时从现在重新算（换到另一段工作时）。 */
+    resetElapsed(): void;
     start(): void;
     stop(): void;
-    /** 推进一帧（定时器调用；测试可直接调用）。 */
+    /** 推进一帧（定时器调用；测试可直接调用）。静止时只在已用时变化时重绘。 */
     tick(): void;
+    private elapsedText;
     render(width: number): string[];
     invalidate(): void;
 }

package/dist/tui/components/loader.js

@@ -1,10 +1,18 @@
 /**
- * 旋转指示器（设计 §12.1、§12.6：运行中显示 Loader 与已用时）。[B4]
+ * 运行指示（设计 §12.1、§12.6；终端界面视觉设计 v1 §3.7）。[B4]
  *
- * 帧由定时器推进并调用 `requestRender`；`stop()` 后不再触发渲染。时钟可注入便于测试。
+ * 一行 `⠋ 动词 · 已用时 · 附加项…`：spinner `accent`、动词正文色、其余 `dim`，以 ` · ` 连接。
+ * - `setVerb(verb, extras, { elapsed })` 换动词（思考中 / 回复中 / 运行 bash / 等待确认……）；
+ *   `setMessage(text)` 是只换动词的旧接口。
+ * - 帧取 `theme.glyphs.spinner`（Unicode 10 帧 80 ms、ASCII 4 帧 250 ms）；`frame` 暴露当前帧字形，
+ *   `onFrame` 让别的组件（运行中的工具摘要行）与 Loader 同帧换字，保证一帧只多改一行。
+ * - `animation: false`：spinner 固定为 `glyphs.spinnerStatic`，定时器每秒一次，已用时变了才请求重绘。
+ * - `stop()` 后不再触发渲染。时钟可注入便于测试。
  */
 import { truncateToWidth } from "../ansi.js";
-export const LOADER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+import { UNICODE_GLYPHS } from "../glyphs.js";
+/** Unicode 帧表（兼容旧导出；实际帧取 `theme.glyphs.spinner`）。 */
+export const LOADER_FRAMES = UNICODE_GLYPHS.spinner;
 export function formatElapsed(ms) {
     const total = Math.max(0, Math.floor(ms / 1000));
     if (total < 60)
@@ -16,31 +24,74 @@ export function formatElapsed(ms) {
 export class Loader {
     requestRender;
     options;
-    frame = 0;
+    frameIndex = 0;
     timer = null;
     startedAt;
-    message;
+    verb;
+    extras = [];
+    verbElapsed;
+    lastElapsed = "";
+    listeners = new Set();
     now;
     constructor(requestRender, options = {}) {
         this.requestRender = requestRender;
         this.options = options;
         this.now = options.now ?? Date.now;
-        this.message = options.message ?? "";
+        this.verb = options.message ?? "";
         this.startedAt = this.now();
     }
     get running() {
         return this.timer !== null;
     }
-    setMessage(message) {
-        this.message = message;
+    get frames() {
+        return (this.options.theme?.glyphs ?? UNICODE_GLYPHS).spinner;
+    }
+    get animated() {
+        return this.options.animation !== false;
+    }
+    /** 当前帧字形（静止时为 `spinnerStatic`）。 */
+    get frame() {
+        const glyphs = this.options.theme?.glyphs ?? UNICODE_GLYPHS;
+        return this.animated
+            ? this.frames[this.frameIndex % this.frames.length]
+            : glyphs.spinnerStatic;
+    }
+    /** 订阅换帧（返回取消函数）。 */
+    onFrame(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    /** 换动词与附加项（附加项 dim，排在已用时之后）。 */
+    setVerb(verb, extras = [], options = {}) {
+        const same = verb === this.verb &&
+            options.elapsed === this.verbElapsed &&
+            extras.length === this.extras.length &&
+            extras.every((e, i) => e === this.extras[i]);
+        if (same)
+            return;
+        this.verb = verb;
+        this.extras = [...extras];
+        this.verbElapsed = options.elapsed;
         this.requestRender();
     }
+    /** 旧接口：只换动词。 */
+    setMessage(message) {
+        this.setVerb(message);
+    }
+    /** 已用时从现在重新算（换到另一段工作时）。 */
+    resetElapsed() {
+        this.startedAt = this.now();
+    }
     start() {
         if (this.timer !== null)
             return;
         this.startedAt = this.now();
-        this.frame = 0;
-        this.timer = setInterval(() => this.tick(), this.options.intervalMs ?? 80);
+        this.frameIndex = 0;
+        const glyphs = this.options.theme?.glyphs ?? UNICODE_GLYPHS;
+        const interval = this.animated
+            ? (this.options.intervalMs ?? (glyphs.ascii ? 250 : 80))
+            : Math.max(this.options.intervalMs ?? 1000, 1000);
+        this.timer = setInterval(() => this.tick(), interval);
         this.timer.unref?.();
         this.requestRender();
     }
@@ -50,22 +101,34 @@ export class Loader {
         clearInterval(this.timer);
         this.timer = null;
     }
-    /** 推进一帧（定时器调用；测试可直接调用）。 */
+    /** 推进一帧（定时器调用；测试可直接调用）。静止时只在已用时变化时重绘。 */
     tick() {
-        this.frame = (this.frame + 1) % LOADER_FRAMES.length;
+        if (this.animated)
+            this.frameIndex = (this.frameIndex + 1) % this.frames.length;
+        else if (this.elapsedText() === this.lastElapsed)
+            return;
+        const frame = this.frame;
+        for (const listener of this.listeners)
+            listener(frame);
         this.requestRender();
     }
+    elapsedText() {
+        return formatElapsed(this.now() - this.startedAt);
+    }
     render(width) {
         const theme = this.options.theme;
-        const spinner = LOADER_FRAMES[this.frame];
-        const parts = [theme ? theme.fg("accent", spinner) : spinner];
-        if (this.message !== "")
-            parts.push(this.message);
-        if (this.options.showElapsed !== false) {
-            const elapsed = `(${formatElapsed(this.now() - this.startedAt)})`;
-            parts.push(theme ? theme.fg("dim", elapsed) : elapsed);
-        }
-        return [truncateToWidth(parts.join(" "), width)];
+        const dim = (s) => (theme ? theme.fg("dim", s) : s);
+        const parts = [];
+        if (this.verb !== "")
+            parts.push(this.verb);
+        const elapsed = this.elapsedText();
+        this.lastElapsed = elapsed;
+        if (this.verbElapsed ?? this.options.showElapsed !== false)
+            parts.push(dim(elapsed));
+        for (const extra of this.extras)
+            parts.push(dim(extra));
+        const spinner = theme ? theme.fg("accent", this.frame) : this.frame;
+        return [truncateToWidth(`${spinner} ${parts.join(dim(" · "))}`, width)];
     }
     invalidate() { }
 }

package/dist/tui/components/markdown.d.ts

@@ -4,7 +4,11 @@
  * 支持：ATX 标题、段落（软换行合并为空格，行尾两个空格或 `\` 为硬换行）、无序 / 有序列表（缩进嵌套）、
  * 围栏代码块（边框 + 语言标签；流式时未闭合的围栏按代码块渲染）、引用、分隔线、
  * 行内 `code` / **粗体** / *斜体* / ~~删除线~~ / [链接](url) / <自动链接> / 反斜杠转义。
- * 表格降级为等宽对齐文本（不换行、超宽截断）；不做语法高亮（§12.9）。
+ * 表格降级为等宽对齐文本（列间两个空格、首行粗体其下一条规则线、不换行、超宽截断）；不做语法高亮（§12.9）。
+ *
+ * 配色（终端界面视觉设计 v1 §3.3）：h1 / h2 `accent` 粗体，h3+ 粗体；行内代码 `code`；链接文字 `link`
+ * 加下划线、URL 以 ` (url)` `dim` 追加；列表符号 `muted`；代码块全宽、边框 `border`、语言标签 `dim`、
+ * 正文 `text`；引用 `▎` + `muted` 斜体。字形（圆点、框线、竖条）取 `theme.glyphs`。
  *
  * 缓存：按块缓存渲染结果（键 = 宽度 + 块源文本），流式追加时只有末块重新渲染；解析也是增量的
  * （`Markdown.append` 只从尾部可能变化的块重新解析）。