@armadra/agent 0.0.0-stage → 0.2.1

package/dist/modes/interactive/line/line-render.js

@@ -0,0 +1,171 @@
+/**
+ * 行式界面的输出：会话事件 → 纯文本（助手文本流式写 stdout，工具 / 重试 / 压缩一行提示）。[B6]
+ * 选择器在行式界面里退化为列出候选、提示带参数重发。
+ */
+import { THINKING_LEVELS } from "../../../ai/thinking.js";
+import { listSessions } from "../../../cli/compose-store.js";
+import { PERMISSION_MODES_STRICT_FIRST } from "../../../permissions/types.js";
+import { cacheEventNotice, warmSentNotice } from "../../session-report.js";
+const SUMMARY_KEYS = ["command", "path", "pattern", "file_path", "url", "description", "name"];
+/** 工具参数的一行摘要（第一个常见字段，折叠换行、截到 80 字符）。 */
+export function argsSummary(args) {
+    if (typeof args !== "object" || args === null)
+        return "";
+    const record = args;
+    for (const key of SUMMARY_KEYS) {
+        const value = record[key];
+        if (typeof value === "string" && value !== "") {
+            const flat = value.replace(/\s*\n\s*/g, " ⏎ ");
+            return flat.length > 80 ? `${flat.slice(0, 79)}…` : flat;
+        }
+    }
+    return "";
+}
+export function approvalQuestion(request) {
+    const task = (request.context?.depth ?? 0) > 0 ? "[task] " : "";
+    const summary = argsSummary(request.input);
+    const why = request.reason === "dangerous"
+        ? "（危险命令）"
+        : request.hookReason !== undefined
+            ? `（${request.hookReason}）`
+            : "";
+    return `${task}允许 ${request.toolName}${summary !== "" ? ` ${summary}` : ""}${why}？[y 允许 / a 本会话都允许 / N 拒绝] `;
+}
+/** `AMA_LOG=info|debug`。 */
+export function logsInfo(env) {
+    return env["AMA_LOG"] === "info" || env["AMA_LOG"] === "debug";
+}
+export class EventPrinter {
+    out;
+    err;
+    options;
+    midLine = false;
+    constructor(out, err, options = {}) {
+        this.out = out;
+        this.err = err;
+        this.options = options;
+    }
+    line(text, toErr = false) {
+        if (this.midLine) {
+            this.out("\n");
+            this.midLine = false;
+        }
+        (toErr ? this.err : this.out)(`${text}\n`);
+    }
+    /** 收尾：保证光标在行首。 */
+    endLine() {
+        if (this.midLine)
+            this.out("\n");
+        this.midLine = false;
+    }
+    handle(event) {
+        switch (event.type) {
+            case "message_update": {
+                const e = event.assistantMessageEvent;
+                if (e.type === "text_delta" && e.delta !== "") {
+                    this.out(e.delta);
+                    this.midLine = !e.delta.endsWith("\n");
+                }
+                return;
+            }
+            case "message_end":
+                if (event.message.role === "assistant") {
+                    this.endLine();
+                    if (event.message.stopReason === "error")
+                        this.line(`ama: 错误：${event.message.errorMessage ?? "模型调用失败"}`, true);
+                }
+                return;
+            case "tool_execution_start": {
+                const summary = argsSummary(event.args);
+                this.line(`● ${event.toolName}${summary !== "" ? `  ${summary}` : ""}`);
+                return;
+            }
+            case "tool_execution_end":
+                if (event.isError) {
+                    const content = event.result.content;
+                    const text = typeof content === "string"
+                        ? content
+                        : content.map((b) => (b.type === "text" ? b.text : "")).join("");
+                    this.line(`  ✗ ${text.split("\n")[0]?.slice(0, 200) ?? ""}`);
+                }
+                return;
+            case "auto_retry_start":
+                this.line(`↻ 重试 ${event.attempt}/${event.maxAttempts}（${Math.round(event.delayMs / 1000)}s）：${event.errorMessage}`, true);
+                return;
+            case "compaction_start":
+                this.line("… 压缩上下文", true);
+                return;
+            case "compaction_end":
+                if (event.error !== undefined)
+                    this.line(`压缩失败：${event.error}`, true);
+                return;
+            case "cache_miss":
+            case "context_pressure": {
+                const shown = cacheEventNotice(event, this.options.missNotices?.() ?? true);
+                if (shown !== undefined)
+                    this.line(`ama: ${shown.text}`, true);
+                return;
+            }
+            case "cache_warm": {
+                const text = this.options.info === true ? warmSentNotice(event) : undefined;
+                if (text !== undefined)
+                    this.line(`ama: ${text}`, true);
+                return;
+            }
+            case "agent_settled":
+                this.endLine();
+                if (event.warning !== undefined)
+                    this.line(`ama: ${event.warning}`, true);
+                return;
+            default:
+                return;
+        }
+    }
+}
+/** `pick` 在行式界面：列出候选，提示带参数重发。 */
+export async function pickHint(what, runtime, session) {
+    switch (what) {
+        case "model": {
+            const refs = [];
+            for (const provider of runtime.providers.list()) {
+                const key = await runtime.providers.resolveApiKey(provider.id);
+                if (provider.requiresApiKey && key.apiKey === undefined)
+                    continue;
+                for (const model of provider.models)
+                    refs.push(`  ${provider.id}/${model.id}`);
+            }
+            return ["可用模型（/model <provider/id>）：", ...refs.slice(0, 40)].join("\n");
+        }
+        case "session": {
+            const items = listSessions({ sessionDir: runtime.paths.sessionDir, cwd: session.state.cwd });
+            if (items.length === 0)
+                return "本目录没有会话";
+            return [
+                "最近的会话（/resume <id>）：",
+                ...items
+                    .slice(0, 15)
+                    .map((i) => `  ${i.id.slice(0, 8)}  ${i.modifiedAt.slice(0, 16).replace("T", " ")}  ${(i.name ?? i.firstPrompt ?? "").replace(/\s+/g, " ").slice(0, 50)}`),
+            ].join("\n");
+        }
+        case "tree": {
+            const users = session.entries.filter((e) => e.type === "message" && e.message.role === "user");
+            if (users.length === 0)
+                return "还没有可分叉的消息";
+            return [
+                "可分叉的位置（/fork <条目 id>）：",
+                ...users.slice(-15).map((e) => {
+                    const message = e.type === "message" ? e.message : undefined;
+                    const content = message?.role === "user" ? message.content : "";
+                    const text = typeof content === "string"
+                        ? content
+                        : content.map((b) => (b.type === "text" ? b.text : "")).join("");
+                    return `  ${e.id}  ${text.replace(/\s+/g, " ").slice(0, 60)}`;
+                }),
+            ].join("\n");
+        }
+        case "permission":
+            return `权限模式（/permission <模式>）：${PERMISSION_MODES_STRICT_FIRST.join(" | ")}；当前 ${session.state.permissionMode}`;
+        case "thinking":
+            return `思考级别（/thinking <级别>）：${THINKING_LEVELS.join(" | ")}；当前 ${session.state.thinkingLevel}`;
+    }
+}

package/dist/modes/interactive/line/paste-state.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 括号粘贴状态机（`ESC[200~ … ESC[201~`，设计 §11.2 / §12.3）：按字符流喂入，跨 chunk 识别起止标记，
+ * 产出普通输入与完整粘贴两类片段。与 tui/stdin-buffer.ts 独立实现（行式界面不依赖 TUI 组件库）。[B6]
+ *
+ * - 标记可能被拆在两个 chunk 之间：末尾若是标记的前缀，先留着等下一块；
+ * - 粘贴里的 `\r\n` / `\r` 统一成 `\n`；
+ * - `flush()`：输入暂停时把留着的前缀当普通输入交出（例如单独按下的 ESC）。
+ */
+export declare const PASTE_START = "\u001B[200~";
+export declare const PASTE_END = "\u001B[201~";
+export type InputPiece = {
+    kind: "text";
+    text: string;
+} | {
+    kind: "paste";
+    text: string;
+};
+export declare class PasteState {
+    private inPaste;
+    private pending;
+    private pasted;
+    get pasting(): boolean;
+    feed(chunk: string): InputPiece[];
+    /** 交出留着的标记前缀（粘贴中途则不动：等结束标记）。 */
+    flush(): InputPiece[];
+}

package/dist/modes/interactive/line/paste-state.js

@@ -0,0 +1,72 @@
+/**
+ * 括号粘贴状态机（`ESC[200~ … ESC[201~`，设计 §11.2 / §12.3）：按字符流喂入，跨 chunk 识别起止标记，
+ * 产出普通输入与完整粘贴两类片段。与 tui/stdin-buffer.ts 独立实现（行式界面不依赖 TUI 组件库）。[B6]
+ *
+ * - 标记可能被拆在两个 chunk 之间：末尾若是标记的前缀，先留着等下一块；
+ * - 粘贴里的 `\r\n` / `\r` 统一成 `\n`；
+ * - `flush()`：输入暂停时把留着的前缀当普通输入交出（例如单独按下的 ESC）。
+ */
+export const PASTE_START = "\x1b[200~";
+export const PASTE_END = "\x1b[201~";
+/** `text` 末尾与 `marker` 开头重合的最长长度（不含完整标记）。 */
+function partialSuffix(text, marker) {
+    for (let n = Math.min(marker.length - 1, text.length); n > 0; n--) {
+        if (text.endsWith(marker.slice(0, n)))
+            return n;
+    }
+    return 0;
+}
+export class PasteState {
+    inPaste = false;
+    pending = "";
+    pasted = "";
+    get pasting() {
+        return this.inPaste;
+    }
+    feed(chunk) {
+        const out = [];
+        let data = this.pending + chunk;
+        this.pending = "";
+        while (data.length > 0) {
+            if (!this.inPaste) {
+                const at = data.indexOf(PASTE_START);
+                if (at >= 0) {
+                    if (at > 0)
+                        out.push({ kind: "text", text: data.slice(0, at) });
+                    this.inPaste = true;
+                    this.pasted = "";
+                    data = data.slice(at + PASTE_START.length);
+                    continue;
+                }
+                const keep = partialSuffix(data, PASTE_START);
+                const text = data.slice(0, data.length - keep);
+                if (text !== "")
+                    out.push({ kind: "text", text });
+                this.pending = data.slice(data.length - keep);
+                break;
+            }
+            const end = data.indexOf(PASTE_END);
+            if (end >= 0) {
+                this.pasted += data.slice(0, end);
+                out.push({ kind: "paste", text: this.pasted.replace(/\r\n?/g, "\n") });
+                this.inPaste = false;
+                this.pasted = "";
+                data = data.slice(end + PASTE_END.length);
+                continue;
+            }
+            const keep = partialSuffix(data, PASTE_END);
+            this.pasted += data.slice(0, data.length - keep);
+            this.pending = data.slice(data.length - keep);
+            break;
+        }
+        return out;
+    }
+    /** 交出留着的标记前缀（粘贴中途则不动：等结束标记）。 */
+    flush() {
+        if (this.inPaste || this.pending === "")
+            return [];
+        const text = this.pending;
+        this.pending = "";
+        return [{ kind: "text", text }];
+    }
+}

package/dist/modes/interactive/message-view.d.ts

@@ -0,0 +1,77 @@
+/**
+ * 消息区（设计 §12.5）。[B7]
+ *
+ * 一个纵向 `Container`，块与块之间空一行：
+ * - 用户消息 `› 文本`；steer / followUp / 宿主注入按 `UserMessage.origin` 标 `↳ steer` / `↳ host` …；
+ * - 助手消息按内容块渲染：文本走 `Markdown`（`ui.markdown: false` 时纯文本），流式时只改末块
+ *   （Markdown 自己按块缓存）；思考块按 `ui.showThinking`：`collapsed`（缺省）一行 `思考 · N token`、
+ *   `full` 显示全文、`hidden` 不显示；
+ * - 压缩摘要卡、重试提示、Hook 阻止提示、宿主 / 系统通知；
+ * - `replay()` 把已有消息（恢复会话、切换会话、/tree 之后）重新画出来，工具调用交给调用方构造。
+ *
+ * 滚动交给终端回滚：消息区只追加，切换会话时整体清空重画。
+ */
+import type { AssistantMessage, ContentBlock, ToolCallBlock, UserMessage } from "../../ai/types.js";
+import type { CompactionResult, ToolResultMessage } from "../../agent/types.js";
+import type { AgentMessage } from "../../session/types.js";
+import { Container, type Component, type Theme } from "../../tui.js";
+export type ThinkingDisplay = "full" | "collapsed" | "hidden";
+export type NoticeLevel = "info" | "warn" | "error";
+export interface MessageViewOptions {
+    theme: Theme;
+    showThinking?: ThinkingDisplay;
+    /** false：助手文本不做 Markdown 渲染。 */
+    markdown?: boolean;
+}
+/** 粗估 token（4 字符 ≈ 1 token），只用于思考块的流式计数。 */
+export declare function estimateTokens(text: string): number;
+export declare function contentText(content: string | readonly ContentBlock[]): string;
+/** 一条助手消息：按内容块（思考 / 文本）同步子组件；工具调用块由 tool-view 单独显示。 */
+export declare class AssistantView extends Container {
+    private readonly options;
+    private readonly parts;
+    private readonly status;
+    private streaming;
+    constructor(options: MessageViewOptions);
+    update(message: AssistantMessage): void;
+    /** 收尾：错误 / 中断 / 长度截断提示，思考计数换成用量里的值。 */
+    finish(message: AssistantMessage): void;
+    get isEmpty(): boolean;
+    private part;
+}
+export interface ReplayHooks {
+    /** 工具调用块 + 配对的结果（可能缺）→ 组件；返回 undefined 不显示。 */
+    tool(call: ToolCallBlock, result: ToolResultMessage | undefined): Component | undefined;
+}
+export declare class MessageView extends Container {
+    private readonly options;
+    private current;
+    private readonly blocks;
+    constructor(options: MessageViewOptions);
+    private get theme();
+    /** 追加一块（与上一块之间空一行）。 */
+    add(component: Component): void;
+    /** 去掉一块（空的助手消息等）。 */
+    remove(component: Component): void;
+    reset(): void;
+    get blockCount(): number;
+    /** 启动画面：首行加粗，其余变暗。 */
+    addHeader(lines: readonly string[]): void;
+    addUser(message: Pick<UserMessage, "content" | "origin">): void;
+    startAssistant(message: AssistantMessage): AssistantView;
+    updateAssistant(message: AssistantMessage): void;
+    endAssistant(message: AssistantMessage): void;
+    addNotice(level: NoticeLevel, message: string): void;
+    addHookBlocked(reason: string): void;
+    addRetry(attempt: number, maxAttempts: number, delayMs: number, error: string): void;
+    addRetryFailed(error: string | undefined): void;
+    /** 压缩 / 分支摘要卡：token 变化（有则显示）+ 摘要前 3 行。 */
+    addSummaryCard(summary: string, options?: {
+        title?: string;
+        tokensBefore?: number;
+        tokensAfter?: number;
+    }): void;
+    addCompaction(result: Pick<CompactionResult, "summary" | "tokensBefore" | "tokensAfter">): void;
+    /** 把已有消息重新画出来。 */
+    replay(messages: readonly AgentMessage[], hooks: ReplayHooks): void;
+}

package/dist/modes/interactive/message-view.js

@@ -0,0 +1,269 @@
+/**
+ * 消息区（设计 §12.5）。[B7]
+ *
+ * 一个纵向 `Container`，块与块之间空一行：
+ * - 用户消息 `› 文本`；steer / followUp / 宿主注入按 `UserMessage.origin` 标 `↳ steer` / `↳ host` …；
+ * - 助手消息按内容块渲染：文本走 `Markdown`（`ui.markdown: false` 时纯文本），流式时只改末块
+ *   （Markdown 自己按块缓存）；思考块按 `ui.showThinking`：`collapsed`（缺省）一行 `思考 · N token`、
+ *   `full` 显示全文、`hidden` 不显示；
+ * - 压缩摘要卡、重试提示、Hook 阻止提示、宿主 / 系统通知；
+ * - `replay()` 把已有消息（恢复会话、切换会话、/tree 之后）重新画出来，工具调用交给调用方构造。
+ *
+ * 滚动交给终端回滚：消息区只追加，切换会话时整体清空重画。
+ */
+import { Box, Container, Markdown, Spacer, Text } from "../../tui.js";
+/** 粗估 token（4 字符 ≈ 1 token），只用于思考块的流式计数。 */
+export function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+export function contentText(content) {
+    if (typeof content === "string")
+        return content;
+    return content
+        .map((block) => (block.type === "text" ? block.text : block.type === "image" ? "[图片]" : ""))
+        .join("");
+}
+/** 一条助手消息：按内容块（思考 / 文本）同步子组件；工具调用块由 tool-view 单独显示。 */
+export class AssistantView extends Container {
+    options;
+    parts = new Map();
+    status = new Text("");
+    streaming = true;
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    update(message) {
+        const { theme } = this.options;
+        const display = this.options.showThinking ?? "collapsed";
+        const order = [];
+        message.content.forEach((block, index) => {
+            if (block.type === "toolCall")
+                return;
+            if (block.type === "thinking") {
+                if (display === "hidden" || (block.thinking === "" && block.redacted !== true))
+                    return;
+                const text = this.part(index, () => new Text(""));
+                if (display === "full" && block.redacted !== true) {
+                    text.setText(theme.fg("dim", theme.italic(block.thinking.trim())));
+                }
+                else {
+                    const single = message.content.filter((b) => b.type === "thinking").length === 1;
+                    const tokens = !this.streaming && single && message.usage.reasoning !== undefined
+                        ? message.usage.reasoning
+                        : estimateTokens(block.thinking);
+                    text.setText(theme.fg("dim", `${this.streaming ? "思考…" : "思考 ·"} ${tokens} token`));
+                }
+                order.push(text);
+                return;
+            }
+            if (block.text.trim() === "")
+                return;
+            const view = this.part(index, () => this.options.markdown === false ? new Text("") : new Markdown("", { theme }));
+            if (view.getText() !== block.text)
+                view.setText(block.text);
+            order.push(view);
+        });
+        this.clear();
+        order.forEach((child, i) => {
+            if (i > 0)
+                this.addChild(new Spacer());
+            this.addChild(child);
+        });
+        if (this.status.getText() !== "") {
+            if (order.length > 0)
+                this.addChild(new Spacer());
+            this.addChild(this.status);
+        }
+    }
+    /** 收尾：错误 / 中断 / 长度截断提示，思考计数换成用量里的值。 */
+    finish(message) {
+        this.streaming = false;
+        const { theme } = this.options;
+        if (message.stopReason === "error") {
+            this.status.setText(theme.fg("error", `✗ ${message.errorMessage ?? "模型调用失败"}`));
+        }
+        else if (message.stopReason === "aborted") {
+            this.status.setText(theme.fg("dim", "已中断"));
+        }
+        else if (message.stopReason === "length") {
+            this.status.setText(theme.fg("warning", "输出达到长度上限"));
+        }
+        this.update(message);
+    }
+    get isEmpty() {
+        return this.children.length === 0;
+    }
+    part(index, make) {
+        let part = this.parts.get(index);
+        if (part === undefined) {
+            part = make();
+            this.parts.set(index, part);
+        }
+        return part;
+    }
+}
+export class MessageView extends Container {
+    options;
+    current;
+    blocks = [];
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    get theme() {
+        return this.options.theme;
+    }
+    /** 追加一块（与上一块之间空一行）。 */
+    add(component) {
+        if (this.blocks.length > 0)
+            this.addChild(new Spacer());
+        this.blocks.push(component);
+        this.addChild(component);
+    }
+    /** 去掉一块（空的助手消息等）。 */
+    remove(component) {
+        const index = this.blocks.indexOf(component);
+        if (index === -1)
+            return;
+        this.blocks.splice(index, 1);
+        const at = this.children.indexOf(component);
+        if (at === -1)
+            return;
+        // 连同它前面（首块则是后面）的空行
+        if (at > 0 && this.children[at - 1] instanceof Spacer)
+            this.children.splice(at - 1, 2);
+        else if (this.children[at + 1] instanceof Spacer)
+            this.children.splice(at, 2);
+        else
+            this.children.splice(at, 1);
+    }
+    reset() {
+        this.clear();
+        this.blocks.length = 0;
+        this.current = undefined;
+    }
+    get blockCount() {
+        return this.blocks.length;
+    }
+    /** 启动画面：首行加粗，其余变暗。 */
+    addHeader(lines) {
+        if (lines.length === 0)
+            return;
+        const [first, ...rest] = lines;
+        const text = [this.theme.bold(first ?? ""), ...rest.map((l) => this.theme.fg("dim", l))];
+        this.add(new Text(text.join("\n")));
+    }
+    addUser(message) {
+        const text = contentText(message.content).replace(/\s+$/, "");
+        const origin = message.origin;
+        const label = origin === undefined || origin === "user"
+            ? this.theme.fg("user", "› ")
+            : this.theme.fg("dim", `↳ ${origin}  `);
+        this.add(new Text(label + text));
+    }
+    startAssistant(message) {
+        const view = new AssistantView(this.options);
+        view.update(message);
+        this.current = view;
+        this.add(view);
+        return view;
+    }
+    updateAssistant(message) {
+        if (this.current === undefined)
+            this.startAssistant(message);
+        else
+            this.current.update(message);
+    }
+    endAssistant(message) {
+        const view = this.current ?? this.startAssistant(message);
+        view.finish(message);
+        this.current = undefined;
+        // 只有工具调用的助手消息不占一块
+        if (view.isEmpty)
+            this.remove(view);
+    }
+    addNotice(level, message) {
+        const color = level === "error" ? "error" : level === "warn" ? "warning" : "dim";
+        const mark = level === "error" ? "✗ " : level === "warn" ? "! " : "";
+        this.add(new Text(this.theme.fg(color, mark + message)));
+    }
+    addHookBlocked(reason) {
+        this.add(new Text(this.theme.fg("warning", `⛔ Hook 阻止：${reason}`)));
+    }
+    addRetry(attempt, maxAttempts, delayMs, error) {
+        const seconds = Math.max(1, Math.round(delayMs / 1000));
+        this.add(new Text(this.theme.fg("warning", `↻ 重试 ${attempt}/${maxAttempts}（${seconds}s 后）：${error}`)));
+    }
+    addRetryFailed(error) {
+        this.addNotice("error", `重试失败${error !== undefined ? `：${error}` : ""}`);
+    }
+    /** 压缩 / 分支摘要卡：token 变化（有则显示）+ 摘要前 3 行。 */
+    addSummaryCard(summary, options = {}) {
+        const dim = (s) => this.theme.fg("dim", s);
+        const lines = summary
+            .trim()
+            .split("\n")
+            .filter((l) => l.trim() !== "");
+        const head = lines.slice(0, 3);
+        const body = [];
+        if (options.tokensBefore !== undefined) {
+            const after = options.tokensAfter !== undefined ? ` → ${options.tokensAfter}` : "";
+            body.push(dim(`${options.tokensBefore}${after} token`));
+        }
+        body.push(...head.map(dim));
+        if (lines.length > head.length)
+            body.push(dim(`…（另 ${lines.length - head.length} 行）`));
+        this.add(new Box(new Text(body.join("\n")), {
+            title: options.title ?? "上下文已压缩",
+            theme: this.theme,
+        }));
+    }
+    addCompaction(result) {
+        this.addSummaryCard(result.summary, {
+            tokensBefore: result.tokensBefore,
+            ...(result.tokensAfter !== undefined ? { tokensAfter: result.tokensAfter } : {}),
+        });
+    }
+    /** 把已有消息重新画出来。 */
+    replay(messages, hooks) {
+        const results = new Map();
+        for (const message of messages) {
+            if (message.role === "toolResult")
+                results.set(message.toolCallId, message);
+        }
+        for (const message of messages) {
+            switch (message.role) {
+                case "user":
+                    this.addUser(message);
+                    break;
+                case "assistant": {
+                    const view = new AssistantView(this.options);
+                    view.finish(message);
+                    if (!view.isEmpty)
+                        this.add(view);
+                    for (const block of message.content) {
+                        if (block.type !== "toolCall")
+                            continue;
+                        const tool = hooks.tool(block, results.get(block.id));
+                        if (tool !== undefined)
+                            this.add(tool);
+                    }
+                    break;
+                }
+                case "compactionSummary":
+                    this.addSummaryCard(message.summary, { tokensBefore: message.tokensBefore });
+                    break;
+                case "branchSummary":
+                    this.addSummaryCard(message.summary, { title: "分支摘要" });
+                    break;
+                case "custom":
+                    if (message.display)
+                        this.add(new Text(this.theme.fg("dim", contentText(message.content))));
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+}

package/dist/modes/interactive/pickers.d.ts

@@ -0,0 +1,42 @@
+/**
+ * 交互模式里的选择器（设计 §12.6）：居中覆盖层 + `SelectList`。[B7]
+ *
+ * - 模型：按供应商分组并标 key 状态（`modelItems`，与启动期共用），当前模型预选；
+ * - 会话：名字或首条提示、相对时间、消息数（`sessionItems`）；
+ * - 树：会话文件里全部用户消息，按分叉缩进，`●` 标出当前分支；选中项回填编辑器（由 commands.ts 处理）；
+ * - 权限模式（从严到宽）与思考级别。
+ */
+import type { SessionEntry } from "../../session/types.js";
+import { type Keybindings, type OverlayHandle, type OverlayOptions, type SelectItem, type Theme, type Component } from "../../tui.js";
+export { modelItems, sessionItems } from "./startup-ui.js";
+export interface PickerHost {
+    theme: Theme;
+    keybindings?: Keybindings;
+    showOverlay(component: Component, options: OverlayOptions): OverlayHandle;
+    /** 终端列数（决定覆盖层宽度）。 */
+    columns(): number;
+}
+export interface PickerSpec {
+    title: string;
+    items: readonly SelectItem[];
+    selected?: string;
+    filterable?: boolean;
+    maxVisible?: number;
+    emptyText?: string;
+}
+/** 打开一个居中选择器；Enter 返回选中项，Esc / Ctrl+C 返回 undefined。 */
+export declare function openPicker(host: PickerHost, spec: PickerSpec): Promise<SelectItem | undefined>;
+export declare function permissionItems(): SelectItem[];
+export declare function thinkingItems(reasoning: boolean): SelectItem[];
+export interface TreeNode {
+    entry: SessionEntry;
+    text: string;
+    children: TreeNode[];
+}
+/** 只保留用户消息的树：每条用户消息挂到最近的用户消息祖先下。 */
+export declare function userMessageTree(entries: readonly SessionEntry[]): TreeNode[];
+/**
+ * 树 → 列表项：分叉处子分支缩进一级，单链保持同级；`●` 在当前分支上、`○` 不在。
+ * value 是用户消息条目的 id。
+ */
+export declare function treeItems(entries: readonly SessionEntry[], activeIds: ReadonlySet<string>, now: number): SelectItem[];