arona-agent 1.0.0

package/src/pet.ts

@@ -0,0 +1,346 @@
+import { spawn, type ChildProcessWithoutNullStreams } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import chalk from "chalk";
+import { PET_DIR, verbose } from "./config.ts";
+import { getMainAgent, getSubAgents, type AgentId } from "./agent_registry.ts";
+import { t } from "./locale.ts";
+
+/** 桌宠要注入到下一轮用户消息的手势事件类型（摸头 / dizzy） */
+export type PetGestureType = "pat" | "dizzy";
+
+const PREFIX = "###PET###";
+const MAX_RESTARTS = 3;
+const STDERR_RING_SIZE = 100; // 崩溃时 dump 的 stderr 最近行数
+// Electron 42+ 移除了 postinstall 自动下载：二进制改为首次 require 时才按需下载（供应链安全考虑）。
+// pet 桥是项目里唯一 require("electron") 的地方，这里用国内镜像在 import 之前手动预下载，
+// 避免首次启动时 CLI 卡在慢速的 GitHub Releases 下载上。
+const ELECTRON_DIR = join(PET_DIR, "..", "node_modules", "electron");
+const ELECTRON_MIRROR = "https://mirrors.tuna.tsinghua.edu.cn/npm/electron";
+
+// --verbose 调试日志：原样转发 Electron stdout/stderr、spawn 参数、协议消息，
+// 用于锁定 Windows 白屏等"进程活着但无画面"类问题（正常模式这些日志被静默/过滤）。
+function vlog(...args: unknown[]): void {
+  if (verbose) console.error(chalk.gray("[pet:verbose]"), ...args);
+}
+
+/** 与 electron/install.js getPlatformPath() 保持一致：各平台可执行文件的相对路径 */
+function electronPlatformPath(): string {
+  if (process.platform === "win32") return "electron.exe";
+  if (process.platform === "darwin") return "Electron.app/Contents/MacOS/Electron";
+  return "electron";
+}
+
+/** dist 二进制是否已就绪（版本匹配 + 可执行文件存在），与 install.js 的 isInstalled() 判定一致 */
+function isElectronInstalled(): boolean {
+  try {
+    const pkg = JSON.parse(readFileSync(join(ELECTRON_DIR, "package.json"), "utf-8"));
+    const version = readFileSync(join(ELECTRON_DIR, "dist", "version"), "utf-8").replace(/^v/, "");
+    return version === pkg.version && existsSync(join(ELECTRON_DIR, "dist", electronPlatformPath()));
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Desktop pet bridge: spawns the Electron pet window as a subprocess and
+ * talks to it via stdin/stdout JSON lines (protocol lines prefixed with
+ * ###PET### to filter Electron's own stdout noise).
+ *
+ * All commands are fire-and-forget — the pet is not a critical path.
+ */
+class PetBridge {
+  private proc: ChildProcessWithoutNullStreams | null = null;
+  private buffer = "";
+  private intentionalStop = false;
+  private restartCount = 0;
+  private restartTimer: ReturnType<typeof setTimeout> | null = null;
+  // stderr 环形缓冲：进程异常退出时 dump 最近输出，便于定位崩溃根因
+  private stderrRing: string[] = [];
+  // 当前桌宠角色（ARONA_AGENT env 传给 pet/main.cjs）；默认跟随 settings.json mainAgent
+  private agentId: AgentId = getMainAgent();
+  // 当前启用的子 Agent（ARONA_SUB_AGENTS env 传给 pet/main.cjs）；默认跟随 settings.json subAgents
+  private subAgents: AgentId[] = getSubAgents();
+  // 待切换角色组合：stop() 后等待旧进程 close 再以新组合拉起（避免双窗口闪现）
+  private pendingSelection: { main: AgentId; subs: AgentId[] } | null = null;
+  // 最近一次桌宠手势（摸头/dizzy）：只保留最新一次，供下一条用户消息注入一次后即消费清空
+  private latestGesture: PetGestureType | null = null;
+
+  /**
+   * Electron 42+ 把二进制下载从 postinstall 挪到了首次 require，而 pet 桥是唯一
+   * require("electron") 的地方。这里在 import 之前抢先检查 dist 是否就绪：
+   * 未就绪则用国内镜像手动执行预下载脚本（install.js 与原 postinstall 同代码、自带幂等检查），
+   * 并给下载过程让出一段专属输出区域提示用户等待。
+   *
+   * @returns "missing" = electron npm 包未安装;true = 已就绪或下载成功;false = 下载失败
+   */
+  private async ensureElectronBinary(): Promise<true | false | "missing"> {
+    if (!existsSync(join(ELECTRON_DIR, "package.json"))) return "missing";
+    if (isElectronInstalled()) return true;
+
+    // 下载期间只显示一行提示，忽略 --verbose；install.js 的进度/冗余输出全部静默（stdio 不继承）
+    console.log(chalk.cyan(t("  正在使用国内源下载Electron……", "  Downloading Electron from CN mirror…")));
+
+    const ok = await new Promise<boolean>((resolve) => {
+      const child = spawn(process.execPath, [join(ELECTRON_DIR, "install.js")], {
+        // 注入国内镜像；用户若已自定义 ELECTRON_MIRROR 则尊重其配置
+        env: { ...process.env, ELECTRON_MIRROR: process.env.ELECTRON_MIRROR ?? ELECTRON_MIRROR },
+        // 默认静默（只显示一行提示）；--verbose 时转发 install.js 全量输出便于排障
+        stdio: verbose ? "inherit" : "ignore",
+      });
+      child.on("error", (err) => {
+        console.warn(chalk.yellow(t(`桌宠：无法启动 Electron 安装器（${err.message}）。`, `Pet: failed to launch Electron installer (${err.message}).`)));
+        resolve(false);
+      });
+      child.on("exit", (code) => {
+        if (code !== 0) {
+          console.warn(chalk.yellow(t("桌宠：Electron 下载失败，已跳过桌宠，可稍后重试。", "Pet: Electron download failed, pet skipped; retry later.")));
+          resolve(false);
+          return;
+        }
+        console.log(chalk.green(t("  ✓ Electron 安装完成", "  ✓ Electron installed")));
+        resolve(true);
+      });
+    });
+    return ok;
+  }
+
+  async start(): Promise<void> {
+    // Headless 环境降级（Linux 无显示服务器时直接跳过）
+    if (process.platform === "linux" && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY) {
+      console.warn(chalk.yellow(t("桌宠：无显示服务器，跳过启动。", "Pet: no display server, skipping startup.")));
+      return;
+    }
+
+    // 未安装 electron 包 → 维持原有降级提示；下载失败 → 提示已在 ensureElectronBinary 内输出
+    const binaryState = await this.ensureElectronBinary();
+    if (binaryState === "missing") {
+      console.warn(chalk.yellow(t("桌宠：未安装 electron，跳过启动（npm install -D electron）。", "Pet: electron not installed, skipping startup (npm install -D electron).")));
+      return;
+    }
+    if (binaryState === false) return;
+
+    let electronPath: string;
+    try {
+      // electron 包默认导出二进制路径字符串
+      const mod = await import("electron");
+      electronPath = mod.default as unknown as string;
+    } catch {
+      console.warn(chalk.yellow(t("桌宠：electron 加载失败，跳过启动。", "Pet: failed to load electron, skipping startup.")));
+      return;
+    }
+
+    this.intentionalStop = false;
+
+    try {
+      // 剔除 ELECTRON_RUN_AS_NODE，否则 Electron 会退化为纯 Node 运行；
+      // 注入 ARONA_AGENT 让桌宠主进程选择主角色，ARONA_SUB_AGENTS 选择子角色窗口（agents.cjs）
+      const env: NodeJS.ProcessEnv = {
+        ...process.env,
+        ARONA_AGENT: this.agentId,
+        ARONA_SUB_AGENTS: this.subAgents.join(","),
+      };
+      delete env.ELECTRON_RUN_AS_NODE;
+      // --no-sandbox：部分环境（权限受限的终端/容器）无法初始化 Chromium sandbox；
+      // 桌宠只加载本地文件，关闭 sandbox 风险可接受
+      const args = ["--no-sandbox"];
+      if (verbose) {
+        // --enable-logging：把渲染进程 console（WebGL/GPU 初始化失败等）原样打进 stderr——
+        // 不传的话 renderer 的 console.error 默认只进 devtools，白屏根因完全不可见。
+        // 同时用 env 通知 pet/main.cjs 输出主进程详细日志。
+        args.push("--enable-logging");
+        env.ARONA_PET_VERBOSE = "1";
+        vlog("spawn", electronPath, args.concat(join(PET_DIR, "main.cjs")), "main=", this.agentId, "subs=", this.subAgents.join(","));
+      }
+      this.proc = spawn(electronPath, args.concat(join(PET_DIR, "main.cjs")), {
+        env,
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+    } catch (err) {
+      console.warn(chalk.yellow(t(`桌宠：启动失败（${err instanceof Error ? err.message : err}），已降级。`, `Pet: failed to start (${err instanceof Error ? err.message : err}), degraded.`)));
+      this.proc = null;
+      return;
+    }
+
+    this.proc.stdout.on("data", (data) => {
+      this.buffer += data.toString();
+      const lines = this.buffer.split("\n");
+      this.buffer = lines.pop() || "";
+      for (const line of lines) this.handleLine(line);
+    });
+
+    this.proc.stderr.on("data", (data) => {
+      const msg = data.toString().trim();
+      if (!msg) return;
+      // 始终入环（崩溃时 dump 用）；平时仅打印非空且不常见的错误
+      this.stderrRing.push(msg);
+      if (this.stderrRing.length > STDERR_RING_SIZE) this.stderrRing.shift();
+      // verbose：原样转发全部 stderr（不过滤 dbus/GLib——它们可能夹带关键渲染日志）
+      if (verbose || (!msg.includes("dbus") && !msg.includes("GLib"))) {
+        console.error(chalk.gray("[pet]"), msg);
+      }
+    });
+
+    this.proc.on("error", (err) => {
+      vlog("spawn error:", err.message);
+      console.warn(chalk.yellow(t(`桌宠：进程错误（${err.message}），已降级。`, `Pet: process error (${err.message}), degraded.`)));
+      this.proc = null;
+    });
+
+    this.proc.on("close", (code, signal) => {
+      vlog("process closed", { code, signal, intentional: this.intentionalStop, pendingSelection: this.pendingSelection });
+      this.proc = null;
+      if (this.pendingSelection) {
+        // 切换角色：旧进程已退出，以新角色组合重新拉起（stop 时 intentionalStop=true 不会走退避重启）
+        const sel = this.pendingSelection;
+        this.pendingSelection = null;
+        this.agentId = sel.main;
+        this.subAgents = sel.subs;
+        void this.start();
+      } else if (!this.intentionalStop && (code === null || code !== 0)) {
+        // 正常退出（code 0）不重启；被信号终止（code null）或异常退出才视为崩溃
+        console.warn(chalk.yellow(t(`桌宠：进程异常退出（code=${code} signal=${signal}），准备重启。`, `Pet: process exited abnormally (code=${code} signal=${signal}), restarting.`)));
+        this.dumpStderr();
+        this.scheduleRestart();
+      }
+    });
+  }
+
+  /** 崩溃时输出 Electron 最近 stderr（渲染崩溃/主进程异常堆栈都在这里） */
+  private dumpStderr(): void {
+    if (!this.stderrRing.length) return;
+    console.error(chalk.gray(`[pet:stderr] 最近 ${this.stderrRing.length} 行输出（定位崩溃用）：\n` + this.stderrRing.join("\n")));
+    this.stderrRing = [];
+  }
+
+  private scheduleRestart(): void {
+    if (this.restartCount >= MAX_RESTARTS) {
+      console.warn(chalk.yellow(t("桌宠：崩溃次数过多，已放弃重启。", "Pet: too many crashes, giving up restarting.")));
+      return;
+    }
+    const delay = 1000 * 2 ** this.restartCount; // 1s / 2s / 4s
+    this.restartCount++;
+    this.restartTimer = setTimeout(() => {
+      this.restartTimer = null;
+      void this.start();
+    }, delay);
+  }
+
+  private handleLine(line: string): void {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith(PREFIX)) return;
+    let msg: any;
+    try {
+      msg = JSON.parse(trimmed.slice(PREFIX.length));
+    } catch {
+      return;
+    }
+    vlog("recv", JSON.stringify(msg));
+    if (msg.type === "ready") {
+      this.restartCount = 0; // 成功启动后重置退避计数
+    } else if (msg.type === "error") {
+      console.error(chalk.gray("[pet]"), msg.message);
+    } else if (msg.type === "crash") {
+      // 渲染/GPU 子进程崩溃上报（pet/main.cjs 的 render-process-gone / child-process-gone）
+      console.error(chalk.red(`[pet:crash] ${msg.kind ?? "process"} reason=${msg.reason ?? "?"} exitCode=${msg.exitCode ?? "?"} url=${msg.url ?? ""}`));
+      // verbose：附带原始 detail（main.cjs 在 ARONA_PET_VERBOSE 下会补全字段）
+      vlog("crash detail:", JSON.stringify(msg));
+    } else if (msg.type === "shake") {
+      // 摸头：记录最新手势。仅主 Agent 事件（sub 无摸头），无需区分 agent。
+      this.latestGesture = "pat";
+    } else if (msg.type === "dizzy") {
+      this.latestGesture = "dizzy";
+    }
+    // moved 目前仅作日志用途，无需处理
+  }
+
+  /**
+   * 取走待注入的手势且只保留最近一次：消费即清空，避免重复注入。
+   * 返回 null 表示没有待注入手势（用户没有摸头/dizzy，正常只发普通消息）。
+   */
+  takeGesture(): PetGestureType | null {
+    const g = this.latestGesture;
+    this.latestGesture = null;
+    return g;
+  }
+
+  private send(msg: Record<string, unknown>): void {
+    if (!this.proc || this.proc.killed) return;
+    vlog("send", JSON.stringify(msg));
+    try {
+      this.proc.stdin.write(JSON.stringify(msg) + "\n");
+    } catch {
+      // stdin 已关闭，忽略
+    }
+  }
+
+  setEmotion(agentId: AgentId, name: string): void {
+    this.send({ type: "set_emotion", agent: agentId, name });
+  }
+
+  sendText(agentId: AgentId, kind: string, data: string): void {
+    this.send({ type: "text", agent: agentId, kind, data });
+  }
+
+  reset(): void {
+    this.send({ type: "reset" });
+  }
+
+  /**
+   * 切换桌宠主角色（子 Agent 组合保持当前值）。
+   * 运行中：先 stop（intentional，不触发退避重启），旧进程 close 后再以新组合拉起，避免双窗口闪现。
+   * 未运行：直接记住角色，下次 start() 生效。
+   */
+  restartWithAgent(id: AgentId): void {
+    this.restartWithSelection(id, this.subAgents);
+  }
+
+  /**
+   * 切换主角色 + 子角色组合（pet/main.cjs 按 ARONA_AGENT + ARONA_SUB_AGENTS 创建多窗口）。
+   */
+  restartWithSelection(main: AgentId, subs: readonly AgentId[]): void {
+    if (!this.isRunning) {
+      this.agentId = main;
+      this.subAgents = [...subs];
+      void this.start();
+      return;
+    }
+    this.pendingSelection = { main, subs: [...subs] };
+    this.stop();
+  }
+
+  stop(): void {
+    this.intentionalStop = true;
+    if (this.restartTimer) {
+      clearTimeout(this.restartTimer);
+      this.restartTimer = null;
+    }
+    if (this.proc && !this.proc.killed) {
+      this.send({ type: "quit" });
+      try {
+        this.proc.stdin.end();
+      } catch {
+        // 忽略
+      }
+      const proc = this.proc;
+      setTimeout(() => {
+        if (!proc.killed) proc.kill("SIGTERM");
+      }, 500);
+      this.proc = null;
+    }
+  }
+
+  get isRunning(): boolean {
+    return this.proc !== null && !this.proc.killed;
+  }
+}
+
+export const pet = new PetBridge();
+
+export async function startPet(): Promise<void> {
+  await pet.start();
+}
+
+export function stopPet(): void {
+  pet.stop();
+}

package/src/renderer.ts

@@ -0,0 +1,350 @@
+import chalk from "chalk";
+import { t } from "./locale.ts";
+import { getAgentLabel, getMainAgent } from "./agent_registry.ts";
+import { countTextUnits } from "./text_split.ts";
+
+let showThinking = true;
+let showToolDetails = true;
+
+export function setShowThinking(v: boolean) { showThinking = v; }
+export function getShowThinking() { return showThinking; }
+export function setShowToolDetails(v: boolean) { showToolDetails = v; }
+export function getShowToolDetails() { return showToolDetails; }
+
+const THINKING_TAIL_LINES = 3; // 流式与历史回放统一：只显示思考尾部 N 行
+const PET_MAX_BUBBLE_LEN = 50;
+
+// ── 显示宽度 & 行数工具（CJK/全角算 2，ANSI 控制符算 0）────────────
+function charWidth(code: number): number {
+  if (code < 0x20) return 0;
+  if (
+    code >= 0x1100 &&
+    (code <= 0x115f ||
+      (code >= 0x2e80 && code <= 0x303e) ||
+      (code >= 0x3040 && code <= 0x33bf) ||
+      (code >= 0x3400 && code <= 0x4dbf) ||
+      (code >= 0x4e00 && code <= 0xa4cf) ||
+      (code >= 0xac00 && code <= 0xd7af) ||
+      (code >= 0xf900 && code <= 0xfaff) ||
+      (code >= 0xfe30 && code <= 0xfe6f) ||
+      (code >= 0xff01 && code <= 0xff60) ||
+      (code >= 0xffe0 && code <= 0xffe6) ||
+      (code >= 0x1f300 && code <= 0x1f9ff))
+  ) {
+    return 2;
+  }
+  return 1;
+}
+function strWidth(s: string): number {
+  let w = 0;
+  for (const ch of s) w += charWidth(ch.codePointAt(0)!);
+  return w;
+}
+/** 给定一行可见文本，根据当前终端列宽计算实际占用的物理行数（自动软换行）。 */
+function physicalLinesForRow(visibleText: string): number {
+  const cols = process.stdout.columns ?? 80;
+  if (cols <= 0) return 1;
+  const w = Math.max(1, strWidth(visibleText));
+  return Math.ceil(w / cols);
+}
+
+type PetTextKind = "mid" | "final";
+
+export function createRenderer(
+  onTurnEnd?: (text: string) => void,
+  onPetText?: (kind: PetTextKind, data: string) => void,
+  initialSpeakerLabel?: string,
+) {
+  let speakerLabel = initialSpeakerLabel;
+  let inThinking = false;
+  let inText = false;
+  let textPrefixWritten = false;
+
+  // ── 流式思考折叠重绘 ──────────────────────────────────────────
+  let thinkingBuffer = "";          // 完整思考内容缓冲区
+  let drawnThinkingLines = 0;      // 上次渲染占用的**物理行数**（含 ANSI 软换行）
+  // 思考前缀：每行都加 2 空格缩进（与历史回放 renderSavedMessages 对齐）
+  const THINKING_PREFIX = "  ";
+
+  /** 擦除上次画出的思考区域，回到思考块第一行的行首。 */
+  function eraseDrawnThinking(): void {
+    if (drawnThinkingLines <= 0) return;
+    // 光标当前在思考块最后一行末尾。先回到该行第 1 列 → 上移 N-1 行到思考块顶行 → 清到屏幕末尾
+    process.stdout.write("\r");
+    if (drawnThinkingLines > 1) {
+      process.stdout.write(`\x1b[${drawnThinkingLines - 1}A`);
+    }
+    process.stdout.write("\x1b[0J");
+    drawnThinkingLines = 0;
+  }
+
+  /**
+   * 根据 thinkingBuffer 按折叠规则渲染（省略前缀 + 最后 THINKING_TAIL_LINES 行）。
+   * 与历史回放 renderSavedMessages 的格式严格对齐：
+   *   - 空缓冲 → 什么都不画
+   *   - 逻辑行 ≤ THINKING_TAIL_LINES → 全画
+   *   - 逻辑行 > THINKING_TAIL_LINES → 1 行省略提示 + 尾部 N 行
+   *   - 每行前缀 = THINKING_PREFIX
+   */
+  function renderThinking(): void {
+    const raw = thinkingBuffer.replace(/\n+$/, "");
+    if (!raw) return;
+    const allLines = raw.split("\n");
+    const total = allLines.length;
+    const showTail = total <= THINKING_TAIL_LINES
+      ? allLines
+      : allLines.slice(-THINKING_TAIL_LINES);
+    const hidden = total - showTail.length;
+
+    // 准备要写出的行（带格式、带前缀）
+    const renderLines: { visible: string; styled: string }[] = [];
+    if (hidden > 0) {
+      const visibleMsg = t(
+        `… (已省略 ${hidden} 行早期思考内容)`,
+        `… (${hidden} earlier thinking lines omitted)`,
+      );
+      renderLines.push({
+        visible: THINKING_PREFIX + visibleMsg,
+        styled: chalk.dim(THINKING_PREFIX + visibleMsg),
+      });
+    }
+    for (const line of showTail) {
+      renderLines.push({
+        visible: THINKING_PREFIX + line,
+        styled: chalk.dim(THINKING_PREFIX + line),
+      });
+    }
+
+    // 输出 + 统计物理行数
+    let physLines = 0;
+    const out: string[] = [];
+    for (const row of renderLines) {
+      out.push(row.styled);
+      physLines += physicalLinesForRow(row.visible);
+    }
+    process.stdout.write(out.join("\r\n"));
+    drawnThinkingLines = physLines;
+  }
+
+  /** 流式思考增量更新：擦旧 → 追加缓冲 → 重绘。 */
+  function appendThinkingDelta(delta: string): void {
+    eraseDrawnThinking();
+    thinkingBuffer += delta;
+    renderThinking();
+  }
+
+  /** 结束流式思考、准备输出正文时调用。把思考块"封版"，游标移到下一行开头。 */
+  function finalizeThinking(): void {
+    if (drawnThinkingLines > 0) {
+      // 画完最后一帧后光标在末行末尾；切到下一行第 1 列即可。
+      process.stdout.write("\r\n");
+    }
+    drawnThinkingLines = 0;
+    thinkingBuffer = "";
+  }
+
+  // 回合文本累积：只保留最后一个 assistant message 的文本（TTS 与气泡都在 agent_end 收尾）
+  let curMsgText = ""; // 当前 message 的 text_delta 累积
+  let lastText = ""; // 最近一个 message 的完整文本（候选：中间段会被后续覆盖）
+
+  /** 把 lines 按"最早的优先保留、最后一条优先被挤掉"裁到总字数 < maxUnits。 */
+  function trimBubbleLines(lines: string[], maxUnits: number): string[] {
+    let total = lines.reduce((s, l) => s + countTextUnits(l), 0);
+    while (total > maxUnits && lines.length > 1) {
+      total -= countTextUnits(lines[0]);
+      lines.shift();
+    }
+    return lines;
+  }
+
+  return {
+    setSpeakerLabel(label: string | undefined) {
+      speakerLabel = label;
+    },
+    subscribe: (session: any) => {
+      return session.subscribe((event: any) => {
+        switch (event.type) {
+          case "message_start":
+            inText = false;
+            inThinking = false;
+            textPrefixWritten = false;
+            curMsgText = "";
+            thinkingBuffer = "";
+            drawnThinkingLines = 0;
+            break;
+
+          case "message_update": {
+            const ae = event.assistantMessageEvent;
+            if (ae.type === "text_delta") {
+              if (!inText) {
+                if (inThinking) {
+                  finalizeThinking();
+                  inThinking = false;
+                }
+                inText = true;
+                if (speakerLabel && !textPrefixWritten) {
+                  process.stdout.write(chalk.magenta.bold(speakerLabel + "："));
+                  textPrefixWritten = true;
+                }
+              }
+              process.stdout.write(ae.delta);
+              // 文本只累积到当前 message，TTS 与气泡都在 agent_end 一次性收尾（只读最后一段）
+              curMsgText += ae.delta;
+            } else if (ae.type === "thinking_delta") {
+              if (showThinking) {
+                if (!inThinking) {
+                  inThinking = true;
+                  inText = false;
+                  // 先开一个新行；后续所有增量走 erase+redraw，从这行开始覆盖
+                  process.stdout.write("\r\n");
+                  drawnThinkingLines = 0;
+                  thinkingBuffer = "";
+                }
+                appendThinkingDelta(ae.delta);
+              }
+            }
+            break;
+          }
+
+          case "message_end": {
+            if (inThinking && showThinking) {
+              finalizeThinking();
+            }
+            if (inText) {
+              process.stdout.write("\n");
+            }
+            // 暂存最近一个 message 的完整文本作为"最后一段"候选；中间段会被后续覆盖。
+            // TTS 与气泡都不在此处收尾——agent_end 时才决定朗读/上屏哪一段。
+            lastText = curMsgText.trim();
+            curMsgText = "";
+            inThinking = false;
+            inText = false;
+            thinkingBuffer = "";
+            drawnThinkingLines = 0;
+            break;
+          }
+
+          case "agent_end": {
+            // 回合全部文字输出完毕：只取最后一个 message 的文本收尾 TTS（中间过程性发言不朗读），
+            // 气泡与 TTS 同步，一次性上屏最后一段（只发 final）。
+            if (lastText) {
+              onTurnEnd?.(lastText);
+              if (onPetText) {
+                const units = countTextUnits(lastText);
+                if (units > 0) {
+                  if (units >= PET_MAX_BUBBLE_LEN) {
+                    onPetText("final", lastText);
+                  } else {
+                    onPetText("final", trimBubbleLines([lastText], PET_MAX_BUBBLE_LEN).join("\n"));
+                  }
+                }
+              }
+            }
+            lastText = "";
+            break;
+          }
+
+          case "tool_execution_start":
+            if (showToolDetails) {
+              const name = event.toolName;
+              const input = event.input ? JSON.stringify(event.input).slice(0, 100) : "";
+              process.stdout.write(chalk.cyan(t(`\n  [工具] ${name}`, `\n  [tool] ${name}`)) + (input ? ` ${input}` : "") + "\n");
+            }
+            break;
+
+          case "tool_execution_end":
+            if (showToolDetails) {
+              const status = event.isError ? chalk.red(t("错误", "error")) : chalk.green(t("完成", "done"));
+              process.stdout.write(t("  [工具] ", "  [tool] ") + `${status}\n`);
+            }
+            break;
+
+          case "compaction_start":
+            process.stdout.write(chalk.yellow(t("\n[正在压缩上下文...]\n", "\n[Compacting context...]\n")));
+            break;
+
+          case "compaction_end":
+            if (event.aborted) {
+              process.stdout.write(chalk.yellow(t("[压缩已取消]\n\n", "[Compaction cancelled]\n\n")));
+            } else if (event.errorMessage) {
+              // SDK 错误信息带 "Compaction failed: " 前缀，去掉保持输出整洁
+              const msg = String(event.errorMessage).replace(/^Compaction failed:\s*/i, "");
+              process.stdout.write(chalk.red(t(`[压缩失败] ${msg}\n\n`, `[Compaction failed] ${msg}\n\n`)));
+            } else {
+              process.stdout.write(chalk.yellow(t("[压缩完成]\n\n", "[Compaction complete]\n\n")));
+            }
+            break;
+
+          case "auto_retry_start":
+            process.stdout.write(chalk.yellow(t("\n[重试中...]\n", "\n[Retrying...]\n")));
+            break;
+        }
+      });
+    },
+  };
+}
+
+/**
+ * 将已保存会话的消息回放渲染到终端（用于 /resume 恢复后重绘历史）。
+ * 仅渲染文件中的消息，不涉及当前 session 状态，避免上下文串扰。
+ *
+ * 消息结构（见 memory.ts loadSession）：
+ *   - { role: "user", content: [{type:"text",text}] }
+ *   - { role: "assistant", content: [{type:"thinking"},{type:"text"},{type:"toolCall"}] }
+ *   - { role: "toolResult", toolName, content:[{type:"text",text}], isError }
+ */
+export function renderSavedMessages(messages: any[]) {
+  for (const msg of messages) {
+    if (msg.type === "arona-session") continue; // 跳过 header（loadSession 已过滤）
+
+    if (msg.role === "user") {
+      const text = extractText(msg.content);
+      if (text) {
+        process.stdout.write(chalk.cyan.bold(t("你：", "You: ")) + text + "\n\n");
+      }
+    } else if (msg.role === "assistant") {
+      const content = msg.content || [];
+      // 思考内容（仅显示尾部，与流式渲染一致）
+      const thinkingBlocks = content.filter((b: any) => b.type === "thinking");
+      for (const tb of thinkingBlocks) {
+        const thinking = tb.thinking || "";
+        if (thinking.trim()) {
+          const allLines = thinking.replace(/\n+$/, "").split("\n");
+          const tail = allLines.slice(-THINKING_TAIL_LINES);
+          const hidden = allLines.length - tail.length;
+          process.stdout.write("\n");
+          if (hidden > 0) {
+            process.stdout.write(chalk.dim(t(`  … (已省略 ${hidden} 行早期思考内容)\n`, `  … (${hidden} earlier thinking lines omitted)\n`)));
+          }
+          for (const line of tail) {
+            process.stdout.write(chalk.dim(`  ${line}\n`));
+          }
+        }
+      }
+      // 文本内容
+      const text = extractText(content);
+      if (text) {
+        const speaker = typeof msg.speaker === "string" ? getAgentLabel(msg.speaker as any) : getAgentLabel(getMainAgent());
+        process.stdout.write(chalk.magenta.bold(speaker + "：") + text + "\n\n");
+      }
+      // 工具调用
+      const toolCalls = content.filter((b: any) => b.type === "toolCall");
+      for (const tc of toolCalls) {
+        const input = tc.arguments ? JSON.stringify(tc.arguments).slice(0, 100) : "";
+        process.stdout.write(chalk.cyan(t("  [工具] ", "  [tool] ") + (tc.name || "")) + (input ? ` ${input}` : "") + "\n");
+      }
+    } else if (msg.role === "toolResult") {
+      const status = msg.isError ? chalk.red(t("错误", "error")) : chalk.green(t("完成", "done"));
+      const toolName = msg.toolName || "";
+      process.stdout.write(chalk.cyan(t("  [工具] ", "  [tool] ") + `${toolName} ${status}\n`));
+    }
+  }
+}
+
+function extractText(content: any): string {
+  if (!Array.isArray(content)) return "";
+  return content
+    .filter((b: any) => b.type === "text")
+    .map((b: any) => b.text || "")
+    .join("");
+}