@qlingzzy/qling 1.0.0

package/dist/tui/streaming-tui.js

@@ -0,0 +1,1049 @@
+// ============================================================
+// streaming-tui.ts - Claude Code 风格流式 Agent CLI
+//
+// 架构原则：
+// 1. Header 只打印一次（启动时）
+// 2. 所有输出追加到终端历史，从不重绘
+// 3. 底部输入栏：› prompt，支持 Ctrl+N 插入多行、Ctrl+R 搜索历史
+// 4. Agent 执行期间输入栏保持可用
+// 5. 执行完毕后调用 showPrompt() 恢复 › prompt
+//
+// 事件输出（全部 append，不清屏）：
+// appendToolStart / appendToolSuccess / appendToolError
+// appendThinking / appendCogitated
+// appendValidation / appendRepair
+// appendFinal / appendError / appendState / appendDone
+// ============================================================
+import { default as stringWidth } from "string-width";
+import { findSlashCompletion, formatSlashCommandPanel, formatGroupedSlashPanel } from "../commands/index.js";
+import { InputBuffer } from "./input-buffer.js";
+import { formatProgressPulse } from "./progress.js";
+import { formatBottomHints, formatWelcomeGuide, formatRoleHeader, formatToolOutputCard, formatToolTimelineRow, formatTopBar, padVisible, truncateVisible, } from "./shell.js";
+import { formatMarkdownForTerminal } from "./markdown.js";
+import { getPackageVersion } from "../package-version.js";
+// ── ANSI 颜色工具 ───────────────────────────────────────
+function rgb(hex) {
+    const n = parseInt(hex.slice(1), 16);
+    return `${(n >> 16) & 255};${(n >> 8) & 255};${n & 255}`;
+}
+const C = {
+    p: "#36F5B5", // primary  竹青绿
+    s: "#75D7FF", // secondary 青蓝
+    d: "#8B949E", // dim 灰
+    b: "#E6EDF3", // bright 白
+    g: "#4ADE80", // green
+    r: "#FB7185", // red
+    y: "#FACC15", // yellow
+    m: "#E879F9", // magenta
+};
+const F = (color, s) => `\x1b[38;2;${rgb(color)}m${s}\x1b[0m`;
+const S = {
+    p: (s) => F(C.p, s),
+    s: (s) => F(C.s, s),
+    d: (s) => F(C.d, s),
+    b: (s) => F(C.b, s),
+    g: (s) => F(C.g, s),
+    r: (s) => F(C.r, s),
+    y: (s) => F(C.y, s),
+    m: (s) => F(C.m, s),
+};
+const DIM = (s) => `\x1b[2m${s}\x1b[0m`;
+const BOLD = (s) => `\x1b[1m${s}\x1b[0m`;
+// ── 显示宽度工具 ────────────────────────────────────────
+const sw = (s) => stringWidth(s);
+function trunc(s, maxW) {
+    if (sw(s) <= maxW)
+        return s;
+    let col = 0;
+    let i = 0;
+    while (i < s.length && col < maxW - 1) {
+        const cw = sw(s[i]);
+        if (col + cw > maxW - 1)
+            break;
+        col += cw;
+        i++;
+    }
+    return s.slice(0, i) + "…";
+}
+// ── Duration 格式化 ─────────────────────────────────────
+function fmtDur(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60_000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    const m = Math.floor(ms / 60_000);
+    const s = Math.floor((ms % 60_000) / 1000);
+    return `${m}m ${s}s`;
+}
+export class StreamUI {
+    model;
+    tools;
+    chromeStatus = {};
+    input = new InputBuffer();
+    running = false;
+    inputCallback = null;
+    currentToolRunning = false;
+    dataHandler = null;
+    resizeHandler = null;
+    statusLine = null;
+    statusLineEnabled = true;
+    progressTimer = null;
+    progressStartedAt = 0;
+    progressLabel = "agent";
+    lastEmptyCtrlCAt = 0;
+    lastClearedDraft = null;
+    lastClearedDraftDisplaySource = null;
+    draftDisplaySource = null;
+    expandLongToolOutput = false;
+    lastInputContentLineCount = 1;
+    lastInputCursorLineIndex = 0;
+    lastInputHintLineCount = 0;
+    slashCompletionSelectedIndex = 0;
+    inputCursorAnchor = "current";
+    inputStartRow = 0;
+    now;
+    doubleCtrlCExitWindowMs = 2_000;
+    constructor(model = "deepseek-chat", tools = 0, options = {}) {
+        this.model = model;
+        this.tools = tools;
+        this.now = options.now ?? (() => Date.now());
+    }
+    start() {
+        this.running = true;
+        this.printHeader();
+        this.printInputBar();
+        this.setupInput();
+    }
+    stop() {
+        this.running = false;
+        this.stopProgress();
+        if (this.dataHandler) {
+            process.stdin.off("data", this.dataHandler);
+            this.dataHandler = null;
+        }
+        if (this.resizeHandler) {
+            process.stdout.off("resize", this.resizeHandler);
+            this.resizeHandler = null;
+        }
+        if (typeof process.stdin.setRawMode === "function") {
+            process.stdin.setRawMode(false);
+        }
+        process.stdin.pause();
+        process.stdout.write("\n");
+    }
+    onInput(cb) {
+        this.inputCallback = cb;
+    }
+    setStatusLine(line) {
+        this.statusLine = line;
+    }
+    setStatusLineEnabled(enabled) {
+        this.statusLineEnabled = enabled;
+    }
+    setChromeStatus(status) {
+        this.chromeStatus = { ...this.chromeStatus, ...status };
+    }
+    setModel(model) {
+        const next = String(model ?? "").trim();
+        if (next)
+            this.model = next;
+    }
+    isExpandLongToolOutput() {
+        return this.expandLongToolOutput;
+    }
+    setExpandLongToolOutput(expanded) {
+        this.expandLongToolOutput = Boolean(expanded);
+    }
+    toggleExpandLongToolOutput() {
+        this.expandLongToolOutput = !this.expandLongToolOutput;
+        return this.expandLongToolOutput;
+    }
+    setHistory(entries) {
+        this.input.setHistory(entries);
+    }
+    startProgress(label = "agent", intervalMs = 10_000) {
+        this.stopProgress();
+        this.progressLabel = label.trim() || "agent";
+        this.progressStartedAt = Date.now();
+        const safeIntervalMs = Math.max(1_000, intervalMs);
+        this.progressTimer = setInterval(() => {
+            const elapsedMs = Date.now() - this.progressStartedAt;
+            process.stdout.write("\n" + DIM(formatProgressPulse(this.progressLabel, elapsedMs)));
+        }, safeIntervalMs);
+        this.progressTimer.unref?.();
+    }
+    stopProgress() {
+        if (!this.progressTimer)
+            return;
+        clearInterval(this.progressTimer);
+        this.progressTimer = null;
+    }
+    // ── Header（只调用一次） ───────────────────────────
+    printHeader() {
+        const width = process.stdout.columns || 120;
+        const lines = formatTopBar({
+            productName: "轻灵",
+            englishName: "Qling",
+            version: getPackageVersion(),
+            model: this.model,
+            workspace: this.chromeStatus.workspace ?? process.cwd(),
+            tokens: this.chromeStatus.tokens ?? 0,
+            branch: this.chromeStatus.branch ?? "-",
+            ready: this.chromeStatus.ready ?? true,
+            sessionMode: this.chromeStatus.sessionMode ?? "agent",
+            permissionMode: this.chromeStatus.permissionMode ?? "ask",
+            width,
+        });
+        // 批量写入减少闪烁
+        const chunks = [S.p(lines[0]) + "\n", S.d(lines[1]) + "\n"];
+        const homeSnap = {
+            model: this.model,
+            workspace: this.chromeStatus.workspace,
+            memoryStatus: this.chromeStatus.memoryStatus || "本地",
+            permissionMode: this.chromeStatus.permissionMode || "ask",
+            recentSessions: [],
+            width,
+        };
+        for (const line of formatWelcomeGuide(width, homeSnap)) {
+            chunks.push(DIM(line) + "\n");
+        }
+        process.stdout.write(chunks.join(""));
+    }
+    // ── 底部输入栏 ────────────────────────────────────
+    printPromptHint() {
+        const chunks = [];
+        if (this.statusLineEnabled && this.statusLine) {
+            chunks.push(DIM(this.statusLine) + "\n");
+        }
+        chunks.push(DIM(formatBottomHints()) + "\n");
+        process.stdout.write(chunks.join(""));
+    }
+    printInputBar() {
+        this.printPromptHint();
+        this.writeInputValue(true);
+        this.syncCursor();
+    }
+    backToPrompt() {
+        this.moveToInputContentStart();
+        process.stdout.write("\r");
+        process.stdout.write("\x1b[J");
+    }
+    redrawInput() {
+        this.backToPrompt();
+        this.writeInputValue();
+        this.syncCursor();
+    }
+    appendFeedbackAndRedraw(message, usePlaceholder = false) {
+        this.moveAfterInputFrame();
+        process.stdout.write("\n" + message + "\n");
+        this.writeInputValue(usePlaceholder);
+        this.syncCursor();
+    }
+    wrapInputVisualLines(value, width, cursor) {
+        if (width <= 0) {
+            return { lines: [value], cursorRow: 0, cursorCol: 0 };
+        }
+        const lines = [""];
+        let currentWidth = 0;
+        let cursorRow = 0;
+        let cursorCol = 0;
+        let charIndex = 0;
+        const chars = Array.from(value);
+        for (const ch of chars) {
+            if (charIndex === cursor) {
+                cursorRow = lines.length - 1;
+                cursorCol = currentWidth;
+            }
+            if (ch === "\n") {
+                lines.push("");
+                currentWidth = 0;
+                charIndex += 1;
+                continue;
+            }
+            const w = sw(ch);
+            if (currentWidth + w > width) {
+                lines.push("");
+                currentWidth = 0;
+            }
+            lines[lines.length - 1] += ch;
+            currentWidth += w;
+            charIndex += ch.length;
+        }
+        if (charIndex === cursor) {
+            cursorRow = lines.length - 1;
+            cursorCol = currentWidth;
+        }
+        return { lines, cursorRow, cursorCol };
+    }
+    formatByteSize(value) {
+        const bytes = Buffer.byteLength(value, "utf8");
+        if (bytes < 1024)
+            return `${bytes} B`;
+        const kb = bytes / 1024;
+        if (kb < 10)
+            return `${kb.toFixed(1)} KB`;
+        return `${Math.round(kb)} KB`;
+    }
+    countInputLines(value) {
+        if (!value)
+            return 0;
+        return value.split("\n").length;
+    }
+    shouldUseCompactDraft(value, wrappedLineCount, isPlaceholder) {
+        return !isPlaceholder && Boolean(value) && (value.includes("\n") || wrappedLineCount > 1);
+    }
+    formatDraftChip(value) {
+        const source = this.draftDisplaySource === "pasted" ? "pasted" : "typed";
+        const size = this.formatByteSize(value);
+        if (source === "pasted") {
+            const lines = this.countInputLines(value);
+            if (lines > 1) {
+                return `[Pasted: ${lines} lines]`;
+            }
+            return `[Pasted: ${size}]`;
+        }
+        return `[Draft: ${this.countInputLines(value)} lines, ${size}]`;
+    }
+    resetDraftDisplaySourceIfEmpty() {
+        if (!this.input.value) {
+            this.draftDisplaySource = null;
+        }
+    }
+    markPastedDraft() {
+        if (this.input.value) {
+            this.draftDisplaySource = "pasted";
+        }
+    }
+    formatInputFrameBorder(left, right, label, totalWidth) {
+        if (!label) {
+            return left + "─".repeat(totalWidth - 2) + right;
+        }
+        const text = " " + label + " ";
+        const textLen = sw(text);
+        const borderLen = totalWidth - 2;
+        if (borderLen <= textLen) {
+            return left + text.slice(0, borderLen) + right;
+        }
+        const leftDash = Math.floor((borderLen - textLen) / 2);
+        const rightDash = borderLen - textLen - leftDash;
+        return left + "─".repeat(leftDash) + text + "─".repeat(rightDash) + right;
+    }
+    syncCursor() {
+        const contentWidth = this.inputFrameContentWidth();
+        const wrapWidth = contentWidth - 2;
+        const wrapped = this.wrapInputVisualLines(this.input.value, wrapWidth, this.input.cursorPos);
+        const compactDraft = this.shouldUseCompactDraft(this.input.value, wrapped.lines.length, false);
+        const cursor = compactDraft
+            ? { lineIndex: 2, columnText: " ".repeat(Math.min(contentWidth - 1, 2 + sw(this.formatDraftChip(this.input.value)))) }
+            : this.inputCursorPosition(wrapped);
+        if (this.inputCursorAnchor === "bottom") {
+            const rowsUp = Math.max(0, this.lastInputContentLineCount + this.lastInputHintLineCount - cursor.lineIndex);
+            if (rowsUp > 0) {
+                process.stdout.write("\x1b[" + rowsUp + "A");
+            }
+        }
+        else {
+            const rowDelta = cursor.lineIndex - this.lastInputCursorLineIndex;
+            if (rowDelta > 0) {
+                process.stdout.write("\x1b[" + rowDelta + "B");
+            }
+            else if (rowDelta < 0) {
+                process.stdout.write("\x1b[" + Math.abs(rowDelta) + "A");
+            }
+        }
+        const col = 5 + cursor.columnText.length;
+        process.stdout.write("\x1b[" + col + "G");
+        this.lastInputCursorLineIndex = cursor.lineIndex;
+        this.inputCursorAnchor = "current";
+    }
+    inputFrameWidth() {
+        return Math.max(40, process.stdout.columns || 80);
+    }
+    inputFrameContentWidth() {
+        return Math.max(20, this.inputFrameWidth() - 4);
+    }
+    inputFrameTop() {
+        return "┌" + "─".repeat(this.inputFrameContentWidth() + 2) + "┐";
+    }
+    inputFrameBottom() {
+        return "└" + "─".repeat(this.inputFrameContentWidth() + 2) + "┘";
+    }
+    inputCursorPosition(wrapped) {
+        const visualCursorRow = wrapped.cursorRow - this.inputStartRow;
+        return {
+            lineIndex: 2 + visualCursorRow,
+            columnText: " ".repeat(wrapped.cursorCol),
+        };
+    }
+    moveToInputContentStart() {
+        const rowsUp = this.inputCursorAnchor === "bottom"
+            ? this.lastInputContentLineCount + this.lastInputHintLineCount
+            : Math.max(0, this.lastInputCursorLineIndex - 1);
+        if (rowsUp > 0) {
+            process.stdout.write("\x1b[" + rowsUp + "A");
+        }
+        this.lastInputCursorLineIndex = 0;
+        this.inputCursorAnchor = "current";
+    }
+    moveAfterInputFrame() {
+        if (this.inputCursorAnchor === "current") {
+            const rowsDown = Math.max(0, this.lastInputContentLineCount + this.lastInputHintLineCount - this.lastInputCursorLineIndex);
+            if (rowsDown > 0) {
+                process.stdout.write("\x1b[" + rowsDown + "B");
+            }
+        }
+        process.stdout.write("\r");
+        this.lastInputCursorLineIndex = 0;
+        this.inputCursorAnchor = "current";
+    }
+    writeInputValue(usePlaceholder = false) {
+        const contentWidth = this.inputFrameContentWidth();
+        const valueToWrap = this.input.value || (usePlaceholder ? "输入任务，或按 / 打开命令面板" : "");
+        const isPlaceholder = !this.input.value && usePlaceholder;
+        const wrapWidth = contentWidth - 2;
+        const wrapped = this.wrapInputVisualLines(valueToWrap, wrapWidth, isPlaceholder ? 0 : this.input.cursorPos);
+        const compactDraft = this.shouldUseCompactDraft(this.input.value, wrapped.lines.length, isPlaceholder);
+        const visibleCount = compactDraft ? 1 : Math.min(5, wrapped.lines.length);
+        if (wrapped.cursorRow < this.inputStartRow) {
+            this.inputStartRow = wrapped.cursorRow;
+        }
+        else if (wrapped.cursorRow >= this.inputStartRow + 5) {
+            this.inputStartRow = wrapped.cursorRow - 4;
+        }
+        if (compactDraft) {
+            this.inputStartRow = 0;
+        }
+        else {
+            this.inputStartRow = Math.max(0, Math.min(this.inputStartRow, wrapped.lines.length - visibleCount));
+        }
+        const visibleLines = compactDraft
+            ? [this.formatDraftChip(this.input.value)]
+            : wrapped.lines.slice(this.inputStartRow, this.inputStartRow + visibleCount);
+        const topLabel = !compactDraft && this.inputStartRow > 0
+            ? "▲ 更多内容 (当前第 " + (wrapped.cursorRow + 1) + " 行)"
+            : "";
+        const bottomLabel = !compactDraft && this.inputStartRow + visibleCount < wrapped.lines.length
+            ? "▼ 更多内容 (共 " + wrapped.lines.length + " 行)"
+            : "";
+        const frameWidth = contentWidth + 4;
+        const topBorder = this.formatInputFrameBorder("┌", "┐", topLabel, frameWidth);
+        const bottomBorder = this.formatInputFrameBorder("└", "┘", bottomLabel, frameWidth);
+        // 批量拼串后一次写出，降低 Windows 终端重绘闪烁
+        const chunks = [S.p(topBorder)];
+        for (let i = 0; i < visibleLines.length; i++) {
+            const absoluteRow = this.inputStartRow + i;
+            const prefix = compactDraft || absoluteRow === 0 ? "› " : "  ";
+            const textLine = visibleLines[i] ?? "";
+            const contentText = textLine;
+            const rendered = truncateVisible(prefix + contentText, contentWidth);
+            chunks.push("\n" + S.p("│ " + padVisible(rendered, contentWidth) + " │"));
+        }
+        chunks.push("\n" + S.p(bottomBorder));
+        let extraHint = "";
+        if (compactDraft) {
+            extraHint = S.y("多行草稿：Enter 发送全部内容");
+        }
+        if (extraHint) {
+            chunks.push("\n" + extraHint);
+        }
+        const hints = this.formatCurrentSlashCompletionHints();
+        for (const hint of hints) {
+            chunks.push("\n" + DIM(hint));
+        }
+        process.stdout.write(chunks.join(""));
+        this.lastInputContentLineCount = 1 + visibleLines.length + 1;
+        this.lastInputHintLineCount = hints.length + (extraHint ? 1 : 0);
+        const cursor = compactDraft
+            ? { lineIndex: 2, columnText: " ".repeat(Math.min(contentWidth - 1, 2 + sw(this.formatDraftChip(this.input.value)))) }
+            : this.inputCursorPosition(wrapped);
+        this.lastInputCursorLineIndex = cursor.lineIndex;
+        this.inputCursorAnchor = "bottom";
+    }
+    formatCurrentSlashCompletionHints() {
+        if (!this.isSlashCompletionActive(this.input.value))
+            return [];
+        const matches = findSlashCompletion(this.input.value, 8);
+        if (matches.length > 0 && this.slashCompletionSelectedIndex >= matches.length) {
+            this.slashCompletionSelectedIndex = 0;
+        }
+        const inputVal = this.input.value || "";
+        if (inputVal === "/" || inputVal === "") {
+            return formatGroupedSlashPanel(process.stdout.columns || 80);
+        }
+        return formatSlashCommandPanel(inputVal, this.slashCompletionSelectedIndex, process.stdout.columns || 80, 8);
+    }
+    isSlashCompletionPrefix(value) {
+        const text = value.trim();
+        return text.startsWith("/") && !/\s/.test(text);
+    }
+    isSlashCompletionActive(value) {
+        return value.startsWith("/") && (!/\s/.test(value.trim()) || /\s$/.test(value));
+    }
+    acceptSlashCompletion() {
+        if (!this.isSlashCompletionPrefix(this.input.value))
+            return false;
+        const matches = findSlashCompletion(this.input.value, 8);
+        const completion = matches[this.slashCompletionSelectedIndex] ?? matches[0];
+        if (!completion)
+            return false;
+        this.input.value = completion.name + " ";
+        this.input.cursorPos = this.input.value.length;
+        this.draftDisplaySource = null;
+        this.slashCompletionSelectedIndex = 0;
+        this.lastEmptyCtrlCAt = 0;
+        this.redrawInput();
+        return true;
+    }
+    moveSlashCompletionSelection(delta) {
+        if (!this.isSlashCompletionPrefix(this.input.value))
+            return false;
+        const matches = findSlashCompletion(this.input.value, 8);
+        if (matches.length <= 1)
+            return false;
+        this.slashCompletionSelectedIndex =
+            (this.slashCompletionSelectedIndex + delta + matches.length) % matches.length;
+        this.redrawInput();
+        return true;
+    }
+    showPrompt() {
+        if (!this.running)
+            return;
+        this.inputStartRow = 0;
+        process.stdout.write("\n");
+        this.printPromptHint();
+        this.writeInputValue(true);
+        this.syncCursor();
+    }
+    /** 测试与 slash 复用：当前是否默认展开长工具输出 */
+    getExpandLongToolOutput() {
+        return this.expandLongToolOutput;
+    }
+    // ── 键盘输入处理 ─────────────────────────────────
+    setupInput() {
+        if (typeof process.stdin.setRawMode === "function") {
+            process.stdin.setRawMode(true);
+        }
+        process.stdin.resume();
+        process.stdin.setEncoding("utf8");
+        this.resizeHandler = () => {
+            if (this.running) {
+                this.redrawInput();
+            }
+        };
+        process.stdout.on("resize", this.resizeHandler);
+        let partial = "";
+        let bracketedPaste = false;
+        let pasteSawCarriageReturn = false;
+        this.dataHandler = (chunk) => {
+            if (!this.running)
+                return;
+            if (chunk === "\x1b") {
+                partial = "";
+                return;
+            }
+            // 非 bracketed 粘贴保护
+            let isMultilinePaste = false;
+            if (!bracketedPaste && !chunk.includes("\x1b") && chunk.length > 1) {
+                const normalized = chunk.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+                const withoutTrailing = normalized.endsWith("\n") ? normalized.slice(0, -1) : normalized;
+                if (withoutTrailing.includes("\n")) {
+                    isMultilinePaste = true;
+                }
+            }
+            if (isMultilinePaste) {
+                const normalized = chunk.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+                for (const ch of normalized) {
+                    if (ch === "\n") {
+                        this.input.insertNewline();
+                    }
+                    else if (ch >= " " || ch === "\t") {
+                        this.input.insertChar(ch);
+                    }
+                }
+                this.markPastedDraft();
+                this.redrawInput();
+                return;
+            }
+            for (const ch of chunk) {
+                if (!partial && ch === "\x1b") {
+                    partial = ch;
+                    continue;
+                }
+                const seq = partial + ch;
+                if (seq === "\x1b[200~") {
+                    partial = "";
+                    bracketedPaste = true;
+                    pasteSawCarriageReturn = false;
+                }
+                else if (seq === "\x1b[201~") {
+                    partial = "";
+                    bracketedPaste = false;
+                    pasteSawCarriageReturn = false;
+                    this.markPastedDraft();
+                    this.redrawInput();
+                }
+                else if (seq === "\x1b[" || /^\x1b\[\d*(?:;\d*)?$/.test(seq)) {
+                    partial = seq;
+                }
+                else if (bracketedPaste) {
+                    partial = "";
+                    if (seq === "\r") {
+                        this.input.insertNewline();
+                        pasteSawCarriageReturn = true;
+                    }
+                    else if (seq === "\n") {
+                        if (!pasteSawCarriageReturn) {
+                            this.input.insertNewline();
+                        }
+                        pasteSawCarriageReturn = false;
+                    }
+                    else if (ch >= " " || ch === "\t") {
+                        pasteSawCarriageReturn = false;
+                        this.input.insertChar(ch);
+                    }
+                }
+                else if (seq === "\r" || seq === "\n") {
+                    partial = "";
+                    this.handleEnter();
+                }
+                else if (seq === "\t") {
+                    partial = "";
+                    this.handleTab();
+                }
+                else if (seq === "\x03") {
+                    partial = "";
+                    this.handleCtrlC();
+                }
+                else if (seq === "\x7f") {
+                    partial = "";
+                    this.handleBackspace();
+                }
+                else if (seq === "\x01") {
+                    partial = "";
+                    this.handleCtrlA();
+                }
+                else if (seq === "\x05") {
+                    partial = "";
+                    this.handleCtrlE();
+                }
+                else if (seq === "\x15") {
+                    partial = "";
+                    this.handleCtrlU();
+                }
+                else if (seq === "\x0b") {
+                    partial = "";
+                    this.handleCtrlK();
+                }
+                else if (seq === "\x17") {
+                    partial = "";
+                    this.handleCtrlW();
+                }
+                else if (seq === "\x1a") {
+                    partial = "";
+                    this.handleCtrlZ();
+                }
+                else if (seq === "\x0c") {
+                    partial = "";
+                    this.handleCtrlL();
+                }
+                else if (seq === "\x04") {
+                    partial = "";
+                    this.handleCtrlD();
+                }
+                else if (seq === "\x1b[A") {
+                    partial = "";
+                    this.handleHistoryUp();
+                }
+                else if (seq === "\x1b[B") {
+                    partial = "";
+                    this.handleHistoryDown();
+                }
+                else if (seq === "\x1b[1;3A" || seq === "\x1b[1;5A" || seq === "\x1b[5A") {
+                    partial = "";
+                    this.handleLineUp();
+                }
+                else if (seq === "\x1b[1;3B" || seq === "\x1b[1;5B" || seq === "\x1b[5B") {
+                    partial = "";
+                    this.handleLineDown();
+                }
+                else if (seq === "\x1b[3~") {
+                    partial = "";
+                    this.handleDelete();
+                }
+                else if (seq === "\x1bd" || seq === "\x1b[3;5~" || seq === "\x1b[3;3~") {
+                    partial = "";
+                    this.handleAltD();
+                }
+                else if (seq === "\x1bb" || seq === "\x1b[1;3D" || seq === "\x1b[1;5D" || seq === "\x1b[5D") {
+                    partial = "";
+                    this.handleWordLeft();
+                }
+                else if (seq === "\x1bf" || seq === "\x1b[1;3C" || seq === "\x1b[1;5C" || seq === "\x1b[5C") {
+                    partial = "";
+                    this.handleWordRight();
+                }
+                else if (seq === "\x1b[C") {
+                    partial = "";
+                    this.handleRight();
+                }
+                else if (seq === "\x1b[D") {
+                    partial = "";
+                    this.handleLeft();
+                }
+                else if (seq === "\x1b[H" || seq === "\x1b[1~") {
+                    partial = "";
+                    this.handleHome();
+                }
+                else if (seq === "\x1b[F" || seq === "\x1b[4~") {
+                    partial = "";
+                    this.handleEnd();
+                }
+                else if (seq === "\x0f") {
+                    partial = "";
+                    this.handleCtrlO();
+                }
+                else if (seq === "\x0e") {
+                    // Ctrl+N inserts a newline while Enter still submits.
+                    partial = "";
+                    this.handleNewline();
+                }
+                else if (seq === "\x12") {
+                    // Ctrl+R restores the latest history entry matching the current input.
+                    partial = "";
+                    this.handleHistorySearch();
+                }
+                else if (ch >= " " || ch === "\t") {
+                    partial = "";
+                    this.handleChar(ch);
+                }
+                else {
+                    partial = "";
+                }
+            }
+        };
+        process.stdin.on("data", this.dataHandler);
+    }
+    handleEnter() {
+        const cmd = this.input.value.trim();
+        if (!cmd)
+            return;
+        this.lastEmptyCtrlCAt = 0;
+        this.inputStartRow = 0;
+        this.moveAfterInputFrame();
+        process.stdout.write("\n");
+        this.input.submit();
+        this.draftDisplaySource = null;
+        if (this.inputCallback) {
+            this.inputCallback(cmd);
+        }
+    }
+    handleTab() {
+        if (!this.input.value) {
+            this.lastEmptyCtrlCAt = 0;
+            process.stdout.write("\n");
+            if (this.inputCallback) {
+                this.inputCallback("/agents");
+            }
+            return;
+        }
+        if (this.acceptSlashCompletion()) {
+            return;
+        }
+        this.appendFeedbackAndRedraw(S.y("Tab agents 仅在空输入时打开；当前草稿已保留，补全未启用"));
+    }
+    handleCtrlC() {
+        if (!this.input.value) {
+            const now = this.now();
+            const shouldExit = this.lastEmptyCtrlCAt > 0 &&
+                now - this.lastEmptyCtrlCAt <= this.doubleCtrlCExitWindowMs;
+            this.lastEmptyCtrlCAt = shouldExit ? 0 : now;
+            if (shouldExit) {
+                process.stdout.write("\n" + DIM("再次 Ctrl+C 已确认退出") + "\n");
+                if (this.inputCallback) {
+                    this.inputCallback("exit");
+                }
+                return;
+            }
+            this.appendFeedbackAndRedraw(S.r("^C") + " " + DIM("再次 Ctrl+C 退出，或输入 exit"), true);
+            return;
+        }
+        this.lastEmptyCtrlCAt = 0;
+        this.lastClearedDraft = this.input.value;
+        this.lastClearedDraftDisplaySource = this.draftDisplaySource;
+        this.input.clear();
+        this.draftDisplaySource = null;
+        this.inputStartRow = 0;
+        this.appendFeedbackAndRedraw(S.r("^C") + " " + DIM("草稿已清空，Ctrl+Z 恢复"), true);
+    }
+    handleCtrlZ() {
+        if (this.input.value) {
+            this.appendFeedbackAndRedraw(S.y("当前输入不会被覆盖，草稿未恢复"));
+            return;
+        }
+        if (!this.lastClearedDraft) {
+            this.appendFeedbackAndRedraw(S.y("没有可恢复的草稿"), true);
+            return;
+        }
+        for (const ch of this.lastClearedDraft) {
+            if (ch === "\n") {
+                this.input.insertNewline();
+            }
+            else {
+                this.input.insertChar(ch);
+            }
+        }
+        this.draftDisplaySource = this.lastClearedDraftDisplaySource;
+        this.lastClearedDraft = null;
+        this.lastClearedDraftDisplaySource = null;
+        this.appendFeedbackAndRedraw(S.g("已恢复草稿"));
+    }
+    handleBackspace() {
+        const beforeValue = this.input.value;
+        const beforeCursor = this.input.cursorPos;
+        this.input.backspace();
+        if (this.input.value === beforeValue && this.input.cursorPos === beforeCursor) {
+            this.syncCursor();
+            return;
+        }
+        this.resetDraftDisplaySourceIfEmpty();
+        this.slashCompletionSelectedIndex = 0;
+        this.redrawInput();
+    }
+    handleCtrlA() {
+        this.input.moveStart();
+        this.redrawInput();
+    }
+    handleCtrlE() {
+        this.input.moveEnd();
+        this.redrawInput();
+    }
+    handleCtrlU() {
+        this.input.deleteBeforeCursor();
+        this.resetDraftDisplaySourceIfEmpty();
+        this.redrawInput();
+    }
+    handleCtrlK() {
+        this.input.deleteAfterCursor();
+        this.resetDraftDisplaySourceIfEmpty();
+        this.redrawInput();
+    }
+    handleCtrlW() {
+        this.input.deleteWordBeforeCursor();
+        this.resetDraftDisplaySourceIfEmpty();
+        this.redrawInput();
+    }
+    handleAltD() {
+        this.input.deleteWordAfterCursor();
+        this.resetDraftDisplaySourceIfEmpty();
+        this.redrawInput();
+    }
+    handleDelete() {
+        const beforeValue = this.input.value;
+        const beforeCursor = this.input.cursorPos;
+        this.input.deleteAfterCursorChar();
+        if (this.input.value === beforeValue && this.input.cursorPos === beforeCursor) {
+            this.syncCursor();
+            return;
+        }
+        this.resetDraftDisplaySourceIfEmpty();
+        this.redrawInput();
+    }
+    handleCtrlL() {
+        process.stdout.write("\x1b[2J\x1b[H");
+        this.printHeader();
+        this.printInputBar();
+        this.syncCursor();
+    }
+    handleCtrlO() {
+        const expanded = this.toggleExpandLongToolOutput();
+        const state = expanded ? "展开后续工具输出" : "折叠后续工具输出";
+        this.appendFeedbackAndRedraw(S.s("长输出：") + DIM(state), !this.input.value);
+    }
+    handleCtrlD() {
+        if (this.input.value) {
+            this.appendFeedbackAndRedraw(S.y("非空输入不会退出，草稿已保留"));
+            return;
+        }
+        this.lastEmptyCtrlCAt = 0;
+        if (this.inputCallback) {
+            this.inputCallback("exit");
+        }
+    }
+    handleHistoryUp() {
+        if (this.moveSlashCompletionSelection(-1))
+            return;
+        this.input.historyUp();
+        this.draftDisplaySource = this.input.value ? "typed" : null;
+        this.redrawInput();
+    }
+    handleHistoryDown() {
+        if (this.moveSlashCompletionSelection(1))
+            return;
+        this.input.historyDown();
+        this.draftDisplaySource = this.input.value ? "typed" : null;
+        this.redrawInput();
+    }
+    handleHistorySearch() {
+        const matched = this.input.searchHistory();
+        if (!matched) {
+            this.appendFeedbackAndRedraw(S.y("无匹配历史"));
+            return;
+        }
+        this.draftDisplaySource = this.input.value ? "typed" : null;
+        this.redrawInput();
+    }
+    handleLeft() {
+        this.input.moveLeft();
+        this.syncCursor();
+    }
+    handleRight() {
+        this.input.moveRight();
+        this.syncCursor();
+    }
+    handleWordLeft() {
+        this.input.moveWordLeft();
+        this.syncCursor();
+    }
+    handleWordRight() {
+        this.input.moveWordRight();
+        this.syncCursor();
+    }
+    handleLineUp() {
+        this.input.moveLineUp();
+        this.syncCursor();
+    }
+    handleLineDown() {
+        this.input.moveLineDown();
+        this.syncCursor();
+    }
+    handleHome() {
+        this.input.moveStart();
+        this.redrawInput();
+    }
+    handleEnd() {
+        this.input.moveEnd();
+        this.redrawInput();
+    }
+    handleChar(ch) {
+        this.input.insertChar(ch);
+        if (this.draftDisplaySource !== "pasted") {
+            this.draftDisplaySource = "typed";
+        }
+        this.slashCompletionSelectedIndex = 0;
+        this.redrawInput();
+    }
+    handleNewline() {
+        this.input.insertNewline();
+        if (this.draftDisplaySource !== "pasted") {
+            this.draftDisplaySource = "typed";
+        }
+        this.redrawInput();
+    }
+    // ── 工具块渲染 ────────────────────────────────────
+    printToolHeader(tool, command, status, durationMs = 0) {
+        const w = process.stdout.columns || 100;
+        const row = formatToolTimelineRow({ tool, command, status, durationMs, width: w });
+        const color = status === "error" ? S.r : status === "success" ? S.g : S.m;
+        process.stdout.write("\n" + color(row));
+    }
+    printToolOutput(output, _status) {
+        const card = formatToolOutputCard(output, {
+            expand: this.expandLongToolOutput,
+            maxTop: 8,
+            maxBottom: 2,
+            longThreshold: 12,
+        });
+        const chunks = [];
+        for (const line of card.displayLines) {
+            chunks.push("  " + DIM(line) + "\n");
+        }
+        if (card.footer) {
+            chunks.push("  " + DIM(card.footer) + "\n");
+        }
+        if (chunks.length > 0) {
+            process.stdout.write(chunks.join(""));
+        }
+    }
+    // ── 事件输出（全部 append，不清屏） ────────────────
+    appendToolStart(tool, command) {
+        this.currentToolRunning = true;
+        process.stdout.write("\n" + S.m(formatRoleHeader("executing")));
+        this.printToolHeader(tool, command, "running");
+    }
+    appendToolSuccess(tool, command, output, durationMs) {
+        if (this.currentToolRunning) {
+            this.currentToolRunning = false;
+        }
+        this.printToolHeader(tool, command, "success", durationMs);
+        process.stdout.write("\n");
+        if (output.trim()) {
+            this.printToolOutput(output, "success");
+        }
+    }
+    appendToolError(tool, command, error, durationMs) {
+        if (this.currentToolRunning) {
+            this.currentToolRunning = false;
+        }
+        this.printToolHeader(tool, command, "error", durationMs);
+        process.stdout.write("\n  " + S.r("Error: ") + S.r(error.split("\n")[0]) + "\n");
+        const rest = error.split("\n");
+        if (rest.length > 1) {
+            this.printToolOutput(rest.slice(1).join("\n"), "error");
+        }
+    }
+    appendThinking(text) {
+        const lines = text.split("\n").filter((l) => l.trim());
+        if (lines.length === 0)
+            return;
+        process.stdout.write("\n" + S.p(formatRoleHeader("assistant")) + "\n");
+        process.stdout.write(lines[0]);
+        for (let i = 1; i < lines.length; i++) {
+            process.stdout.write("\n" + lines[i]);
+        }
+    }
+    appendCogitated(durationMs) {
+        process.stdout.write("\n" + DIM("◆ Cogitated for " + fmtDur(durationMs)));
+    }
+    appendValidation(status, text) {
+        const icon = status === "pass" ? S.g("●") : status === "fail" ? S.r("●") : S.y("●");
+        const label = status === "pass" ? S.g("pass") : status === "fail" ? S.r("fail") : S.y("warn");
+        process.stdout.write("\n" + icon + " " + label + "  " + S.d(text));
+    }
+    appendOutput(text) {
+        const lines = text.split("\n");
+        for (const line of lines) {
+            process.stdout.write(line.trim() ? "\n" + S.b("› ") + line : "\n");
+        }
+    }
+    appendUserInput(text) {
+        const lines = text.split("\n");
+        process.stdout.write("\n" + S.s(formatRoleHeader("user")) + "\n");
+        for (const line of lines) {
+            process.stdout.write(line + "\n");
+        }
+    }
+    appendRepair(reason, action, retryCount) {
+        process.stdout.write("\n" + S.y("[repair]"));
+        process.stdout.write("\n  " + S.d("原因:") + " " + S.r(reason));
+        process.stdout.write("\n  " + S.d("动作:") + " " + S.b(action));
+        process.stdout.write("\n  " + S.d("retry:") + " " + S.y(String(retryCount)));
+    }
+    appendFinal(text) {
+        process.stdout.write("\n" + S.p(formatRoleHeader("assistant")) + "\n");
+        const width = process.stdout.columns || 100;
+        const lines = formatMarkdownForTerminal(text, { width });
+        for (const line of lines) {
+            process.stdout.write(line + "\n");
+        }
+    }
+    appendError(text) {
+        process.stdout.write("\n" + S.r("● error") + "  " + S.r(text));
+    }
+    appendState(from, to) {
+        process.stdout.write("\n" + DIM("[state] ") + S.y(from) + " " + DIM("→") + " " + S.g(to));
+    }
+    appendDone(durationMs) {
+        const dur = fmtDur(durationMs);
+        process.stdout.write("\n" + S.g("☑ 分析完成") + " " + DIM(dur));
+    }
+}