mocode-ai 0.1.0

package/dist/llm/index.js

@@ -0,0 +1,162 @@
+import OpenAI from 'openai';
+import { config } from '../config/index.js';
+import { tools } from '../tools/registry.js';
+const client = new OpenAI({
+    baseURL: config.baseURL,
+    apiKey: config.apiKey,
+});
+/** 把内部工具定义转成 OpenAI 的 tool 格式 */
+export const chatTools = tools.map((t) => ({
+    type: 'function',
+    function: {
+        name: t.name,
+        description: t.description,
+        // 不同版本 SDK 的 FunctionParameters 宽严不一,用 any 兜底
+        parameters: t.parameters,
+    },
+}));
+/**
+ * 流式调一次 LLM:增量回调文本 / 思考,内部累加 tool_calls 片段。
+ * 思考内容走 delta.reasoning_content(DeepSeek / GLM / Qwen 等推理模型,
+ * SDK 类型无此字段,用 as any 取;不支持的模型则无思考,只流文本)。
+ * tool_calls 跨 chunk 按 index 累加(id / name / arguments 拼接)。
+ * include_usage 时末尾 chunk 携带 usage,先读再 continue(末尾 chunk 无 delta)。
+ */
+export async function chat(messages, handlers = {}, signal) {
+    // signal 透传给 SDK 第二参(RequestOptions);abort 后 for await 抛错,chat 不 catch,透传 runAgent 处理。
+    const stream = await client.chat.completions.create({
+        model: config.model,
+        messages,
+        tools: chatTools,
+        stream: true,
+        ...(config.maxTokens ? { max_tokens: config.maxTokens } : {}),
+        ...(config.includeUsage ? { stream_options: { include_usage: true } } : {}),
+    }, signal ? { signal } : undefined);
+    let content = '';
+    let hasContent = false;
+    let usage;
+    const toolAcc = new Map();
+    for await (const chunk of stream) {
+        // usage:末尾 chunk(choices 可能为空)在 include_usage 时携带;先读再 continue。
+        if (chunk.usage) {
+            usage = {
+                promptTokens: chunk.usage.prompt_tokens,
+                completionTokens: chunk.usage.completion_tokens,
+                totalTokens: chunk.usage.total_tokens,
+            };
+        }
+        const delta = chunk.choices[0]?.delta;
+        if (!delta)
+            continue; // 末尾 usage-only chunk 等无 delta
+        // 思考内容(非标准字段,SDK 类型无)
+        const reasoning = delta.reasoning_content ?? delta.reasoning;
+        if (reasoning)
+            handlers.onThinking?.(reasoning);
+        if (delta.content) {
+            content += delta.content;
+            hasContent = true;
+            handlers.onText?.(delta.content);
+        }
+        if (delta.tool_calls) {
+            for (const tc of delta.tool_calls) {
+                const idx = tc.index ?? 0;
+                let entry = toolAcc.get(idx);
+                if (!entry) {
+                    entry = { name: '', arguments: '' };
+                    toolAcc.set(idx, entry);
+                }
+                if (tc.id)
+                    entry.id = tc.id;
+                if (tc.function?.name)
+                    entry.name += tc.function.name;
+                if (tc.function?.arguments)
+                    entry.arguments += tc.function.arguments;
+            }
+        }
+    }
+    const toolCalls = [...toolAcc.entries()]
+        .sort((a, b) => a[0] - b[0])
+        .map(([, e]) => ({
+        id: e.id ?? '',
+        name: e.name,
+        arguments: e.arguments,
+    }));
+    return {
+        content: hasContent ? content : null,
+        toolCalls,
+        usage,
+    };
+}
+// ── token 估算(自包含,不依赖 ui / 外部 tokenizer)──────────────────────
+// CJK 感知启发式:CJK 字符 ≈ 1 token,其余 ≈ 4 字符/token。
+// 故意偏过估(安全侧):估算偏高 → 压缩触发偏早 → 不会溢出窗口。
+// 真实 usage 由 chat() 的 include_usage 返回;此处仅作预检 / 兜底 / /context 显示。
+/** 判断一个码点是否 CJK 表意 / 假名 / 韩文(按 1 token 计)。 */
+function isCJK(cp) {
+    return ((cp >= 0x4e00 && cp <= 0x9fff) || // CJK 统一表意
+        (cp >= 0x3400 && cp <= 0x4dbf) || // CJK 扩展 A
+        (cp >= 0xf900 && cp <= 0xfaff) || // CJK 兼容表意
+        (cp >= 0x3040 && cp <= 0x30ff) || // 假名
+        (cp >= 0xac00 && cp <= 0xd7a3) // 韩文音节
+    );
+}
+/** 粗估一段文本的 token 数。CJK≈1/字,其余≈1/4字,向上取整。 */
+export function estimateTokens(text) {
+    if (!text)
+        return 0;
+    let cjk = 0;
+    let other = 0;
+    for (const ch of text) {
+        const cp = ch.codePointAt(0) ?? 0;
+        if (isCJK(cp))
+            cjk++;
+        else
+            other++;
+    }
+    return Math.ceil(cjk + other / 4);
+}
+/** 把任意消息内容(content 可能是 string | null | 多模态数组)拍平成字符串。 */
+function contentToText(content) {
+    if (content == null)
+        return '';
+    if (typeof content === 'string')
+        return content;
+    try {
+        return JSON.stringify(content);
+    }
+    catch {
+        return String(content);
+    }
+}
+/** 估算单条消息的 token 数:结构开销 + content + tool_calls 参数。 */
+export function messageTokens(m) {
+    const role = m.role;
+    let structural = 4; // {role}\n{content}\n 框架基线
+    if (role === 'system')
+        structural = 3;
+    else if (role === 'tool')
+        structural = 6;
+    let body = contentToText(m.content);
+    const tcs = m
+        .tool_calls;
+    if (tcs) {
+        for (const tc of tcs)
+            body += tc?.function?.arguments ?? '';
+    }
+    return structural + estimateTokens(body);
+}
+/** 估算整段 messages 的 token 数(不含工具 schema,含 priming 常数)。 */
+export function estimateMessagesTokens(messages) {
+    let sum = 3; // priming:每轮对话的基础开销
+    for (const m of messages)
+        sum += messageTokens(m);
+    return sum;
+}
+let schemaTokensCache;
+/** 估算 chatTools(工具 schema)占用的一次性 token,带缓存。 */
+export function estimateToolSchemaTokens() {
+    if (schemaTokensCache === undefined) {
+        schemaTokensCache = estimateTokens(JSON.stringify(chatTools)) + 16;
+    }
+    return schemaTokensCache;
+}

package/dist/repl/index.js

@@ -0,0 +1,530 @@
+import readline from 'node:readline/promises';
+import { emitKeypressEvents } from 'node:readline';
+import { stdin, stdout } from 'node:process';
+import { config } from '../config/index.js';
+import { runAgent } from '../agent/index.js';
+import { ui } from '../ui/theme.js';
+import { bannerString, displayWidth, summarizeToolCall, summarizeToolResult } from '../ui/render.js';
+import * as layout from '../ui/layout.js';
+import { promptWithSlashMenu, promptTurnPicker } from '../ui/prompt.js';
+import { tools } from '../tools/registry.js';
+import { estimateMessagesTokens, estimateToolSchemaTokens, } from '../llm/index.js';
+import { compactHistory, contextState, newSessionId, saveSession, loadSession, listSessions, } from '../session/index.js';
+import { listTurns, planRollback, applyRollback, persistSnapshots, loadSnapshots, rebuildFromHistory, resetState, } from '../rollback/index.js';
+import { listSkills, effectiveSystemPrompt } from '../skills/index.js';
+/**
+ * readline 的 prompt 必须是纯文本(无 ANSI):readline 按字符数算光标位置,
+ * 颜色码会让光标错位、编辑时漂移。颜色只用在直接 stdout.write 的横幅 / 工具行 / 回复。
+ */
+const PROMPT = '❯ ';
+/** 斜杠命令菜单(仅用于输入时下拉显示与过滤;分发仍走下方 if 链)。 */
+const SLASH_COMMANDS = [
+    { name: '/exit', desc: '退出 mocode(同 /quit)' },
+    { name: '/clear', desc: '清空历史(保留系统提示)' },
+    { name: '/context', desc: '显示上下文用量条' },
+    { name: '/skills', desc: '列出已发现的 skill' },
+    { name: '/compact', desc: '压缩历史(可带焦点 /compact …)' },
+    { name: '/resume', desc: '续接已保存的会话' },
+    { name: '/think', desc: '展开折叠思考段(/think N)' },
+    { name: '/rollback', desc: '菜单选轮次回滚(↑↓·Enter)' },
+];
+/** 临时 readline 读一行(cooked,用于子提问;主输入走 promptWithSlashMenu)。 */
+async function askLine(prompt) {
+    const rl = readline.createInterface({ input: stdin, output: stdout });
+    try {
+        return await rl.question(prompt);
+    }
+    finally {
+        rl.close();
+    }
+}
+/** /context 的用量条(详情版,进内容区):优先用上次 chat() 返回的实测 usage,否则用启发式估算。 */
+function renderContextBar(history) {
+    const schema = estimateToolSchemaTokens();
+    const est = contextState.lastUsage?.totalTokens ??
+        estimateMessagesTokens(history) + schema;
+    const win = config.contextWindowTokens;
+    const pct = Math.min(1, est / win);
+    const W = 10;
+    const filled = Math.round(pct * W);
+    const bar = '█'.repeat(filled) + '░'.repeat(W - filled);
+    const src = contextState.lastUsage ? '实测' : '估算';
+    const k = (n) => `${Math.round(n / 1000)}k`;
+    const pctCol = pct >= config.compactThreshold ? ui.yellow : ui.cyan;
+    return `${ui.gray}[${pctCol}${bar}${ui.reset}] ${Math.round(pct * 100)}%  ${k(est)}/${k(win)} tokens · ${history.length} 条消息 (${src})${ui.reset}`;
+}
+/** 状态行用量条(精简版,进底栏):[bar] pct% k/k。 */
+function renderContextBarInline(history) {
+    const schema = estimateToolSchemaTokens();
+    const est = contextState.lastUsage?.totalTokens ??
+        estimateMessagesTokens(history) + schema;
+    const win = config.contextWindowTokens;
+    const pct = Math.min(1, est / win);
+    const W = 10;
+    const filled = Math.round(pct * W);
+    const bar = '█'.repeat(filled) + '░'.repeat(W - filled);
+    const k = (n) => `${Math.round(n / 1000)}k`;
+    const pctCol = pct >= config.compactThreshold ? ui.yellow : ui.cyan;
+    return `${ui.gray}[${pctCol}${bar}${ui.reset}] ${pctCol}${Math.round(pct * 100)}%${ui.reset} ${ui.dim}${k(est)}/${k(win)}${ui.reset}`;
+}
+/** 状态行基线:模型 / context / cwd。repl 在轮次边界调,刷新 context 用量。 */
+function refreshStatusBase(history) {
+    layout.setStatusBase({
+        model: config.model,
+        contextBar: renderContextBarInline(history),
+        cwd: process.cwd(),
+    });
+}
+/** 命令 → 运行态状态文字 + 底栏 dim 占位。 */
+function runningStateFor(cmd) {
+    switch (cmd) {
+        case '/compact':
+            return { status: '压缩', placeholder: '压缩中…' };
+        case '/resume':
+            return { status: '续接', placeholder: '选择会话…' };
+        case '/rollback':
+            return { status: '回滚', placeholder: '选择轮次…' };
+        case '/clear':
+            return { status: '清空', placeholder: '…' };
+        default:
+            return { status: '处理', placeholder: '思考中… Ctrl+C 中断' };
+    }
+}
+const emitter = stdin;
+// ── 运行态交互(typeahead 输入 + 滚动回看 + Ctrl+C 中断)──
+// 只在 await runAgent() 期间挂载;/resume /rollback /compact 等走 askLine(cooked readline)的分支不挂(避免抢 stdin)。
+let runningInput = ''; // 运行中已打字缓冲(单行;agent 结束后预填下一轮 INPUT 态)
+let runningPlaceholder = '';
+let currentAbort = null;
+let pendingPrefill = null; // /rollback 选中后预填的 user 输入(下轮 INPUT 态消费)
+/** 运行态按键:滚动优先,再 Ctrl+C 中断,再 typeahead 编辑(单行,Enter=无操作)。 */
+function onRunningKey(_str, key) {
+    if (!key)
+        return;
+    // 滚动回看键(优先;不触发回尾):PgUp/PgDn 翻页,↑/↓ 单行(含鼠标滚轮——alt 屏滚轮转发↑↓)。
+    // 运行态无输入光标,↑/↓ 无其他用途,直接作滚动。
+    if (key.name === 'pageup' ||
+        key.name === 'pagedown' ||
+        key.name === 'up' ||
+        key.name === 'down') {
+        const pageH = layout.getGeo().contentBottom;
+        if (key.name === 'pageup')
+            layout.scrollBy(pageH);
+        else if (key.name === 'pagedown')
+            layout.scrollBy(-pageH);
+        else if (key.name === 'up')
+            layout.scrollBy(1);
+        else
+            layout.scrollBy(-1);
+        return;
+    }
+    // 其他键:若处于滚动回看,先回尾再处理(打字即回底)
+    if (layout.isScrolled())
+        layout.resetScroll();
+    // Ctrl+C 中断当前 agent 轮次(不退进程;raw 模式下 Ctrl+C 是按键,不触发 SIGINT)
+    if (key.ctrl && key.name === 'c') {
+        currentAbort?.abort();
+        return;
+    }
+    const s = key.sequence ?? '';
+    if (key.name === 'backspace') {
+        if (runningInput.length > 0) {
+            runningInput = runningInput.slice(0, -1);
+            layout.paintRunningInputEcho(runningInput, runningPlaceholder);
+        }
+        return;
+    }
+    if (key.name === 'escape') {
+        runningInput = '';
+        layout.paintRunningInputEcho(runningInput, runningPlaceholder);
+        return;
+    }
+    // Enter / Ctrl+J:运行中 no-op(单行 typeahead;agent 结束后预填,用户在 INPUT 态按 Enter 提交)
+    if (key.name === 'return' ||
+        key.name === 'enter' ||
+        (key.ctrl && key.name === 'j')) {
+        return;
+    }
+    // 可打印字符(>= 空格,非 ctrl/meta)→ 追加 + dim 回显
+    if (s && s >= ' ' && !key.ctrl && !key.meta) {
+        runningInput += s;
+        layout.paintRunningInputEcho(runningInput, runningPlaceholder);
+    }
+}
+/** 进入运行态:挂 keypress 监听 + raw mode + 新建 abort 控制器,返回其 signal。在 await runAgent 前、enterRunningMode 后调。 */
+function startRunningListener(placeholder) {
+    runningPlaceholder = placeholder;
+    runningInput = '';
+    emitKeypressEvents(stdin); // 幂等:首轮 prompt 已永久挂解析器,这里防御性再调
+    try {
+        stdin.setRawMode(true);
+    }
+    catch {
+        // 非 TTY / 不支持 raw:监听器仍挂(按键可能不来,不影响 agent)
+    }
+    stdin.resume();
+    emitter.on('keypress', onRunningKey);
+    const ac = new AbortController();
+    currentAbort = ac;
+    return ac.signal;
+}
+/** 退出运行态:摘监听 + 清 abort。不 pause / 不 setRawMode(false)——紧接着 promptWithSlashMenu 自己接管 raw。 */
+function stopRunningListener() {
+    emitter.off('keypress', onRunningKey);
+    currentAbort = null;
+}
+/** 把多行提交输入回显进内容区(❯ 首行,续行按 prompt 宽度缩进)。仅 TUI 态回显(非 TTY 由 readline 自带回显)。 */
+function echoInput(lines) {
+    if (!layout.isActive())
+        return;
+    const indent = ' '.repeat(displayWidth(PROMPT));
+    const echo = lines.map((l, i) => (i === 0 ? `${PROMPT}${l}` : `${indent}${l}`)).join('\n') +
+        '\n';
+    layout.contentWrite(echo);
+}
+/** 把任意消息 content 拍平成字符串(OpenAI 可能 string / null / 多模态数组)。 */
+function textOf(c) {
+    if (typeof c === 'string')
+        return c;
+    if (c == null)
+        return '';
+    if (Array.isArray(c)) {
+        return c
+            .map((p) => typeof p === 'string' ? p : p?.text ?? '')
+            .join('');
+    }
+    return String(c);
+}
+/**
+ * 把会话历史渲染成静态文本进内容区(回滚 / 续接 / --resume 后复显上下文,仿 Claude Code):
+ * user→❯ 回显、assistant→正文(+ tool_calls 作 ● 行)、tool→↳ 结果预览;system 跳过。
+ * 思考段不持久(history 只存正文),故无思考折叠。渲染后续写位在末尾,紧接 enterInputMode 画输入框。
+ * 内容长于屏时 viewport 显尾(最近轮次),PgUp 可看更早——与流式态一致。
+ */
+export function renderHistory(history) {
+    const indent = ' '.repeat(displayWidth(PROMPT));
+    const idToName = new Map();
+    for (const m of history) {
+        if (m.role === 'system')
+            continue;
+        if (m.role === 'user') {
+            const lines = textOf(m.content).split('\n');
+            layout.contentWrite(lines
+                .map((l, i) => (i === 0 ? `${PROMPT}${l}` : `${indent}${l}`))
+                .join('\n') + '\n');
+            continue;
+        }
+        if (m.role === 'assistant') {
+            const text = textOf(m.content);
+            if (text) {
+                layout.contentWrite(text);
+                if (!text.endsWith('\n'))
+                    layout.contentWrite('\n');
+            }
+            const tcs = m.tool_calls;
+            if (Array.isArray(tcs)) {
+                for (const tc of tcs) {
+                    const name = tc?.function?.name ?? '';
+                    const args = tc?.function?.arguments ?? '';
+                    if (tc?.id && name)
+                        idToName.set(tc.id, name);
+                    layout.contentWrite(`  ${ui.brightMagenta}●${ui.reset} ${ui.cyan}${name}${ui.reset}  ${ui.dim}${summarizeToolCall(name, args)}${ui.reset}\n`);
+                }
+            }
+            continue;
+        }
+        if (m.role === 'tool') {
+            const id = m.tool_call_id ?? '';
+            const name = idToName.get(id) ?? '';
+            const preview = summarizeToolResult(name, textOf(m.content));
+            if (preview)
+                layout.contentWrite(`  ${ui.gray}↳ ${preview}${ui.reset}\n`);
+            continue;
+        }
+    }
+}
+/**
+ * 交互式 REPL:全屏 TUI(alt screen + 固定底栏)。INPUT 态底栏=状态行+输入框(raw mode 等按键);
+ * 提交后 enterRunningMode(底栏改 dim 占位、光标回内容续写位),命令分发与 runAgent 的流式输出经
+ * contentWrite 落入内容区(滚动区域内自动滚动,底栏不动)。history 由本模块持有,在轮次间持久;
+ * agent 只读取并追加(+ 经 session/ 压缩)。每轮成功结束后自动落盘,退出后可用 --resume / /resume 续接。
+ */
+export async function startRepl(initialHistory, sessionId) {
+    // 有预加载(--resume)则用它,并把 history[0] 刷成当前 system prompt(config 可能已变);
+    // 否则新会话只塞 system 提示。
+    const systemPrompt = effectiveSystemPrompt(config.systemPrompt);
+    const history = initialHistory && initialHistory.length
+        ? initialHistory
+        : [{ role: 'system', content: systemPrompt }];
+    if (initialHistory &&
+        initialHistory.length &&
+        history[0]?.role === 'system') {
+        history[0] = { role: 'system', content: systemPrompt };
+    }
+    // --resume:读回该会话的轮次/快照;无文件则从 history 重建 turns(无快照→旧轮次文件改动不可撤销)
+    if (sessionId && initialHistory && initialHistory.length) {
+        if (!loadSnapshots(sessionId))
+            rebuildFromHistory(history);
+    }
+    let currentSessionId = sessionId;
+    // 本会话累积的折叠思考段,供 /think N 重打原文。
+    const collapsedThinkings = [];
+    const toolsLine = tools.map((t) => t.name).join(' · ');
+    const banner = () => ({
+        model: config.model,
+        baseURL: config.baseURL,
+        cwd: process.cwd(),
+        tools: toolsLine,
+    });
+    // 开场:进 alt screen + 状态基线 + 清内容区。--resume 有历史则渲染对话(仿 Claude Code),否则横幅。
+    layout.enterAltScreen();
+    refreshStatusBase(history);
+    layout.clearContent();
+    layout.contentMode();
+    if (history.some((m) => m.role === 'user')) {
+        renderHistory(history);
+    }
+    else {
+        layout.contentWrite(bannerString(banner()));
+    }
+    /**
+     * 回滚子流程(由 /rollback 触发):菜单(↑/↓)选轮次 → 选中第 X 轮 = 删第 X 轮及之后 + 预填第 X 轮 user 输入
+     * (仿 Claude Code rewind,Enter 重新跑该轮);被删轮次的文件改动仍逐个「保留/撤销」询问(cooked readline)。
+     * 选轮菜单走 promptTurnPicker(raw mode);文件询问走 askLine(cooked)。预填经 pendingPrefill 注入下轮 INPUT。
+     */
+    const rollbackFlow = async () => {
+        const turnList = listTurns();
+        if (turnList.length < 1) {
+            layout.contentWrite(`${ui.dim}(没有可回滚的轮次)${ui.reset}\n`);
+            return;
+        }
+        // 各轮 user 全文(预填用;按 user 消息顺序与 turnList 对齐)
+        const userTexts = [];
+        for (const m of history) {
+            if (m.role === 'user')
+                userTexts.push(textOf(m.content));
+        }
+        const items = turnList.map((t) => ({ firstLine: t.firstLine }));
+        let picked;
+        try {
+            picked = await promptTurnPicker(items);
+        }
+        catch {
+            return; // Ctrl+C(SIGINT)→ 取消回滚
+        }
+        if (picked === null)
+            return; // Esc 取消
+        // picked(0-based)= 第 (picked+1) 轮:删该轮及之后(planRollback(picked) 保 1..picked),预填该轮 user 输入
+        const prefillText = userTexts[picked] ?? '';
+        const plan = planRollback(picked, history);
+        // 清屏(擦选轮菜单 + /rollback 回显)+ 复位 lastView(dim 空),给文件询问一个干净、resize 安全的画面
+        layout.clearContent();
+        layout.paintInput({
+            prompt: '❯ ',
+            lines: [''],
+            cursorLine: 0,
+            cursorCol: 0,
+            menu: null,
+            dim: true,
+        });
+        const revertPaths = new Set();
+        for (const c of plan.changes) {
+            layout.contentWrite(`  ${ui.cyan}${c.path}${ui.reset} ${ui.dim}(${c.ops.join(', ')})${ui.reset}\n`);
+            let ans = '';
+            try {
+                ans = (await askLine('  保留/撤销 [k/u](回车=保留): ')).trim();
+            }
+            catch {
+                continue;
+            }
+            if (ans.startsWith('u') || ans.startsWith('U')) {
+                if (c.snapshotAvailable) {
+                    revertPaths.add(c.path);
+                }
+                else {
+                    layout.contentWrite(`${ui.dim}  (无快照,无法撤销——保留)${ui.reset}\n`);
+                }
+            }
+        }
+        applyRollback(plan, history, revertPaths);
+        if (!currentSessionId)
+            currentSessionId = newSessionId();
+        try {
+            saveSession(history, currentSessionId);
+        }
+        catch {
+            // 落盘失败不阻断
+        }
+        persistSnapshots(currentSessionId);
+        // 复显剩余对话(无提示行),输入框预填该轮 user 输入 → 下轮 Enter 重新跑
+        layout.clearContent();
+        renderHistory(history);
+        pendingPrefill = prefillText.split('\n');
+    };
+    while (true) {
+        // INPUT 态:画底栏输入框 + 状态行,光标入输入框
+        refreshStatusBase(history);
+        layout.enterInputMode('空闲');
+        let input = null;
+        try {
+            input = await promptWithSlashMenu({
+                prompt: PROMPT,
+                commands: SLASH_COMMANDS,
+                // /rollback 预填优先;否则上一轮运行中 typeahead 打的字 → 预填进输入框,用户可改可发
+                ...(pendingPrefill
+                    ? { initialLines: pendingPrefill }
+                    : runningInput
+                        ? { initialLines: [runningInput] }
+                        : {}),
+            });
+        }
+        catch {
+            break; // Ctrl+C(SIGINT)/ 异常 → 退出
+        }
+        pendingPrefill = null; // 预填已消费,清空
+        runningInput = ''; // 预填已消费,清空(下轮运行态从空开始)
+        if (input === null)
+            break; // 空 prompt Ctrl+D
+        const joined = input.join('\n');
+        const line = joined.trim();
+        if (!line)
+            continue;
+        if (line === '/exit' || line === '/quit')
+            break;
+        // RUNNING 态:回显输入 → 底栏改 dim 占位、光标回内容续写位
+        echoInput(input);
+        const cmd = line.split(/\s+/)[0];
+        const { status, placeholder } = runningStateFor(cmd);
+        refreshStatusBase(history);
+        layout.enterRunningMode(status, placeholder);
+        if (line === '/clear') {
+            history.length = 1; // 保留 system 提示
+            collapsedThinkings.length = 0; // 同步清空折叠的思考段
+            resetState(); // 同步清空回滚轮次/快照
+            currentSessionId = undefined; // 下轮起新会话文件
+            contextState.lastUsage = undefined;
+            layout.clearContent();
+            layout.contentWrite(bannerString(banner()));
+            layout.contentWrite(`${ui.dim}(历史已清空,保留系统提示)${ui.reset}\n`);
+            continue;
+        }
+        if (line === '/context') {
+            layout.contentWrite(`  ${renderContextBar(history)}\n`);
+            continue;
+        }
+        if (line === '/skills') {
+            const skills = listSkills();
+            if (skills.length === 0) {
+                layout.contentWrite(`${ui.dim}(没有已发现的 skill)${ui.reset}\n`);
+            }
+            else {
+                layout.contentWrite(`${ui.dim}已发现 ${skills.length} 个 skill:${ui.reset}\n`);
+                for (const s of skills) {
+                    layout.contentWrite(`  ${ui.cyan}${s.name}${ui.reset}  ${ui.dim}${s.description}${ui.reset}\n`);
+                }
+                layout.contentWrite(`${ui.dim}(用 use_skill 工具加载某 skill 的完整指令)${ui.reset}\n`);
+            }
+            continue;
+        }
+        if (line === '/compact' || line.startsWith('/compact ')) {
+            const focus = line.startsWith('/compact ')
+                ? line.slice('/compact '.length).trim()
+                : undefined;
+            const r = await compactHistory(history, {
+                window: config.contextWindowTokens,
+                threshold: config.compactThreshold,
+                focus,
+            });
+            if (r.reason === 'noop') {
+                layout.contentWrite(`${ui.dim}(无需压缩:没有可压缩的旧消息)${ui.reset}\n`);
+            }
+            continue;
+        }
+        if (line === '/resume') {
+            const sessions = listSessions();
+            if (sessions.length === 0) {
+                layout.contentWrite(`${ui.dim}(没有已保存的会话)${ui.reset}\n`);
+                continue;
+            }
+            sessions.forEach((s, i) => {
+                layout.contentWrite(`  ${ui.dim}${i + 1}${ui.reset}  ${s.id}  ${ui.cyan}${s.firstUser || '(无)'}${ui.reset}  ${ui.dim}${s.model}${ui.reset}\n`);
+            });
+            let pick = '';
+            try {
+                pick = (await askLine('序号(回车取消): ')).trim();
+            }
+            catch {
+                continue;
+            }
+            const idx = Number(pick);
+            if (!pick || !Number.isInteger(idx) || idx < 1 || idx > sessions.length)
+                continue;
+            const loaded = loadSession(sessions[idx - 1].id);
+            if (!loaded || !loaded.history.length) {
+                layout.contentWrite(`${ui.yellow}(加载失败)${ui.reset}\n`);
+                continue;
+            }
+            if (loaded.history[0]?.role === 'system') {
+                loaded.history[0] = { role: 'system', content: systemPrompt };
+            }
+            history.length = 0;
+            history.push(...loaded.history);
+            currentSessionId = loaded.id;
+            // 读回该会话的轮次/快照;无文件则从 history 重建 turns(无快照→旧轮次文件改动不可撤销)
+            if (!loadSnapshots(loaded.id))
+                rebuildFromHistory(history);
+            contextState.lastUsage = undefined;
+            collapsedThinkings.length = 0;
+            layout.clearContent();
+            renderHistory(history);
+            layout.contentWrite(`${ui.dim}(已续接会话 ${loaded.id})${ui.reset}\n`);
+            continue;
+        }
+        if (line === '/think' || line.startsWith('/think ')) {
+            const arg = line.split(/\s+/)[1];
+            if (!arg) {
+                layout.contentWrite(`${ui.dim}折叠思考段: ${collapsedThinkings.length} 段  ·  用法: /think N (展开第 N 段)${ui.reset}\n`);
+                continue;
+            }
+            const idx = Number(arg);
+            if (!Number.isInteger(idx) || idx < 1 || idx > collapsedThinkings.length) {
+                layout.contentWrite(`${ui.yellow}无第 ${arg} 段(共 ${collapsedThinkings.length})${ui.reset}\n`);
+                continue;
+            }
+            const content = collapsedThinkings[idx - 1];
+            layout.contentWrite(`${ui.dim}▎ 思考 ▾ (第 ${idx} 段)${ui.reset}\n`);
+            layout.contentWrite(`${ui.dim}${content}${ui.reset}\n`);
+            if (!content.endsWith('\n'))
+                layout.contentWrite('\n');
+            continue;
+        }
+        if (line === '/rollback' || line.startsWith('/rollback ')) {
+            // /rollback:打开轮次菜单(↑/↓ 选,Enter 回滚到该轮并预填其输入,再 Enter 重新跑)。
+            // 忽略任何数字参数(原「输数字选回滚」已删,统一走菜单)。无快照的旧轮次(/resume 重建)文件改动不可撤销。
+            await rollbackFlow();
+            continue;
+        }
+        try {
+            const signal = startRunningListener(placeholder);
+            await runAgent(history, joined, collapsedThinkings, signal);
+            // 成功轮次自动落盘(崩溃也保住上一轮);新会话首轮分配 id
+            if (!currentSessionId)
+                currentSessionId = newSessionId();
+            try {
+                saveSession(history, currentSessionId);
+            }
+            catch {
+                // 落盘失败不阻断 REPL
+            }
+            persistSnapshots(currentSessionId); // 随会话落盘回滚快照(/resume 后仍可撤销)
+        }
+        catch (e) {
+            layout.contentWrite(`${ui.red}[错误]${ui.reset} ${e instanceof Error ? e.message : String(e)}\n`);
+        }
+        finally {
+            stopRunningListener();
+        }
+        layout.contentWrite('\n'); // 轮次之间空行
+    }
+    layout.exitAltScreen();
+}