@minko-ai/minko 0.1.0 → 0.1.1

package/dist/cli/tui.js

@@ -0,0 +1,1104 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { Painter, stripAnsi, truncateVisible, visibleWidth } from "../ui/ansi.js";
+import { Screen } from "../ui/screen.js";
+import { KeyParser } from "../ui/keyboard.js";
+import { InputModel, wrapInput } from "../ui/inputModel.js";
+import { highlightColumns, renderEntries, selectionByCells, selectionText, Viewport } from "../ui/transcript.js";
+import { copyToClipboard } from "../util/clipboard.js";
+import { bannerLines, compactBanner } from "../ui/banner.js";
+import { mascotFrames } from "../ui/mascot.js";
+import { StreamRenderer } from "../ui/md.js";
+import { runAgent } from "../agent/loop.js";
+import { compactHistory } from "../agent/compact.js";
+import { loadProjectContext } from "../agent/context.js";
+import { createSubagentTool } from "../agent/subagent.js";
+import { createPlanTools, renderTodos } from "../agent/plan.js";
+import { createMemoryTools, defaultMemoryDir, listMemoryIndex, loadMemoryContext, } from "../agent/memory.js";
+import { WorkerRegistry, createWorkerTools } from "../agent/workers.js";
+import { LaneRegistry, createLaneTools } from "../agent/lanes.js";
+import { TaskRegistry, createTaskTools } from "../agent/tasks.js";
+import { CronScheduler, createCronTools } from "../agent/cron.js";
+import { BranchLockStore, createBranchTools } from "../agent/branchLock.js";
+import { ApprovalTokenStore, createApprovalTools } from "../agent/approvalTokens.js";
+import { closeLspClients } from "../lsp/tool.js";
+import { loadPlugins, listPlugins, mergeHooks } from "../plugins/loader.js";
+import { listSkills } from "../skills/index.js";
+import { dockerAvailable, resolveSandbox } from "../sandbox/index.js";
+import { commandHelp, findCommand, parseSlash, suggestCommand } from "../commands/registry.js";
+import { buildStatus, formatStatusPlain } from "./statusCommand.js";
+import { sessionToMarkdown } from "./exportCommand.js";
+import { systemPrompt } from "../agent/prompt.js";
+import { ALL_TOOLS } from "../tools/registry.js";
+import { titleFromMessages } from "../session/store.js";
+import { TurnRecorder } from "../session/recorder.js";
+import { SessionHeartbeat } from "../session/liveness.js";
+import { loadConfig } from "../config/store.js";
+import { friendlyError } from "../util/errors.js";
+import { PURPLE } from "../theme.js";
+const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+/** Full-screen conversation UI: scrolling transcript above a fixed input box. */
+export class Tui {
+    screen = new Screen();
+    painter = new Painter();
+    parser = new KeyParser();
+    input = new InputModel();
+    viewport = new Viewport();
+    entries = [];
+    options;
+    provider;
+    model;
+    meta;
+    history;
+    running = null;
+    status = '';
+    statusStarted = 0;
+    spinnerFrame = 0;
+    approval = null;
+    copy = null;
+    selection = null;
+    expandDetails = false;
+    timer = null;
+    dirty = true;
+    closed = false;
+    finish = () => { };
+    agentTool;
+    planTools;
+    memoryDir = defaultMemoryDir();
+    memoryTools;
+    heartbeat;
+    workers;
+    workerTools;
+    lanes;
+    laneTools;
+    taskTools;
+    tasks;
+    crons;
+    cronTools;
+    branchTools;
+    approvals;
+    approvalTools;
+    pluginTools;
+    pluginErrors;
+    effectiveHooks;
+    usageTotals = { input: 0, output: 0, cached: 0 };
+    constructor(options) {
+        this.options = options;
+        this.provider = options.provider;
+        this.model = options.model;
+        this.meta = options.session.meta;
+        this.history = options.session.history;
+        this.agentTool = createSubagentTool({
+            getProvider: () => this.provider,
+            getConfig: () => this.options.config,
+        });
+        this.planTools = createPlanTools(this.meta);
+        this.memoryTools = createMemoryTools(this.memoryDir);
+        this.heartbeat = new SessionHeartbeat(this.options.store.dir, this.meta);
+        this.approvals = new ApprovalTokenStore();
+        this.workers = new WorkerRegistry({
+            getProvider: () => this.provider,
+            getConfig: () => this.options.config,
+            cwd: this.options.cwd,
+            approvalStore: this.approvals,
+            approve: async (request) => {
+                if (this.approval) {
+                    return false;
+                }
+                return await this.askApproval(request);
+            },
+        });
+        this.workerTools = createWorkerTools(this.workers);
+        const branchLocks = new BranchLockStore();
+        this.branchTools = createBranchTools(branchLocks);
+        this.lanes = new LaneRegistry({
+            getProvider: () => this.provider,
+            getConfig: () => this.options.config,
+            cwd: this.options.cwd,
+            lockStore: branchLocks,
+            approvalStore: this.approvals,
+            approve: async (request) => {
+                if (this.approval) {
+                    return false;
+                }
+                return await this.askApproval(request);
+            },
+        });
+        this.laneTools = createLaneTools(this.lanes);
+        this.tasks = new TaskRegistry({ workers: this.workers });
+        this.taskTools = createTaskTools(this.tasks);
+        this.crons = new CronScheduler({ workers: this.workers });
+        this.cronTools = createCronTools(this.crons);
+        this.approvalTools = createApprovalTools(this.approvals);
+        const pluginLoad = loadPlugins(undefined, options.config?.plugins.disabled ?? []);
+        this.pluginTools = pluginLoad.plugins.flatMap((plugin) => plugin.tools);
+        this.pluginErrors = pluginLoad.errors;
+        this.effectiveHooks = mergeHooks(options.config?.hooks ?? options.toolHooks, ...pluginLoad.plugins.map((plugin) => plugin.hooks));
+    }
+    async run() {
+        this.screen.enter();
+        this.heartbeat.start();
+        this.crons.start();
+        this.pushBanner();
+        for (const error of this.pluginErrors) {
+            this.entries.push({ kind: 'stats', text: '插件加载失败：' + error });
+        }
+        if (this.options.store.fallback) {
+            this.entries.push({
+                kind: 'stats',
+                text: '主目录不可写，会话改存到 ' + this.options.store.dir,
+            });
+        }
+        this.attachInput();
+        this.timer = setInterval(() => this.tick(), 80);
+        this.render();
+        const promise = new Promise((resolve) => { this.finish = resolve; });
+        if (this.options.initialPrompt && this.options.initialPrompt.trim().length > 0) {
+            this.submitText(this.options.initialPrompt.trim());
+        }
+        return await promise;
+    }
+    pushBanner() {
+        const info = {
+            model: this.model,
+            cwd: this.options.cwd,
+            session: this.meta.id,
+            continued: this.history.length > 0,
+            version: this.options.version,
+        };
+        const rows = this.screen.rows;
+        if (rows < 12) {
+            this.entries.push({ kind: 'banner', text: compactBanner(this.painter, info).join('\n') });
+            return;
+        }
+        const frames = rows < 18 || process.env.MINKO_MASCOT === '0'
+            ? []
+            : mascotFrames(this.painter);
+        const lines = bannerLines(this.painter, info, frames.length > 0 ? frames[0] : null);
+        // Breathing room between the mascot and the conversation below it.
+        this.entries.push({ kind: 'banner', text: [...lines, '', ''].join('\n') });
+    }
+    attachInput() {
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+        }
+        process.stdin.resume();
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (chunk) => {
+            for (const key of this.parser.push(chunk)) {
+                this.handleKey(key);
+            }
+        });
+        process.stdout.on('resize', () => { this.dirty = true; });
+    }
+    detachInput() {
+        process.stdin.removeAllListeners('data');
+        process.stdout.removeAllListeners('resize');
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(false);
+        }
+        process.stdin.pause();
+    }
+    close(code) {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        this.heartbeat.stop();
+        this.crons.stop();
+        this.workers.stopAll();
+        this.lanes.closeAll();
+        void closeLspClients();
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        this.detachInput();
+        this.screen.leave();
+        this.finish(code);
+    }
+    tick() {
+        this.spinnerFrame = (this.spinnerFrame + 1) % SPINNER.length;
+        if (this.running || this.approval || this.dirty) {
+            this.dirty = false;
+            this.render();
+        }
+    }
+    push(entry) {
+        this.entries.push(entry);
+        if (!this.viewport.atBottom) {
+            this.viewport.scroll += 1;
+        }
+        this.dirty = true;
+    }
+    handleKey(key) {
+        if (key.type === 'mouse') {
+            this.handleMouse(key);
+            return;
+        }
+        if (this.approval) {
+            this.handleApprovalKey(key);
+            return;
+        }
+        if (this.copy) {
+            this.handleCopyKey(key);
+            return;
+        }
+        switch (key.type) {
+            case 'ctrl':
+                if (key.key === 'c') {
+                    if (this.selection) {
+                        this.copySelectionCells();
+                        return;
+                    }
+                    if (this.running) {
+                        this.running.abort();
+                    }
+                    else if (!this.input.empty) {
+                        this.input.clear();
+                        this.dirty = true;
+                    }
+                    else {
+                        this.close(0);
+                    }
+                    return;
+                }
+                if (key.key === 'g') {
+                    this.startCopy();
+                    return;
+                }
+                if (key.key === 'd') {
+                    if (this.input.empty) {
+                        this.close(0);
+                    }
+                    return;
+                }
+                if (key.key === 'a') {
+                    this.input.home();
+                    this.dirty = true;
+                    return;
+                }
+                if (key.key === 'e') {
+                    this.input.end();
+                    this.dirty = true;
+                    return;
+                }
+                if (key.key === 'u') {
+                    this.input.clear();
+                    this.dirty = true;
+                    return;
+                }
+                if (key.key === 'o') {
+                    this.expandDetails = !this.expandDetails;
+                    this.dirty = true;
+                    return;
+                }
+                return;
+            case 'enter':
+                this.submit();
+                return;
+            case 'backspace':
+                this.input.backspace();
+                this.dirty = true;
+                return;
+            case 'delete':
+                this.input.deleteForward();
+                this.dirty = true;
+                return;
+            case 'left':
+                this.input.move(-1);
+                this.dirty = true;
+                return;
+            case 'right':
+                this.input.move(1);
+                this.dirty = true;
+                return;
+            case 'home':
+                this.input.home();
+                this.dirty = true;
+                return;
+            case 'end':
+                this.input.end();
+                this.dirty = true;
+                return;
+            case 'up':
+                this.input.previous();
+                this.dirty = true;
+                return;
+            case 'down':
+                this.input.next();
+                this.dirty = true;
+                return;
+            case 'pageup':
+                this.viewport.scrollBy(this.viewportHeight(), this.totalLines(), this.viewportHeight());
+                this.dirty = true;
+                return;
+            case 'pagedown':
+                this.viewport.scrollBy(-this.viewportHeight(), this.totalLines(), this.viewportHeight());
+                this.dirty = true;
+                return;
+            case 'wheel':
+                this.viewport.scrollBy(key.delta, this.totalLines(), this.viewportHeight());
+                this.dirty = true;
+                return;
+            case 'paste':
+                this.input.insert(key.text.replace(/\r?\n/g, ' '));
+                this.dirty = true;
+                return;
+            case 'text':
+                this.input.insert(key.text);
+                this.dirty = true;
+                return;
+            default:
+                return;
+        }
+    }
+    handleMouse(key) {
+        const total = this.totalLines();
+        if (total === 0) {
+            return;
+        }
+        const height = this.viewportHeight();
+        const start = Math.max(0, total - height - this.viewport.scroll);
+        const line = Math.max(0, Math.min(total - 1, start + key.row - 1));
+        const col = Math.max(0, key.col - 1);
+        if (key.kind === 'down') {
+            this.copy = null;
+            this.selection = { anchor: { line, col }, cursor: { line, col }, dragging: true };
+            this.dirty = true;
+            return;
+        }
+        if (key.kind === 'drag' && this.selection) {
+            this.selection.cursor = { line, col };
+            this.dirty = true;
+            return;
+        }
+        if (key.kind === 'up' && this.selection) {
+            // Windows convention: selecting is not copying. Keep the selection until
+            // the user presses Ctrl+C.
+            this.selection.dragging = false;
+            this.dirty = true;
+        }
+    }
+    selectionRangeFor(absolute) {
+        if (!this.selection) {
+            return null;
+        }
+        const a = this.selection.anchor;
+        const b = this.selection.cursor;
+        const startLine = Math.min(a.line, b.line);
+        const endLine = Math.max(a.line, b.line);
+        if (absolute < startLine || absolute > endLine) {
+            return null;
+        }
+        const first = a.line <= b.line ? a : b;
+        const last = a.line <= b.line ? b : a;
+        const from = absolute === first.line ? first.col : 0;
+        const to = absolute === last.line ? last.col : Number.MAX_SAFE_INTEGER;
+        return [from, to];
+    }
+    copySelectionCells() {
+        if (!this.selection) {
+            return;
+        }
+        const { anchor, cursor } = this.selection;
+        this.selection = null;
+        const lines = renderEntries(this.entries, this.screen.columns - 2, this.painter, this.spinnerFrame, this.expandDetails);
+        const text = selectionByCells(lines, anchor, cursor);
+        if (text.trim().length > 0) {
+            copyToClipboard(text);
+        }
+        this.dirty = true;
+    }
+    startCopy() {
+        const total = this.totalLines();
+        this.copy = { cursor: Math.max(0, total - 1), anchor: null };
+        this.dirty = true;
+    }
+    handleCopyKey(key) {
+        if (!this.copy) {
+            return;
+        }
+        const total = this.totalLines();
+        switch (key.type) {
+            case 'escape':
+                this.copy = null;
+                this.dirty = true;
+                return;
+            case 'ctrl':
+                if (key.key === 'c' || key.key === 'g') {
+                    this.copy = null;
+                    this.dirty = true;
+                }
+                return;
+            case 'enter':
+                this.copySelection();
+                return;
+            case 'up':
+                this.copy.cursor = Math.max(0, this.copy.cursor - 1);
+                this.dirty = true;
+                return;
+            case 'down':
+                this.copy.cursor = Math.min(Math.max(0, total - 1), this.copy.cursor + 1);
+                this.dirty = true;
+                return;
+            case 'pageup':
+                this.copy.cursor = Math.max(0, this.copy.cursor - this.viewportHeight());
+                this.dirty = true;
+                return;
+            case 'pagedown':
+                this.copy.cursor = Math.min(Math.max(0, total - 1), this.copy.cursor + this.viewportHeight());
+                this.dirty = true;
+                return;
+            case 'home':
+                this.copy.cursor = 0;
+                this.dirty = true;
+                return;
+            case 'end':
+                this.copy.cursor = Math.max(0, total - 1);
+                this.dirty = true;
+                return;
+            case 'text':
+                if (key.text.trim() === '') {
+                    this.copy.anchor = this.copy.anchor === null ? this.copy.cursor : null;
+                    this.dirty = true;
+                }
+                return;
+            default:
+                return;
+        }
+    }
+    copySelection() {
+        if (!this.copy) {
+            return;
+        }
+        const lines = renderEntries(this.entries, this.screen.columns - 2, this.painter, this.spinnerFrame, this.expandDetails);
+        const anchor = this.copy.anchor ?? this.copy.cursor;
+        const text = selectionText(lines, anchor, this.copy.cursor);
+        this.copy = null;
+        if (text.trim().length > 0) {
+            copyToClipboard(text);
+        }
+        this.dirty = true;
+    }
+    isSelected(index) {
+        if (!this.copy) {
+            return false;
+        }
+        const anchor = this.copy.anchor ?? this.copy.cursor;
+        return index >= Math.min(anchor, this.copy.cursor) && index <= Math.max(anchor, this.copy.cursor);
+    }
+    ensureCopyVisible(height, total) {
+        if (!this.copy) {
+            return;
+        }
+        const start = Math.max(0, total - height - this.viewport.scroll);
+        const end = start + height - 1;
+        if (this.copy.cursor < start) {
+            this.viewport.scroll = Math.max(0, total - height - this.copy.cursor);
+        }
+        else if (this.copy.cursor > end) {
+            this.viewport.scroll = Math.max(0, total - height - (this.copy.cursor - height + 1));
+        }
+    }
+    handleApprovalKey(key) {
+        const approval = this.approval;
+        if (!approval) {
+            return;
+        }
+        const entry = approval.entry;
+        const answer = (allowed) => {
+            this.approval = null;
+            this.heartbeat.setStatus('running');
+            entry.state = allowed ? 'allowed' : 'denied';
+            this.dirty = true;
+            approval.resolve(allowed);
+        };
+        if (key.type === 'escape') {
+            answer(false);
+            return;
+        }
+        if (key.type === 'ctrl' && key.key === 'c') {
+            answer(false);
+            return;
+        }
+        if (key.type === 'up') {
+            entry.choice = Math.max(0, entry.choice - 1);
+            this.dirty = true;
+            return;
+        }
+        if (key.type === 'down') {
+            entry.choice = Math.min(2, entry.choice + 1);
+            this.dirty = true;
+            return;
+        }
+        if (key.type === 'enter') {
+            answer(entry.choice !== 2);
+            return;
+        }
+        if (key.type !== 'text') {
+            return;
+        }
+        const text = key.text.trim().toLowerCase();
+        if (text === '1') {
+            entry.choice = 0;
+            answer(true);
+            return;
+        }
+        if (text === '2' || text === 'a') {
+            entry.choice = 1;
+            answer(true);
+            return;
+        }
+        if (text === '3' || text === 'n') {
+            entry.choice = 2;
+            answer(false);
+            return;
+        }
+        if (text === 'y') {
+            answer(true);
+        }
+    }
+    submit() {
+        if (this.running) {
+            return;
+        }
+        const text = this.input.text.trim();
+        if (text.length === 0) {
+            return;
+        }
+        this.input.remember();
+        this.input.clear();
+        this.submitText(text);
+    }
+    submitText(text) {
+        this.viewport.scroll = 0;
+        this.push({ kind: 'user', text });
+        if (text.startsWith('/')) {
+            this.command(text);
+            return;
+        }
+        void this.runTurn(text);
+    }
+    command(text) {
+        const parsed = parseSlash(text);
+        if (!parsed) {
+            return;
+        }
+        const definition = findCommand(parsed.name);
+        if (!definition) {
+            const suggestion = suggestCommand(parsed.name);
+            this.push({
+                kind: 'stats',
+                text: '未知命令 /' + parsed.name
+                    + (suggestion ? '，你是想 /' + suggestion + ' 吗？' : '，试试 /help'),
+            });
+            return;
+        }
+        const name = definition.name;
+        const argument = parsed.argument;
+        switch (name) {
+            case 'exit':
+                this.close(0);
+                return;
+            case 'help':
+                this.push({ kind: 'banner', text: commandHelp() });
+                return;
+            case 'new':
+                this.meta = this.options.store.create(this.options.cwd, this.model);
+                this.history = [];
+                this.planTools = createPlanTools(this.meta);
+                this.heartbeat.retarget(this.meta);
+                this.push({ kind: 'stats', text: '新会话 ' + this.meta.id });
+                return;
+            case 'clear':
+                this.history = [];
+                this.options.store.save(this.meta, this.history);
+                this.push({ kind: 'stats', text: '上下文已清空' });
+                return;
+            case 'compact': {
+                const preserve = /^\d+$/.test(argument)
+                    ? Math.min(Math.max(Number(argument), 0), 50)
+                    : 4;
+                const result = compactHistory(this.history, preserve);
+                if (result.removed === 0) {
+                    this.push({
+                        kind: 'stats',
+                        text: '没有需要压缩的内容（约 ' + formatTokens(result.before) + ' token）',
+                    });
+                    return;
+                }
+                this.history = result.history;
+                this.options.store.save(this.meta, this.history);
+                this.push({
+                    kind: 'stats',
+                    text: '已压缩 ' + result.removed + ' 条较早消息 · 约 '
+                        + formatTokens(result.before) + ' → ' + formatTokens(result.after) + ' token',
+                });
+                return;
+            }
+            case 'plan': {
+                this.meta.planMode = !this.meta.planMode;
+                this.options.store.save(this.meta, this.history);
+                this.push({
+                    kind: 'stats',
+                    text: this.meta.planMode
+                        ? '已进入计划模式：只能只读调查，提交计划后才能动手'
+                        : '已退出计划模式',
+                });
+                return;
+            }
+            case 'todos': {
+                this.push({
+                    kind: 'banner',
+                    text: '待办清单\n' + renderTodos(this.meta.todos ?? []),
+                });
+                return;
+            }
+            case 'fork': {
+                this.options.store.save(this.meta, this.history);
+                const forked = this.options.store.fork(this.meta.id, argument || undefined);
+                if (!forked) {
+                    this.push({ kind: 'stats', text: '创建分支失败：找不到当前会话' });
+                    return;
+                }
+                this.meta = forked.meta;
+                this.history = forked.messages;
+                this.planTools = createPlanTools(this.meta);
+                this.heartbeat.retarget(this.meta);
+                this.options.store.save(this.meta, this.history);
+                this.push({
+                    kind: 'stats',
+                    text: '已创建分支 ' + this.meta.id + '（来自 ' + forked.meta.forkedFrom + '）',
+                });
+                return;
+            }
+            case 'cwd':
+                this.push({ kind: 'stats', text: this.options.cwd });
+                return;
+            case 'model':
+                if (argument.length === 0) {
+                    this.push({ kind: 'stats', text: '当前模型：' + this.model });
+                    return;
+                }
+                try {
+                    this.provider = this.options.setModel(argument);
+                    this.model = argument;
+                    this.push({ kind: 'stats', text: '已切换到 ' + argument });
+                }
+                catch (error) {
+                    this.push({ kind: 'stats', text: friendlyError(error) });
+                }
+                return;
+            case 'sessions': {
+                const metas = this.options.store.list().slice(0, 10);
+                const lines = metas.map((meta) => '  ' + (meta.id === this.meta.id ? '● ' : '○ ')
+                    + meta.id + '  ' + meta.title);
+                this.push({ kind: 'banner', text: lines.length > 0 ? lines.join('\n') : '  还没有保存的会话' });
+                return;
+            }
+            case 'status': {
+                try {
+                    const config = this.options.config ?? loadConfig();
+                    const report = buildStatus(config, this.options.store, {
+                        version: this.options.version,
+                    });
+                    this.push({ kind: 'banner', text: formatStatusPlain(report) });
+                }
+                catch (error) {
+                    this.push({ kind: 'stats', text: friendlyError(error) });
+                }
+                return;
+            }
+            case 'usage': {
+                const cached = this.usageTotals.cached > 0
+                    ? '（缓存 ' + formatTokens(this.usageTotals.cached) + '）'
+                    : '';
+                this.push({
+                    kind: 'stats',
+                    text: '本会话：' + formatTokens(this.usageTotals.input) + ' 入' + cached
+                        + ' / ' + formatTokens(this.usageTotals.output) + ' 出',
+                });
+                return;
+            }
+            case 'workers': {
+                const workers = this.workers.list();
+                this.push({
+                    kind: 'banner',
+                    text: workers.length === 0 ? '没有 worker。' : workers
+                        .map((worker) => worker.id + ' [' + worker.state + '] ' + worker.name).join('\n'),
+                });
+                return;
+            }
+            case 'tasks': {
+                const tasks = this.tasks.list();
+                this.push({
+                    kind: 'banner',
+                    text: tasks.length === 0 ? '任务板为空。' : tasks
+                        .map((task) => task.id + ' [' + task.status + '] ' + task.title).join('\n'),
+                });
+                return;
+            }
+            case 'crons': {
+                const crons = this.crons.getStore().list();
+                this.push({
+                    kind: 'banner',
+                    text: crons.length === 0 ? '还没有 cron。' : crons
+                        .map((cron) => cron.id + ' [' + (cron.enabled ? '启用' : '停用') + '] '
+                        + cron.name + ' · 每 ' + cron.everyMinutes + ' 分钟').join('\n'),
+                });
+                return;
+            }
+            case 'lanes': {
+                const lanes = this.lanes.list();
+                this.push({
+                    kind: 'banner',
+                    text: lanes.length === 0 ? '还没有 lane。' : lanes
+                        .map((lane) => lane.id + ' [' + lane.state + '] ' + lane.name + ' · ' + lane.branch)
+                        .join('\n'),
+                });
+                return;
+            }
+            case 'approvals': {
+                const tokens = this.approvals.list();
+                this.push({
+                    kind: 'banner',
+                    text: tokens.length === 0 ? '没有审批令牌。' : tokens
+                        .map((token) => token.id + ' · ' + token.tool
+                        + (token.pattern ? '(' + token.pattern + ')' : '')
+                        + ' · ' + token.uses + '/' + token.maxUses + ' · ' + token.expiresAt)
+                        .join('\n'),
+                });
+                return;
+            }
+            case 'plugins': {
+                const config = this.options.config ?? loadConfig();
+                const result = listPlugins(undefined, config.plugins.disabled);
+                const lines = result.plugins.map((plugin) => plugin.name
+                    + (plugin.enabled ? ' [启用]' : ' [停用]') + ' · ' + plugin.toolCount + ' 个工具');
+                if (result.errors.length > 0) {
+                    lines.push('错误：' + result.errors.join('；'));
+                }
+                this.push({
+                    kind: 'banner',
+                    text: lines.length === 0 ? '还没有安装插件。' : lines.join('\n'),
+                });
+                return;
+            }
+            case 'skills': {
+                const skills = listSkills(this.options.cwd);
+                this.push({
+                    kind: 'banner',
+                    text: skills.length === 0 ? '没有技能包。' : skills
+                        .map((skill) => skill.name + ' — ' + skill.description + '（' + skill.source + '）')
+                        .join('\n'),
+                });
+                return;
+            }
+            case 'memory': {
+                const index = listMemoryIndex(this.memoryDir);
+                this.push({ kind: 'banner', text: index.length === 0 ? '长期记忆为空。' : index });
+                return;
+            }
+            case 'sandbox': {
+                const sandbox = resolveSandbox(this.options.config);
+                const docker = dockerAvailable();
+                this.push({
+                    kind: 'banner',
+                    text: 'sandbox: ' + (sandbox
+                        ? 'docker · ' + sandbox.image + ' · network ' + (sandbox.network ? '允许' : '禁止')
+                        : 'off')
+                        + '\ndocker: ' + (docker ? '可用' : '不可用'),
+                });
+                return;
+            }
+            case 'export': {
+                const target = path.resolve(this.options.cwd, argument || 'minko-' + this.meta.id + '.md');
+                try {
+                    fs.writeFileSync(target, sessionToMarkdown({
+                        meta: this.meta,
+                        messages: this.history,
+                    }), 'utf8');
+                    this.push({ kind: 'stats', text: '已导出到 ' + target });
+                }
+                catch (error) {
+                    this.push({
+                        kind: 'stats',
+                        text: '导出失败：' + (error instanceof Error ? error.message : String(error)),
+                    });
+                }
+                return;
+            }
+            default:
+                this.push({ kind: 'stats', text: '未知命令 /' + name + '，试试 /help' });
+        }
+    }
+    async runTurn(text) {
+        this.history.push({ role: 'user', content: text });
+        this.meta.title = titleFromMessages(this.history);
+        this.heartbeat.setStatus('running');
+        const recorder = new TurnRecorder(this.options.store, this.meta, this.history);
+        const controller = new AbortController();
+        this.running = controller;
+        this.status = '思考中';
+        this.statusStarted = Date.now();
+        let assistantEntry = null;
+        let reasoningEntry = null;
+        let currentTool = null;
+        const started = Date.now();
+        // Text starts a new bubble after every tool round, so answers and tool calls
+        // keep the order they arrived in instead of all text collecting at the top.
+        const ensureAssistant = () => {
+            if (assistantEntry === null) {
+                assistantEntry = { kind: 'assistant', text: '' };
+                this.entries.push(assistantEntry);
+            }
+            return assistantEntry;
+        };
+        const finishReasoning = () => {
+            if (reasoningEntry === null) {
+                return;
+            }
+            reasoningEntry.done = true;
+            reasoningEntry.ms = Math.max(0, Date.now() - reasoningEntry.started);
+            reasoningEntry = null;
+            this.dirty = true;
+        };
+        const hooks = {
+            onText: (delta) => {
+                finishReasoning();
+                ensureAssistant().text += delta;
+                if (this.status === '思考中') {
+                    this.status = '';
+                }
+                if (!this.viewport.atBottom) {
+                    return;
+                }
+                this.dirty = true;
+            },
+            onReasoning: (delta) => {
+                if (reasoningEntry === null) {
+                    reasoningEntry = {
+                        kind: 'reasoning',
+                        text: '',
+                        started: Date.now(),
+                        ms: 0,
+                        done: false,
+                    };
+                    this.entries.push(reasoningEntry);
+                }
+                reasoningEntry.text += delta;
+                if (this.status === '思考中') {
+                    this.status = '';
+                }
+                this.dirty = true;
+            },
+            onToolStart: (call) => {
+                finishReasoning();
+                assistantEntry = null;
+                currentTool = {
+                    kind: 'tool',
+                    name: call.name,
+                    args: describeArguments(call.arguments),
+                    started: Date.now(),
+                    status: 'running',
+                    ms: 0,
+                    output: '',
+                };
+                this.status = '';
+                this.push(currentTool);
+            },
+            onToolEnd: (_call, result) => {
+                if (currentTool) {
+                    currentTool.status = result.ok ? 'ok' : 'error';
+                    currentTool.ms = result.ms;
+                    currentTool.output = result.output;
+                    currentTool = null;
+                }
+                this.dirty = true;
+            },
+            approve: (request) => this.askApproval(request),
+            onNotice: (text) => this.push({ kind: 'stats', text }),
+            onAssistantMessage: (message) => recorder.record(message),
+        };
+        try {
+            const outcome = await runAgent({
+                provider: this.provider,
+                tools: [
+                    ...ALL_TOOLS,
+                    ...this.options.mcpTools,
+                    ...this.planTools,
+                    ...this.memoryTools,
+                    ...this.workerTools,
+                    ...this.pluginTools,
+                    ...this.laneTools,
+                    ...this.taskTools,
+                    ...this.cronTools,
+                    ...this.branchTools,
+                    ...this.approvalTools,
+                    this.agentTool,
+                ],
+                messages: [{
+                        role: 'system',
+                        content: systemPrompt({
+                            cwd: this.options.cwd,
+                            project: loadProjectContext(this.options.cwd),
+                            planMode: this.meta.planMode,
+                            memory: loadMemoryContext(this.memoryDir),
+                        }),
+                    }, ...this.history],
+                cwd: this.options.cwd,
+                signal: controller.signal,
+                approval: this.options.auto ? 'auto' : 'ask',
+                power: this.options.power,
+                permissions: this.options.permissions,
+                toolHooks: this.effectiveHooks,
+                planState: this.meta,
+                config: this.options.config,
+                approvalStore: this.approvals,
+                hooks,
+            });
+            this.history = outcome.messages.filter((message) => message.role !== 'system');
+            this.meta.title = titleFromMessages(this.history);
+            recorder.commit(this.history);
+            const tokens = outcome.usage.input > 0 || outcome.usage.output > 0
+                ? ' · ' + formatTokens(outcome.usage.input) + ' 入'
+                    + (outcome.usage.cached ? '（缓存 ' + formatTokens(outcome.usage.cached) + '）' : '')
+                    + ' / ' + formatTokens(outcome.usage.output) + ' 出'
+                : '';
+            this.usageTotals.input += outcome.usage.input;
+            this.usageTotals.output += outcome.usage.output;
+            this.usageTotals.cached += outcome.usage.cached ?? 0;
+            this.push({ kind: 'stats', text: formatMs(Date.now() - started) + tokens });
+        }
+        catch (error) {
+            this.history = recorder.snapshot();
+            this.meta.title = titleFromMessages(this.history);
+            this.history = recorder.recover();
+            let message = error instanceof Error && error.name === 'AbortError'
+                ? '已中断'
+                : friendlyError(error);
+            if (/reasoning_content/i.test(message)) {
+                message += '  · 这个会话是旧版本建的，输入 /new 开新会话即可';
+            }
+            this.push({ kind: 'stats', text: message });
+        }
+        finally {
+            finishReasoning();
+            this.running = null;
+            this.status = '';
+            this.heartbeat.setStatus('idle');
+            this.dirty = true;
+        }
+    }
+    askApproval(request) {
+        this.heartbeat.setStatus('waiting_approval');
+        return new Promise((resolve) => {
+            const entry = {
+                kind: 'permission',
+                title: request.title,
+                detail: request.detail,
+                choice: 0,
+                state: 'pending',
+            };
+            this.push(entry);
+            this.approval = { request, resolve, entry };
+            this.dirty = true;
+        });
+    }
+    viewportHeight() {
+        const inputWidth = Math.max(8, this.screen.columns - 4);
+        const wrapped = wrapInput(this.input.text, this.input.cursor, inputWidth);
+        return Math.max(3, this.screen.rows - (wrapped.lines.length + 2) - 1);
+    }
+    totalLines() {
+        return renderEntries(this.entries, this.screen.columns - 2, this.painter, this.spinnerFrame, this.expandDetails).length;
+    }
+    render() {
+        const columns = this.screen.columns;
+        const rows = this.screen.rows;
+        const width = columns - 2;
+        const inputWidth = Math.max(8, columns - 4);
+        const wrapped = wrapInput(this.input.text, this.input.cursor, inputWidth);
+        const viewportHeight = Math.max(3, rows - (wrapped.lines.length + 2) - 1);
+        const all = renderEntries(this.entries, width, this.painter, this.spinnerFrame, this.expandDetails);
+        if (this.copy) {
+            this.ensureCopyVisible(viewportHeight, all.length);
+        }
+        const visible = this.viewport.visible(all, viewportHeight);
+        const start = Math.max(0, all.length - viewportHeight - this.viewport.scroll);
+        const frame = [];
+        for (let index = 0; index < viewportHeight; index += 1) {
+            const line = visible[index] ?? '';
+            const absolute = start + index;
+            const range = this.selectionRangeFor(absolute);
+            if (range) {
+                frame.push(highlightColumns(line, range[0], range[1]));
+            }
+            else if (this.copy && this.isSelected(absolute)) {
+                frame.push('\x1b[7m' + stripAnsi(line) + '\x1b[27m');
+            }
+            else {
+                frame.push(line);
+            }
+        }
+        const rule = this.painter.fg(PURPLE.border, '─'.repeat(Math.max(10, columns - 1)));
+        frame.push(this.statusLine(columns));
+        frame.push(rule);
+        for (let index = 0; index < wrapped.lines.length; index += 1) {
+            const lead = index === 0 ? this.painter.primary('› ') : '  ';
+            frame.push(lead + wrapped.lines[index]);
+        }
+        frame.push(rule);
+        const cursorRow = viewportHeight + 3 + wrapped.row;
+        const cursorColumn = 3 + wrapped.column;
+        this.screen.draw(frame, cursorRow, Math.min(cursorColumn, columns - 1));
+    }
+    statusLine(columns) {
+        if (this.copy) {
+            const anchor = this.copy.anchor;
+            const count = Math.abs((anchor ?? this.copy.cursor) - this.copy.cursor) + 1;
+            const hint = ' 选择模式 · ↑↓ 移动 · 空格 ' + (anchor === null ? '标记起点' : '取消标记')
+                + ' · Enter 复制 · Esc 取消 · ' + count + ' 行';
+            return this.painter.primary(truncateVisible(hint, columns - 2));
+        }
+        if (this.approval) {
+            return this.painter.dimmed('  在对话中按 y / a / n 处理确认');
+        }
+        if (!this.running) {
+            if (this.viewport.scroll > 0) {
+                return this.painter.dimmed('  已向上滚动 · PgDn 回到底部');
+            }
+            return '';
+        }
+        const seconds = Math.max(0, Math.round((Date.now() - this.statusStarted) / 1000));
+        const spinner = SPINNER[this.spinnerFrame];
+        return '  ' + this.painter.primary(spinner) + ' '
+            + this.painter.muted(this.status + (seconds > 0 ? '  ' + seconds + 's' : ''));
+    }
+}
+function describeArguments(raw) {
+    try {
+        const args = JSON.parse(raw);
+        if (typeof args.command === 'string') {
+            return args.command;
+        }
+        if (typeof args.path === 'string') {
+            return args.path;
+        }
+        return raw;
+    }
+    catch {
+        return raw;
+    }
+}
+function formatMs(ms) {
+    return ms < 1000 ? ms + 'ms' : (ms / 1000).toFixed(1) + 's';
+}
+function formatTokens(value) {
+    return value < 1000 ? String(value) : (value / 1000).toFixed(1) + 'k';
+}
+export async function runTui(options) {
+    const tui = new Tui(options);
+    return await tui.run();
+}