mslxdff 0.1.55 → 0.1.56

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mslxdff",
-  "version": "0.1.55",
+  "version": "0.1.56",
   "description": "测试项目，请勿使用。",
   "type": "module",
   "bin": {
@@ -8,7 +8,8 @@
   },
   "scripts": {
     "start": "node bin/mslxdff.js",
-    "test": "node --test test/*.test.js"
+    "test": "node --test test/*.test.js",
+    "docs:check": "node scripts/docs-check.js"
   },
   "engines": {
     "node": ">=20"

package/src/chat/config.js

@@ -0,0 +1,10 @@
+export const CHAT_PREFERRED = "mimo-v2.5-free";
+export const CHAT_FALLBACK = "big-pickle";
+// 128k 上下文 *95% ≈ 121.6k tokens，按 ~3.3 字符/token 估算 ≈ 400k 字符
+// 接近 95% 再压缩，避免频繁摘要
+export const CHAT_HISTORY_MAX_CHARS = 400000;
+export const CHAT_KEEP_RECENT = 40;
+export const CHAT_SUMMARY_TRIGGER = 400000;
+export const CHAT_MAX_TOOL_LOOPS = 6;
+export const CHAT_TIMEOUT_MS = 30000;
+export const FORBIDDEN = ["-uninstall", "--uninstall"];

package/src/chat/index.js

@@ -0,0 +1,6 @@
+import { startRepl } from "./repl.js";
+
+export async function startChat({ singleShot } = {}) {
+  // 独立进程：本函数在用户终端前台运行，与 daemon 无父子关系，daemon 重启不影响
+  await startRepl({ singleShot });
+}

package/src/chat/prompt.js

@@ -0,0 +1,63 @@
+import { readFileSync, existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { logDir } from "../logs.js";
+import { nowShanghaiYMDHM } from "../time.js";
+
+const pkgRoot = join(dirname(fileURLToPath(import.meta.url)), "../..");
+
+function readMini() {
+  try {
+    const p = join(pkgRoot, "docs/cli_help_mini.md");
+    return readFileSync(p, "utf8");
+  } catch { return ""; }
+}
+
+function readModels() {
+  try {
+    const cache = join(logDir(), "models.json");
+    if (existsSync(cache)) {
+      const j = JSON.parse(readFileSync(cache, "utf8"));
+      const ids = (j.data || []).map((m) => m.id).filter(Boolean);
+      if (ids.length) return ids;
+    }
+  } catch {}
+  // 兜底：硬编码常见 free 模型，供离线时参考
+  return ["mimo-v2.5-free", "big-pickle", "deepseek-v4-flash-free", "hy3-free", "laguna-free", "kimi-k2-free", "nemotron-3-nano-free", "big-pickle"];
+}
+
+export function buildSystemPrompt({ modelsOverride } = {}) {
+  const mini = readMini();
+  const models = modelsOverride || readModels();
+  const now = nowShanghaiYMDHM();
+  // 按供应商分组，便于“bai有哪些模型”这类问题直接回答
+  const byProv = {};
+  for (const id of models) {
+    const slash = id.indexOf("/");
+    const prov = slash > 0 ? id.slice(0, slash) : "opencode";
+    if (!byProv[prov]) byProv[prov] = [];
+    byProv[prov].push(id);
+  }
+  const provSummary = Object.entries(byProv).map(([p, arr]) => `${p}(${arr.length}): ${arr.slice(0, 12).join(", ")}${arr.length > 12 ? " …" : ""}`).join(" | ");
+  return `你是 mslxdff 的终端助手，运行在用户本机，帮用户把自然语言翻译成精确的 mslxdff CLI 命令并执行。
+
+当前时间：${now}
+可用模型（你必须从中精确选择，禁止自创，共 ${models.length} 个）：${models.join(", ")}
+按供应商：${provSummary}
+
+${mini}
+
+规则：
+- 用户说简称你必须自行查“可用模型”找到全称，例如 hy3→hy3-free，mimo→mimo-v2.5-free，bigpickle→big-pickle。
+- 永远输出精确的命令与模型 id，大小写敏感。
+- 需要执行命令时调用 run_command，需要看文件时调用 read_file，需要检查网络/服务可用性时调用 curl。
+- curl 简写：upstream(=上游 https://opencode.ai/zen/v1/models)、local/health(=本机 /health)、local/models(=本机 /v1/models)，也支持完整 http(s) URL；会自动补上游头、本机 token 与已配置供应商 key（直连 https://api.b.ai/v1/models 会自动带 bai 的 key，无需手动加头）。
+- 查“某供应商有哪些模型”：优先直接用上方“可用模型”按前缀过滤回答（如 bai/ 开头的即 bai 供应商），无需调工具；如需实时刷新，调 curl local/models（GET，自动带本机 token）看网关聚合列表，或 curl https://api.b.ai/v1/models（自动带 key）看上游全量。禁止为此调用 -showtoken（本机 token 已自动注入）。
+- 禁止调用 -uninstall，包含即拒绝；-showtoken 仅在用户明确要求查看/调试本机 token 时才用，查模型/查供应商严禁调用。
+- 回复用中文，简洁友好，执行前后说明你在做什么。
+- 若用户只是闲聊/提问且可用模型列表已能回答，不调工具，直接回答。`;
+}
+
+export function getModelsForPrompt() {
+  return readModels();
+}

package/src/chat/repl.js

@@ -0,0 +1,245 @@
+import readline from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+import { performance } from "node:perf_hooks";
+import { buildSystemPrompt, getModelsForPrompt } from "./prompt.js";
+import { getToolDefs, execCommand, readFileTool, curlTool } from "./tools.js";
+import { chatWithFallback, summarizeHistory } from "./upstream.js";
+import { loadHistory, saveHistory, clearHistory, histPath, estimateChars, needsCompress } from "./store.js";
+import { CHAT_KEEP_RECENT, CHAT_MAX_TOOL_LOOPS, CHAT_PREFERRED, CHAT_FALLBACK } from "./config.js";
+import { formatBannerLines, formatStatsDetail, collectStats } from "./stats.js";
+import { createSpinner } from "./spinner.js";
+
+const SLASH_HELP = `自然语言直接说，斜杠快捷：
+  /help     本帮助
+  /stats    详细统计（网关 -d 的请求/延迟/模型）
+  /history  查看对话历史
+  /clear    清空历史
+  /exit     退出
+示例：设置 hy3 为默认模型 / 查看组列表 / 看最近20条日志 / 读一下 src/logs.js`;
+
+function printBanner() {
+  const { lines } = formatBannerLines();
+  for (const l of lines) console.log(l);
+  console.log(`\x1b[90m输入自然语言即可执行；/help 帮助，/stats 看网关统计，/exit 退出\x1b[0m`);
+  console.log(`\x1b[90m历史：${histPath()} · 仅拦截 -uninstall · 数据来自网关 -d，非本会话计数\x1b[0m`);
+}
+
+function trace(line) {
+  if (process.env.MSLXDFF_CHAT_TRACE === "0") return;
+  console.log(`\x1b[90m· ${line}\x1b[0m`);
+}
+
+async function maybeCompress(messages) {
+  if (!needsCompress(messages)) return [...messages];
+  const sys = messages[0];
+  const rest = messages.slice(1);
+  if (rest.length <= CHAT_KEEP_RECENT + 2) return [...messages];
+  const t0 = performance.now();
+  const toSummarize = rest.slice(0, -CHAT_KEEP_RECENT);
+  const keep = rest.slice(-CHAT_KEEP_RECENT);
+  const chars = estimateChars(messages);
+  trace(`[压缩] 触发 ${chars}字 > ${400000}阈值 · 待压 ${toSummarize.length}条 保留 ${keep.length}条`);
+  const summary = await summarizeHistory(toSummarize);
+  const dt = Math.round(performance.now() - t0);
+  if (!summary) {
+    trace(`[压缩] 失败/空 · ${dt}ms → 截断`);
+    return [sys, ...keep];
+  }
+  const summaryMsg = { role: "system", content: summary };
+  const next = [sys, summaryMsg, ...keep];
+  trace(`[压缩] 完成 ${toSummarize.length}条→${summary.length}字 · ${dt}ms · 新总量约 ${estimateChars(next)}字`);
+  return next;
+}
+
+async function runAgentTurn(userText, messages) {
+  const tools = getToolDefs();
+  messages.push({ role: "user", content: userText });
+  let loops = 0;
+  let lastModel = null;
+  let lastUsage = null;
+  let lastFallback = false;
+  let lastLatency = 0;
+  const t0 = performance.now();
+  const turnStart = performance.now();
+  trace(`[turn] 开始 "${userText.slice(0, 60)}${userText.length > 60 ? "…" : ""}" · 历史 ${messages.length}条 约 ${estimateChars(messages)}字`);
+  while (loops < CHAT_MAX_TOOL_LOOPS) {
+    const tLoop = performance.now();
+    const tComp = performance.now();
+    const cur = await maybeCompress(messages);
+    const compressMs = Math.round(performance.now() - tComp);
+    if (compressMs > 50) trace(`[loop ${loops}] 压缩耗时 ${compressMs}ms`);
+    messages.length = 0;
+    for (const m of cur) messages.push(m);
+    const tCall = performance.now();
+    const spinnerLabel = loops === 0 ? "已发送给 AI，等待回复中" : "AI 正在整理回复中";
+    const spinner = createSpinner(spinnerLabel);
+    spinner.start();
+    let res;
+    try {
+      res = await chatWithFallback({ messages, tools });
+    } finally {
+      const ms = Math.round(performance.now() - tCall);
+      spinner.stop(`\x1b[90m✓ AI 已回复 · ${ms}ms\x1b[0m`);
+    }
+    const llmMs = Math.round(performance.now() - tCall);
+    trace(`[loop ${loops}] LLM ${llmMs}ms${compressMs > 50 ? ` (含压缩 ${compressMs}ms)` : ""} · ${estimateChars(messages)}字上下文`);
+    lastLatency = llmMs;
+    if (!res.ok) {
+      const err = `大模型暂不可用：${res.error}`;
+      messages.push({ role: "assistant", content: err });
+      return { text: err, model: null, latency: lastLatency, usage: null, fallback: false, ok: false };
+    }
+    lastModel = res.model;
+    lastUsage = res.usage || null;
+    lastFallback = !!res.fallback;
+    const msg = res.message;
+    const toolCalls = msg.tool_calls || [];
+    let fallbackCmd = null;
+    if (!toolCalls.length && msg.content) {
+      const m = String(msg.content).match(/\{[^}]*"command"\s*:\s*"([^"]+)"[^}]*\}/);
+      if (m) fallbackCmd = m[1];
+    }
+    if (!toolCalls.length && !fallbackCmd) {
+      const text = String(msg.content || "").trim() || "(空回复)";
+      messages.push({ role: "assistant", content: text });
+      const totalMs = Math.round(performance.now() - t0);
+      const note = lastFallback ? "\n\x1b[90m[注：mimo 不可用，已用 big-pickle]\x1b[0m" : "";
+      trace(`[turn] 完成 总计 ${totalMs}ms · LLM ${lastLatency}ms · 0 工具`);
+      return { text: text + note, model: lastModel, latency: lastLatency, usage: lastUsage, fallback: lastFallback, ok: true, totalMs };
+    }
+    const calls = toolCalls.length ? toolCalls : [{ id: "fallback-1", function: { name: "run_command", arguments: JSON.stringify({ command: fallbackCmd }) } }];
+    messages.push({ role: "assistant", content: msg.content || "", tool_calls: calls.map((c) => ({ id: c.id, type: "function", function: c.function })) });
+    trace(`[tools] 本轮 ${calls.length} 个调用 ${calls.map((c) => c.function?.name).join(",")} · 并发执行`);
+    const tTools = performance.now();
+    const toolResults = await Promise.all(calls.map(async (c) => {
+      const name = c.function?.name;
+      let args = {};
+      try { args = JSON.parse(c.function?.arguments || "{}"); } catch {}
+      const t1 = performance.now();
+      let result;
+      if (name === "run_command") {
+        const cmd = String(args.command || "").trim();
+        console.log(`\x1b[90m→ 执行: mslxdff ${cmd}\x1b[0m`);
+        const r = await execCommand(cmd);
+        result = `${r.ok ? "OK" : "FAIL"}: ${r.output}`;
+        const dt = Math.round(performance.now() - t1);
+        trace(`[tool] run_command "${cmd.slice(0, 40)}" · ${dt}ms · ${r.ok ? "OK" : "FAIL"} ${r.output.length}字`);
+        console.log(r.ok ? `\x1b[32m${r.output.slice(0, 800)}\x1b[0m` : `\x1b[31m${r.output.slice(0, 800)}\x1b[0m`);
+      } else if (name === "read_file") {
+        const r = await readFileTool(args);
+        result = `${r.ok ? "OK" : "FAIL"}: ${r.output.slice(0, 6000)}`;
+        const dt = Math.round(performance.now() - t1);
+        trace(`[tool] read_file ${args.path} · ${dt}ms · ${r.ok ? "OK" : "FAIL"} ${r.output.length}字`);
+        console.log(`\x1b[90m→ 读取: ${args.path} ${r.ok ? "OK" : "FAIL"}\x1b[0m`);
+      } else if (name === "curl") {
+        const u = String(args.url || "").trim();
+        console.log(`\x1b[90m→ 探活: ${u} ${args.method || "GET"}\x1b[0m`);
+        const r = await curlTool(args);
+        result = `${r.ok ? "OK" : "FAIL"}: ${r.output.slice(0, 6000)}`;
+        const dt = Math.round(performance.now() - t1);
+        trace(`[tool] curl ${u} · ${dt}ms`);
+        console.log(r.ok ? `\x1b[32m${r.output.slice(0, 800)}\x1b[0m` : `\x1b[31m${r.output.slice(0, 800)}\x1b[0m`);
+      } else {
+        result = `unknown tool ${name}`;
+      }
+      return { id: c.id, content: result };
+    }));
+    for (const tr of toolResults) messages.push({ role: "tool", tool_call_id: tr.id, content: tr.content });
+    const toolsMs = Math.round(performance.now() - tTools);
+    const loopMs = Math.round(performance.now() - tLoop);
+    trace(`[loop ${loops}] 工具 ${toolsMs}ms · 本轮总 ${loopMs}ms · 累计 ${Math.round(performance.now() - turnStart)}ms`);
+    loops++;
+  }
+  return { text: "（工具调用次数已达上限，已停止）", model: lastModel, latency: lastLatency, usage: lastUsage, fallback: lastFallback, ok: false };
+}
+
+function printFooter({ model, latency, usage, totalMs, fallback }) {
+  const dim = "\x1b[90m";
+  const rst = "\x1b[0m";
+  let gw = null;
+  try { gw = collectStats(); } catch {}
+  const modelLabel = model || "—";
+  const latLabel = latency ? `${latency}ms` : "—";
+  const totalLabel = totalMs ? ` · 总耗时 ${totalMs}ms` : "";
+  const tokLabel = usage ? ` · tokens ${usage.prompt_tokens ?? "?"}→${usage.completion_tokens ?? "?"}` : "";
+  const fbLabel = fallback ? " · fallback" : "";
+  let gwLabel = "";
+  if (gw) {
+    const cnt = gw.latencies?.[model]?.count;
+    const ema = gw.latencies?.[model]?.emaMs;
+    const per = cnt ? ` · 网关该模型 ${cnt}次 EMA ${ema}ms` : "";
+    gwLabel = ` · 网关 总${gw.total} 成功${gw.success} 失败${gw.fail}${per}`;
+  }
+  console.log(`${dim}─ ${modelLabel}  ${latLabel}${totalLabel}${tokLabel}${fbLabel}${gwLabel}${rst}`);
+}
+
+export async function startRepl({ singleShot } = {}) {
+  const models = getModelsForPrompt();
+  const system = buildSystemPrompt({ modelsOverride: models });
+  let messages = [{ role: "system", content: system }];
+  const hist = loadHistory();
+  if (hist.length) {
+    for (const h of hist) messages.push(h);
+    console.log(`\x1b[90m[恢复] 已载入 ${hist.length} 条历史\x1b[0m`);
+  }
+  if (singleShot) {
+    const text = String(singleShot).trim();
+    if (!text) return;
+    const r = await runAgentTurn(text, messages);
+    console.log(r.text);
+    if (r.model) printFooter(r);
+    saveHistory(messages.slice(1));
+    return;
+  }
+  printBanner();
+  const rl = readline.createInterface({ input: stdin, output: stdout, prompt: `\x1b[36m${CHAT_PREFERRED.split("-")[0]}>\x1b[0m ` });
+  rl.prompt();
+  for await (const line of rl) {
+    const raw = String(line || "").trim();
+    if (!raw) { rl.prompt(); continue; }
+    const low = raw.toLowerCase();
+    if (["/exit", "/quit", "exit", "quit", "退出"].includes(low)) {
+      console.log("再见");
+      saveHistory(messages.slice(1));
+      rl.close();
+      return;
+    }
+    if (["/help", "help", "/h", "?"].includes(low)) {
+      console.log(SLASH_HELP);
+      rl.prompt();
+      continue;
+    }
+    if (["/stats", "/status", "stats", "status"].includes(low)) {
+      console.log(formatStatsDetail());
+      rl.prompt();
+      continue;
+    }
+    if (["/clear", "clear"].includes(low)) {
+      clearHistory();
+      messages = [{ role: "system", content: system }];
+      console.log("\x1b[90m[已清空历史]\x1b[0m");
+      rl.prompt();
+      continue;
+    }
+    if (["/history"].includes(low)) {
+      console.log(`\x1b[90m历史 ${messages.length - 1} 条，约 ${estimateChars(messages)} 字符 · ${histPath()}\x1b[0m`);
+      for (const m of messages.slice(1).slice(-10)) console.log(`- ${m.role}: ${(m.content || "").slice(0, 120)}`);
+      rl.prompt();
+      continue;
+    }
+    try {
+      const r = await runAgentTurn(raw, messages);
+      if (r.text && !r.text.startsWith("OK") && !r.text.startsWith("FAIL")) console.log(r.text);
+      if (r.model || r.latency) printFooter(r);
+    } catch (e) {
+      console.log(`\x1b[31m[错误] ${String(e.message || e).slice(0, 800)}\x1b[0m`);
+      messages.push({ role: "assistant", content: `error: ${String(e.message || e)}` });
+    }
+    saveHistory(messages.slice(1));
+    if (needsCompress(messages)) {
+      messages = await maybeCompress(messages);
+      saveHistory(messages.slice(1));
+    }
+    rl.prompt();
+  }
+}

package/src/chat/spinner.js

@@ -0,0 +1,38 @@
+import { stdout } from "node:process";
+import { performance } from "node:perf_hooks";
+
+export function createSpinner(label) {
+  const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+  let i = 0;
+  let t0 = performance.now();
+  let timer = null;
+  let active = false;
+  const isTTY = stdout.isTTY;
+  function start() {
+    if (active) return;
+    active = true;
+    t0 = performance.now();
+    if (!isTTY) {
+      console.log(`\x1b[90m${label}…\x1b[0m`);
+      return;
+    }
+    timer = setInterval(() => {
+      const sec = ((performance.now() - t0) / 1000).toFixed(1);
+      const f = frames[i++ % frames.length];
+      stdout.write(`\r\x1b[90m${f} ${label}… ${sec}s\x1b[0m`);
+    }, 180);
+    timer.unref?.();
+  }
+  function stop(finalMsg) {
+    if (!active) return;
+    active = false;
+    if (timer) { clearInterval(timer); timer = null; }
+    if (isTTY) {
+      stdout.write("\r\x1b[K");
+      if (finalMsg) console.log(finalMsg);
+    } else if (finalMsg) {
+      console.log(finalMsg);
+    }
+  }
+  return { start, stop };
+}

package/src/chat/stats.js

@@ -0,0 +1,170 @@
+import { readFileSync, existsSync } from "node:fs";
+import { getPreferredModel } from "../auto.js";
+import { loadModelLatencies, loadModelErrors, loadModelPicks, getPort } from "../state.js";
+import { logDir, callsFile, errorsFile, recentCalls, lastError } from "../logs.js";
+import { fmtShanghai } from "../time.js";
+import { CHAT_PREFERRED, CHAT_FALLBACK } from "./config.js";
+
+function readLinesCount(file) {
+  try {
+    if (!existsSync(file)) return 0;
+    const txt = readFileSync(file, "utf8");
+    if (!txt.trim()) return 0;
+    return txt.split("\n").filter(Boolean).length;
+  } catch { return 0; }
+}
+
+function fmtLatency(entry) {
+  if (!entry || !entry.emaMs) return "—";
+  const ema = entry.emaMs;
+  const cnt = entry.count ? ` · ${entry.count}次` : "";
+  const last = entry.lastMs ? ` (末次 ${entry.lastMs}ms)` : "";
+  return `${ema}ms${cnt}${last}`;
+}
+
+function fmtStatus(entry) {
+  if (!entry) return "normal";
+  if (typeof entry === "number") return "error";
+  return entry.status || "normal";
+}
+
+export function collectStats() {
+  const gatewayModel = getPreferredModel();
+  const latencies = loadModelLatencies();
+  const errors = loadModelErrors();
+  const picks = loadModelPicks();
+  const port = getPort() ?? (Number(process.env.MSLXDFF_PORT) > 0 ? Number(process.env.MSLXDFF_PORT) : 8989);
+  const chatPrefLat = latencies[CHAT_PREFERRED] || null;
+  const chatFallLat = latencies[CHAT_FALLBACK] || null;
+  const gatewayLat = latencies[gatewayModel] || null;
+
+  // gateway totals — 来自 -d 进程的持久化日志（非本 -chat 会话）
+  const cf = callsFile();
+  const ef = errorsFile();
+  const totalCalls = readLinesCount(cf);
+  const totalErrs = readLinesCount(ef);
+  const recent = recentCalls(5);
+  const lastErr = lastError();
+
+  // cache model counts + ids
+  let freeCount = 0;
+  let cachedAt = null;
+  let freeIds = [];
+  try {
+    const cacheFile = `${logDir()}/models.json`;
+    if (existsSync(cacheFile)) {
+      const j = JSON.parse(readFileSync(cacheFile, "utf8"));
+      if (Array.isArray(j.data)) {
+        freeIds = j.data.map((m) => m.id).filter(Boolean);
+        freeCount = freeIds.length;
+      }
+      cachedAt = j.cachedAt || null;
+    }
+  } catch {}
+  const freeSet = new Set(freeIds);
+
+  // per-model daemon detail (for /stats) — 只展示网关认识的 free 模型，避免测试假数据污染
+  const allIds = Object.keys({ ...latencies, ...errors }).filter(Boolean);
+  const filteredIds = freeIds.length
+    ? allIds.filter((id) => freeSet.has(id) || id === gatewayModel || id === CHAT_PREFERRED || id === CHAT_FALLBACK)
+    : allIds.filter((id) => !/^m-(one|two)-free$|^a-free$|^b-free$|^c-free$|^ghost-/.test(id) && !id.startsWith("test-"));
+  const perModel = filteredIds
+    .map((id) => ({
+      id,
+      lat: latencies[id] || null,
+      status: fmtStatus(errors[id]),
+      at: errors[id]?.at || latencies[id]?.at || 0,
+    }))
+    .sort((a, b) => (b.lat?.count || 0) - (a.lat?.count || 0) || (b.at - a.at));
+
+  return {
+    gatewayModel,
+    gatewayLat,
+    chatPref: CHAT_PREFERRED,
+    chatFall: CHAT_FALLBACK,
+    chatPrefLat,
+    chatFallLat,
+    chatPrefStatus: fmtStatus(errors[CHAT_PREFERRED]),
+    chatFallStatus: fmtStatus(errors[CHAT_FALLBACK]),
+    gatewayStatus: fmtStatus(errors[gatewayModel]),
+    picks,
+    port,
+    totalCalls,
+    totalErrs,
+    total: totalCalls + totalErrs,
+    success: totalCalls,
+    fail: totalErrs,
+    recent,
+    lastErr,
+    freeCount,
+    cachedAt,
+    healthUrl: `http://127.0.0.1:${port}/health`,
+    endpointUrl: `http://127.0.0.1:${port}/v1`,
+    latencies,
+    errors,
+    perModel,
+  };
+}
+
+export function formatBannerLines() {
+  const s = collectStats();
+  const dim = "\x1b[90m";
+  const rst = "\x1b[0m";
+  const cyan = "\x1b[36m";
+  const yellow = "\x1b[33m";
+  const green = "\x1b[32m";
+  const lines = [];
+  lines.push(`${cyan}┌─ mslxdff chat  ·  数据来自 -d 网关进程（非本会话） ─────${rst}`);
+  lines.push(`${cyan}│${rst}  对话模型  ${yellow}${s.chatPref}${rst} ${dim}→ ${s.chatFall}（自动降级）${rst}  ${dim}[${s.chatPrefStatus}/${s.chatFallStatus}]${rst}`);
+  lines.push(`${cyan}│${rst}  网关默认  ${green}${s.gatewayModel}${rst} ${dim}[${s.gatewayStatus}]${rst}  ·  端口 ${s.port}  ·  ${dim}${s.endpointUrl}${rst}`);
+  const prefLine = `mimo ${fmtLatency(s.chatPrefLat)}`;
+  const fallLine = `pickle ${fmtLatency(s.chatFallLat)}`;
+  const gateLine = s.gatewayModel !== s.chatPref && s.gatewayModel !== s.chatFall ? ` · 网关默认 ${fmtLatency(s.gatewayLat)}` : "";
+  lines.push(`${cyan}│${rst}  网关延迟 ${prefLine}  ·  ${fallLine}${gateLine}`);
+  const errWhen = s.lastErr?.ts ? fmtShanghai(s.lastErr.ts) : "—";
+  const errMsg = s.lastErr?.message ? String(s.lastErr.message).slice(0, 40) : (s.lastErr?.status ? `HTTP ${s.lastErr.status}` : "无");
+  lines.push(`${cyan}│${rst}  网关请求  总 ${s.total}  成功 ${s.success}  失败 ${s.fail}  ${dim}· 末错 ${errWhen} ${errMsg}${rst}`);
+  const cacheInfo = s.freeCount ? `${s.freeCount} free` : "—";
+  const picksInfo = s.picks.length ? `${s.picks.length} 已选` : "未筛选";
+  lines.push(`${cyan}│${rst}  模型库   ${cacheInfo}  ·  勾选 ${picksInfo}  ${dim}${s.picks.slice(0, 3).join(", ") || ""}${s.picks.length > 3 ? " …" : ""}${rst}`);
+  lines.push(`${cyan}│${rst}  健康     ${dim}${s.healthUrl}${rst}  ${dim}· 日志 ${recentCalls(1).length ? "有" : "暂无"} · 上海时间${rst}`);
+  lines.push(`${cyan}└──────────────────────────────────────────────────${rst}`);
+  return { lines, stats: s };
+}
+
+export function formatStatsDetail() {
+  const s = collectStats();
+  const dim = "\x1b[90m";
+  const rst = "\x1b[0m";
+  const cyan = "\x1b[36m";
+  const out = [];
+  out.push(`${dim}── 网关详细统计（-d 进程持久化数据） ──────────${rst}`);
+  out.push(`网关默认: ${s.gatewayModel} [${s.gatewayStatus}] 延迟 ${fmtLatency(s.gatewayLat)}  端口 ${s.port}`);
+  out.push(`对话模型: ${s.chatPref} [${s.chatPrefStatus}] ${fmtLatency(s.chatPrefLat)}  ·  兜底 ${s.chatFall} [${s.chatFallStatus}] ${fmtLatency(s.chatFallLat)}`);
+  out.push(`健康: ${s.healthUrl}  端点: ${s.endpointUrl}`);
+  out.push(`网关请求: 总 ${s.total}  成功 ${s.success}  失败 ${s.fail}  ${dim}(calls.log + errors.log 持久化计数)${rst}`);
+  if (s.lastErr) {
+    out.push(`末次错误: ${fmtShanghai(s.lastErr.ts)}  ${s.lastErr.model || ""}  ${s.lastErr.status || ""}  ${String(s.lastErr.message || "").slice(0, 80)}`);
+  } else {
+    out.push(`末次错误: 无`);
+  }
+  out.push(`勾选集: ${s.picks.length ? s.picks.join(", ") : "(空=全量 auto)"}  ·  模型库: ${s.freeCount || 0} free  缓存: ${s.cachedAt ? fmtShanghai(s.cachedAt) : "—"}`);
+  if (s.perModel.length) {
+    out.push(`各模型网关统计（按成功次数排序）:`);
+    for (const r of s.perModel.slice(0, 10)) {
+      const lat = r.lat ? `${r.lat.emaMs}ms·${r.lat.count}次` : "—";
+      const at = r.at ? fmtShanghai(r.at) : "—";
+      out.push(`  ${r.id.padEnd(28)}  ${r.status.padEnd(6)}  ${lat.padEnd(16)}  ${at}`);
+    }
+    if (s.perModel.length > 10) out.push(`  … 还有 ${s.perModel.length - 10} 个模型`);
+  }
+  if (s.recent.length) {
+    out.push(`最近网关调用（calls.log 最近5条）:`);
+    for (const r of s.recent.slice(-5)) {
+      out.push(`  ${fmtShanghai(r.ts)}  ${(r.model || "-").padEnd(22)}  ${String(r.status || "-").padEnd(4)}  ${r.durationMs ? r.durationMs + "ms" : ""} ${r.stream ? "stream" : ""}`);
+    }
+  }
+  out.push(`${dim}提示：以上均为 -d 网关进程的持久化数据，非本 -chat 会话计数。看实时事件用 mslxdff -log 20${rst}`);
+  out.push(`${dim}──────────────────────────────────────${rst}`);
+  return out.join("\n");
+}

package/src/chat/store.js

@@ -0,0 +1,48 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { defaultStateFile } from "../state.js";
+import { CHAT_HISTORY_MAX_CHARS } from "./config.js";
+
+function histFile() {
+  const base = process.env.MSLXDFF_CHAT_HISTORY || join(dirname(defaultStateFile()), "chat-history.json");
+  return base;
+}
+
+export function loadHistory() {
+  try {
+    if (!existsSync(histFile())) return [];
+    const raw = readFileSync(histFile(), "utf8");
+    const arr = JSON.parse(raw);
+    return Array.isArray(arr) ? arr : [];
+  } catch { return []; }
+}
+
+export function saveHistory(arr) {
+  try {
+    const f = histFile();
+    mkdirSync(dirname(f), { recursive: true });
+    // 128k 上下文下保留更多历史，配合 400k 阈值
+    const slim = arr.slice(-120);
+    writeFileSync(f, JSON.stringify(slim, null, 2));
+  } catch {}
+}
+
+export function clearHistory() {
+  saveHistory([]);
+}
+
+export function histPath() { return histFile(); }
+
+export function estimateChars(messages) {
+  let n = 0;
+  for (const m of messages) {
+    n += String(m.content || "").length;
+    if (m.tool_calls) n += JSON.stringify(m.tool_calls).length;
+    if (m.tool_call_id) n += 200;
+  }
+  return n;
+}
+
+export function needsCompress(messages) {
+  return estimateChars(messages) > CHAT_HISTORY_MAX_CHARS;
+}