clawt 2.16.3 → 2.16.5

package/src/utils/progress-render.ts

@@ -1,7 +1,63 @@
 import chalk from 'chalk';
+import stringWidth from 'string-width';
 import { TASK_STATUS_ICONS, TASK_STATUS_LABELS } from '../constants/index.js';
 import { formatDuration } from './formatter.js';
 
+/** ANSI 颜色/样式转义序列的匹配正则 */
+const ANSI_ESCAPE_RE = /\x1B\[[0-9;]*m/g;
+
+/** ANSI 样式重置序列，用于截断后关闭未闭合的颜色 */
+const ANSI_RESET = '\x1B[0m';
+
+/**
+ * 将含 ANSI 转义码的字符串截断到指定可见宽度
+ *
+ * 逐字符遍历原始字符串，跳过 ANSI 序列不计入可见宽度，
+ * 在可见宽度达到上限时截断并追加样式重置序列防止颜色泄漏。
+ * @param {string} text - 可能含 ANSI 颜色码的字符串
+ * @param {number} maxWidth - 终端可见列数上限
+ * @returns {string} 截断后的字符串（不超过 maxWidth 可见列）
+ */
+export function truncateToTerminalWidth(text: string, maxWidth: number): string {
+  // 快速路径：实际可见宽度未超限时直接返回
+  if (stringWidth(text) <= maxWidth) {
+    return text;
+  }
+
+  let visibleWidth = 0;
+  let result = '';
+  let i = 0;
+
+  while (i < text.length) {
+    // 检查当前位置是否是 ANSI 转义序列的起始
+    if (text[i] === '\x1B' && text[i + 1] === '[') {
+      // 匹配完整的 ANSI 序列（格式: ESC [ <数字;...> m）
+      const match = text.slice(i).match(/^\x1B\[[0-9;]*m/);
+      if (match) {
+        // ANSI 序列不占可见宽度，直接保留
+        result += match[0];
+        i += match[0].length;
+        continue;
+      }
+    }
+
+    // 计算当前字符的可见宽度（中文/emoji 为 2，ASCII 为 1）
+    const charWidth = stringWidth(text[i]);
+
+    // 加上当前字符后是否会超出上限
+    if (visibleWidth + charWidth > maxWidth) {
+      break;
+    }
+
+    result += text[i];
+    visibleWidth += charWidth;
+    i++;
+  }
+
+  // 追加样式重置，防止截断后颜色泄漏到下一行
+  return result + ANSI_RESET;
+}
+
 /** 单个任务的进度状态 */
 export interface TaskProgress {
   /** 任务序号（从 1 开始） */
@@ -22,47 +78,55 @@ export interface TaskProgress {
   durationMs: number | null;
   /** 费用（美元），完成后由 ClaudeCodeResult 填入 */
   costUsd: number | null;
+  /** 当前活动描述文本（仅 running 状态有效） */
+  activity: string | null;
+  /** 结果预览文本（完成/失败后显示） */
+  resultPreview: string | null;
 }
 
 /**
- * 计算分支名的最大显示宽度，用于对齐
+ * 计算路径的最大显示宽度，用于对齐
  * @param {TaskProgress[]} tasks - 任务列表
- * @returns {number} 最大分支名长度
+ * @returns {number} 最大路径长度
  */
-export function getMaxBranchWidth(tasks: TaskProgress[]): number {
-  return Math.max(...tasks.map((t) => t.branch.length));
+export function getMaxPathWidth(tasks: TaskProgress[]): number {
+  return Math.max(...tasks.map((t) => t.path.length));
 }
 
 /**
  * 渲染单个任务行（TTY 模式）
- * 格式: [1/3] feat-1  ⠹ 运行中 1m23s
- * 完成/失败后追加 worktree 路径，终端可点击跳转
+ * 格式: [1/3] /path/to/worktree  ⠹ 运行中 1m23s
+ * 完成/失败后末尾追加结果预览文本
  * @param {TaskProgress} task - 任务进度
  * @param {number} total - 总任务数
- * @param {number} maxBranchWidth - 分支名最大宽度（用于对齐）
+ * @param {number} maxPathWidth - 路径最大宽度（用于对齐）
  * @param {string} spinnerChar - 当前 spinner 帧字符
  * @returns {string} 渲染后的单行字符串（含 chalk 颜色）
  */
-export function renderTaskLine(task: TaskProgress, total: number, maxBranchWidth: number, spinnerChar: string): string {
+export function renderTaskLine(task: TaskProgress, total: number, maxPathWidth: number, spinnerChar: string): string {
   const indexStr = `[${task.index}/${total}]`;
-  const branchStr = task.branch.padEnd(maxBranchWidth);
+  const pathStr = task.path.padEnd(maxPathWidth);
 
   switch (task.status) {
     case 'pending': {
-      return `${indexStr} ${branchStr}  ${chalk.gray(TASK_STATUS_ICONS.PENDING)} ${chalk.gray(TASK_STATUS_LABELS.PENDING)}  ${chalk.dim(task.path)}`;
+      return `${indexStr} ${pathStr}  ${chalk.gray(TASK_STATUS_ICONS.PENDING)} ${chalk.gray(TASK_STATUS_LABELS.PENDING)}`;
     }
     case 'running': {
       const elapsed = formatDuration(Date.now() - task.startedAt);
-      return `${indexStr} ${branchStr}  ${chalk.cyan(spinnerChar)} ${chalk.cyan(TASK_STATUS_LABELS.RUNNING)} ${chalk.gray(elapsed)}  ${chalk.dim(task.path)}`;
+      // 仅显示活动信息，不显示路径（路径已在第二列显示）
+      const detail = task.activity ? `  ${chalk.dim(task.activity)}` : '';
+      return `${indexStr} ${pathStr}  ${chalk.cyan(spinnerChar)} ${chalk.cyan(TASK_STATUS_LABELS.RUNNING)} ${chalk.gray(elapsed)}${detail}`;
     }
     case 'done': {
       const duration = task.durationMs != null ? formatDuration(task.durationMs) : 'N/A';
       const cost = task.costUsd != null ? `$${task.costUsd.toFixed(2)}` : '';
-      return `${indexStr} ${branchStr}  ${chalk.green(TASK_STATUS_ICONS.DONE)} ${chalk.green(TASK_STATUS_LABELS.DONE)}   ${chalk.gray(duration)}  ${chalk.yellow(cost)}  ${chalk.dim(task.path)}`;
+      const preview = task.resultPreview ? `  ${chalk.dim(task.resultPreview)}` : '';
+      return `${indexStr} ${pathStr}  ${chalk.green(TASK_STATUS_ICONS.DONE)} ${chalk.green(TASK_STATUS_LABELS.DONE)}   ${chalk.gray(duration)}  ${chalk.yellow(cost)}${preview}`;
     }
     case 'failed': {
       const duration = task.durationMs != null ? formatDuration(task.durationMs) : 'N/A';
-      return `${indexStr} ${branchStr}  ${chalk.red(TASK_STATUS_ICONS.FAILED)} ${chalk.red(TASK_STATUS_LABELS.FAILED)}   ${chalk.gray(duration)}  ${chalk.dim(task.path)}`;
+      const preview = task.resultPreview ? `  ${chalk.dim(task.resultPreview)}` : '';
+      return `${indexStr} ${pathStr}  ${chalk.red(TASK_STATUS_ICONS.FAILED)} ${chalk.red(TASK_STATUS_LABELS.FAILED)}   ${chalk.gray(duration)}${preview}`;
     }
   }
 }

package/src/utils/progress.ts

@@ -1,15 +1,22 @@
 import {
   SPINNER_FRAMES,
   SPINNER_INTERVAL_MS,
-  CURSOR_UP,
-  CLEAR_LINE,
   CURSOR_HIDE,
   CURSOR_SHOW,
+  DEFAULT_TERMINAL_COLUMNS,
+  LINE_WRAP_DISABLE,
+  LINE_WRAP_ENABLE,
+  SYNC_OUTPUT_START,
+  SYNC_OUTPUT_END,
+  ALT_SCREEN_ENTER,
+  ALT_SCREEN_LEAVE,
+  CLEAR_SCREEN,
+  CURSOR_HOME,
   MESSAGES,
 } from '../constants/index.js';
 import { formatDuration } from './formatter.js';
 import type { TaskProgress } from './progress-render.js';
-import { getMaxBranchWidth, renderTaskLine, renderSummaryLine } from './progress-render.js';
+import { getMaxPathWidth, renderTaskLine, renderSummaryLine, truncateToTerminalWidth } from './progress-render.js';
 
 /**
  * 任务进度面板渲染器
@@ -29,10 +36,12 @@ export class ProgressRenderer {
   private timer: ReturnType<typeof setInterval> | null;
   /** 是否为 TTY 环境 */
   private isTTY: boolean;
-  /** 已渲染的行数（用于回退光标） */
-  private renderedLineCount: number;
+  /** resize 事件处理器引用（用于 stop 时移除监听） */
+  private resizeHandler: (() => void) | null;
   /** 是否已停止 */
   private stopped: boolean;
+  /** exit 兜底处理器（确保异常退出时终端状态被恢复） */
+  private exitHandler: (() => void) | null;
   /** 是否存在排队任务（启用汇总行渲染） */
   private hasPendingTasks: boolean;
 
@@ -48,8 +57,9 @@ export class ProgressRenderer {
     this.frameIndex = 0;
     this.timer = null;
     this.isTTY = !!process.stdout.isTTY;
-    this.renderedLineCount = 0;
+    this.resizeHandler = null;
     this.stopped = false;
+    this.exitHandler = null;
     this.hasPendingTasks = !allRunning;
 
     this.tasks = branches.map((branch, i) => ({
@@ -62,6 +72,8 @@ export class ProgressRenderer {
       lastActiveAt: allRunning ? now : 0,
       durationMs: null,
       costUsd: null,
+      activity: null,
+      resultPreview: null,
     }));
   }
 
@@ -83,8 +95,10 @@ export class ProgressRenderer {
       return;
     }
 
-    // TTY 模式：隐藏光标，启动定时刷新
+    // TTY 模式：进入备选屏幕缓冲区，隐藏光标，禁用终端自动行换行
+    process.stdout.write(ALT_SCREEN_ENTER);
     process.stdout.write(CURSOR_HIDE);
+    process.stdout.write(LINE_WRAP_DISABLE);
     this.render();
     this.timer = setInterval(() => {
       this.frameIndex = (this.frameIndex + 1) % SPINNER_FRAMES.length;
@@ -95,6 +109,22 @@ export class ProgressRenderer {
     if (this.timer.unref) {
       this.timer.unref();
     }
+
+    // 监听终端宽度变化，立即触发重绘
+    this.resizeHandler = () => {
+      if (!this.stopped) {
+        this.render();
+      }
+    };
+    process.stdout.on('resize', this.resizeHandler);
+
+    // 注册 exit 兜底，确保异常退出时终端状态被恢复
+    this.exitHandler = () => {
+      process.stdout.write(LINE_WRAP_ENABLE);
+      process.stdout.write(CURSOR_SHOW);
+      process.stdout.write(ALT_SCREEN_LEAVE);
+    };
+    process.on('exit', this.exitHandler);
   }
 
   /**
@@ -106,6 +136,18 @@ export class ProgressRenderer {
     this.tasks[index].lastActiveAt = Date.now();
   }
 
+  /**
+   * 更新指定任务的活动描述文本
+   * 同时更新 lastActiveAt 时间戳
+   * @param {number} index - 任务索引（从 0 开始）
+   * @param {string} text - 活动描述文本
+   */
+  updateActivityText(index: number, text: string): void {
+    const task = this.tasks[index];
+    task.activity = text;
+    task.lastActiveAt = Date.now();
+  }
+
   /**
    * 标记指定任务为运行中状态
    * 将 pending 任务标记为 running 并设置启动时间戳
@@ -129,19 +171,21 @@ export class ProgressRenderer {
    * @param {number} index - 任务索引（从 0 开始）
    * @param {number} durationMs - 耗时（毫秒）
    * @param {number} costUsd - 费用（美元）
+   * @param {string} [resultPreview] - 结果预览文本（可选）
    */
-  markDone(index: number, durationMs: number, costUsd: number): void {
+  markDone(index: number, durationMs: number, costUsd: number, resultPreview?: string): void {
     const task = this.tasks[index];
     task.status = 'done';
     task.finishedAt = Date.now();
     task.durationMs = durationMs;
     task.costUsd = costUsd;
+    task.resultPreview = resultPreview ?? null;
 
     if (!this.isTTY) {
       // 非 TTY 降级：直接输出完成信息
       const duration = formatDuration(durationMs);
       const cost = `$${costUsd.toFixed(2)}`;
-      console.log(MESSAGES.PROGRESS_TASK_DONE(task.index, this.total, task.branch, duration, cost, task.path));
+      console.log(MESSAGES.PROGRESS_TASK_DONE(task.index, this.total, task.branch, duration, cost, task.resultPreview ?? task.path));
     }
   }
 
@@ -149,17 +193,19 @@ export class ProgressRenderer {
    * 标记指定任务为失败状态
    * @param {number} index - 任务索引（从 0 开始）
    * @param {number} durationMs - 耗时（毫秒）
+   * @param {string} [resultPreview] - 结果预览文本（可选）
    */
-  markFailed(index: number, durationMs: number): void {
+  markFailed(index: number, durationMs: number, resultPreview?: string): void {
     const task = this.tasks[index];
     task.status = 'failed';
     task.finishedAt = Date.now();
     task.durationMs = durationMs;
+    task.resultPreview = resultPreview ?? null;
 
     if (!this.isTTY) {
       // 非 TTY 降级：直接输出失败信息
       const duration = formatDuration(durationMs);
-      console.log(MESSAGES.PROGRESS_TASK_FAILED(task.index, this.total, task.branch, duration, task.path));
+      console.log(MESSAGES.PROGRESS_TASK_FAILED(task.index, this.total, task.branch, duration, task.resultPreview ?? task.path));
     }
   }
 
@@ -176,38 +222,78 @@ export class ProgressRenderer {
       this.timer = null;
     }
 
+    // 移除终端 resize 监听
+    if (this.resizeHandler) {
+      process.stdout.removeListener('resize', this.resizeHandler);
+      this.resizeHandler = null;
+    }
+
     if (this.isTTY) {
-      // 最后渲染一次，确保最终状态显示正确
+      // 最后在备选屏幕渲染一次，确保最终状态显示正确
       this.render();
+      // 恢复终端自动行换行
+      process.stdout.write(LINE_WRAP_ENABLE);
       // 恢复光标显示
       process.stdout.write(CURSOR_SHOW);
+      // 退出备选屏幕缓冲区，恢复主屏幕内容
+      process.stdout.write(ALT_SCREEN_LEAVE);
+
+      // 在主屏幕上输出最终面板状态（备选屏幕内容不保留，需要重新输出）
+      const cols = process.stdout.columns || DEFAULT_TERMINAL_COLUMNS;
+      const finalLines = this.buildLines(cols);
+      for (const line of finalLines) {
+        process.stdout.write(`${line}\n`);
+      }
+    }
+
+    // 移除 exit 兜底
+    if (this.exitHandler) {
+      process.removeListener('exit', this.exitHandler);
+      this.exitHandler = null;
     }
   }
 
   /**
-   * 执行一次完整的面板渲染
-   * 先回退光标到面板起始位置，再逐行输出
+   * 构建当前帧的面板行内容
+   * @param {number} cols - 终端列数
+   * @returns {string[]} 截断后的面板行数组
    */
-  private render(): void {
-    const maxBranchWidth = getMaxBranchWidth(this.tasks);
+  private buildLines(cols: number): string[] {
+    const maxPathWidth = getMaxPathWidth(this.tasks);
     const spinnerChar = SPINNER_FRAMES[this.frameIndex];
-    const lines = this.tasks.map((task) => renderTaskLine(task, this.total, maxBranchWidth, spinnerChar));
+    const lines = this.tasks.map((task) => renderTaskLine(task, this.total, maxPathWidth, spinnerChar));
 
     // 存在排队任务时追加汇总行
     if (this.hasPendingTasks) {
       lines.push(renderSummaryLine(this.tasks, this.total));
     }
 
-    // 回退光标到面板起始位置
-    if (this.renderedLineCount > 0) {
-      process.stdout.write(CURSOR_UP(this.renderedLineCount));
-    }
+    return lines.map((line) => truncateToTerminalWidth(line, cols));
+  }
+
+  /**
+   * 执行一次完整的面板渲染
+   * 在备选屏幕缓冲区中，每次清屏+归位后完全重绘
+   * 无需计算 CURSOR_UP 回退量，不受终端 reflow 影响
+   * 使用 Synchronized Output 防止多行写入时的闪烁
+   */
+  private render(): void {
+    const cols = process.stdout.columns || DEFAULT_TERMINAL_COLUMNS;
+    const lines = this.buildLines(cols);
+
+    // 开启同步输出（终端缓冲输出，关闭时一次性刷新，防止闪烁）
+    process.stdout.write(SYNC_OUTPUT_START);
+
+    // 备选屏幕无滚动缓冲区，直接清屏+归位即可，无需计算回退量
+    process.stdout.write(CLEAR_SCREEN);
+    process.stdout.write(CURSOR_HOME);
 
-    // 逐行输出，每行末尾清除残留字符
+    // 逐行输出，按终端宽度截断
     for (const line of lines) {
-      process.stdout.write(`${line}${CLEAR_LINE}\n`);
+      process.stdout.write(`${line}\n`);
     }
 
-    this.renderedLineCount = lines.length;
+    // 关闭同步输出
+    process.stdout.write(SYNC_OUTPUT_END);
   }
 }

package/src/utils/stream-parser.ts

@@ -0,0 +1,251 @@
+import path from 'node:path';
+import type { ClaudeCodeResult } from '../types/index.js';
+import {
+  ACTIVITY_TEXT_MAX_LENGTH,
+  TEXT_ACTIVITY_PREFIX,
+} from '../constants/index.js';
+
+// ============================================================
+// 类型定义
+// ============================================================
+
+/** stream-json content 数组中的单个块 */
+interface StreamContentBlock {
+  /** 内容类型：tool_use / text / tool_result */
+  type: string;
+  /** 工具名称（tool_use 时） */
+  name?: string;
+  /** 工具调用参数（tool_use 时） */
+  input?: Record<string, unknown>;
+  /** 文本内容（text 时） */
+  text?: string;
+  /** 工具执行结果内容（tool_result 时） */
+  content?: string;
+}
+
+/** stream-json 单行事件中 assistant/user 消息的 message 结构 */
+interface StreamMessage {
+  content?: StreamContentBlock[];
+}
+
+/** stream-json 单行事件的统一结构 */
+export interface StreamEvent {
+  /** 事件类型：system / assistant / user / result */
+  type: string;
+  /** 事件子类型 */
+  subtype?: string;
+  /** assistant/user 消息体 */
+  message?: StreamMessage;
+  /** user 消息的 content（tool_result 场景） */
+  content?: StreamContentBlock[];
+  // --- result 类型特有字段 ---
+  /** 是否为错误结果 */
+  is_error?: boolean;
+  /** 总耗时（毫秒） */
+  duration_ms?: number;
+  /** API 调用耗时（毫秒） */
+  duration_api_ms?: number;
+  /** 交互轮次数 */
+  num_turns?: number;
+  /** 会话结果文本 */
+  result?: string;
+  /** 停止原因 */
+  stop_reason?: string;
+  /** 会话 ID */
+  session_id?: string;
+  /** 总费用（美元） */
+  total_cost_usd?: number;
+  /** 使用量统计 */
+  usage?: Record<string, unknown>;
+}
+
+/** 解析出的活动信息 */
+export interface ParsedActivity {
+  /** 活动类型 */
+  kind: 'tool_use' | 'text' | 'result';
+  /** 格式化后的活动描述文本（已截断到 ACTIVITY_TEXT_MAX_LENGTH） */
+  activityText: string;
+  /** 最终结果对象（仅 kind=result 时有值） */
+  result?: ClaudeCodeResult;
+}
+
+/** 行缓冲器，处理 data 事件中的不完整行 */
+export interface LineBuffer {
+  /** 追加数据并返回完整的行 */
+  push(chunk: string): string[];
+  /** 获取缓冲区中剩余的不完整数据（流结束时调用） */
+  flush(): string | null;
+}
+
+// ============================================================
+// 核心函数
+// ============================================================
+
+/**
+ * 创建行缓冲器，用于处理流式数据中的不完整行
+ * stdout 的 data 事件可能在行中间切割，需要缓冲直到遇到换行符
+ * @returns {LineBuffer} 行缓冲器实例
+ */
+export function createLineBuffer(): LineBuffer {
+  let buffer = '';
+  return {
+    push(chunk: string): string[] {
+      buffer += chunk;
+      const lines = buffer.split('\n');
+      // 最后一个元素可能是不完整的行，保留在缓冲区
+      buffer = lines.pop() ?? '';
+      return lines;
+    },
+    flush(): string | null {
+      const remaining = buffer;
+      buffer = '';
+      return remaining || null;
+    },
+  };
+}
+
+/**
+ * 解析单行 stream-json 输出为事件对象
+ * 忽略空行和非 JSON 行
+ * @param {string} line - 单行文本
+ * @returns {StreamEvent | null} 解析成功返回事件对象，失败返回 null
+ */
+export function parseStreamLine(line: string): StreamEvent | null {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+
+  try {
+    return JSON.parse(trimmed) as StreamEvent;
+  } catch {
+    // 非 JSON 行（verbose 模式可能有额外日志），静默忽略
+    return null;
+  }
+}
+
+/**
+ * 将文本截断到指定最大长度，超长部分用省略号替代
+ * @param {string} text - 原始文本
+ * @param {number} maxLength - 最大字符数
+ * @returns {string} 截断后的文本
+ */
+export function truncateText(text: string, maxLength: number): string {
+  if (text.length <= maxLength) return text;
+  return text.substring(0, maxLength - 1) + '…';
+}
+
+/**
+ * 根据活动类型和参数生成活动描述文本
+ * tool_use 类型直接使用英文工具名，有 file_path 参数时追加文件名
+ * 输出最大长度为 ACTIVITY_TEXT_MAX_LENGTH（30 字符），超出截断并追加省略号
+ * @param {'tool_use' | 'text'} kind - 活动类型
+ * @param {string} [toolName] - 工具名（tool_use 时）
+ * @param {Record<string, unknown>} [input] - 工具参数（tool_use 时）
+ * @param {string} [text] - 文本内容（text 时）
+ * @returns {string} 格式化后的活动描述文本
+ */
+export function formatActivityText(
+  kind: 'tool_use' | 'text',
+  toolName?: string,
+  input?: Record<string, unknown>,
+  text?: string,
+): string {
+  let raw = '';
+
+  if (kind === 'tool_use' && toolName) {
+    // 对有文件路径参数的工具，追加文件名
+    const filePath = input?.file_path as string | undefined;
+    // 对有 command 参数的工具（如 Bash），追加命令内容
+    const command = input?.command as string | undefined;
+    if (filePath) {
+      const basename = path.basename(filePath);
+      raw = `${toolName} ${basename}`;
+    } else if (command) {
+      // 清理命令中的换行和多余空白
+      const cleaned = command.replace(/[\n\r\t]+/g, ' ').trim();
+      raw = `${toolName} ${cleaned}`;
+    } else {
+      raw = toolName;
+    }
+  } else if (kind === 'text' && text) {
+    // 清理控制字符和换行
+    const cleaned = text.replace(/[\n\r\t]/g, ' ').trim();
+    if (!cleaned) return '';
+    raw = `${TEXT_ACTIVITY_PREFIX}: ${cleaned}`;
+  }
+
+  if (!raw) return '';
+
+  return truncateText(raw, ACTIVITY_TEXT_MAX_LENGTH);
+}
+
+/**
+ * 从流式事件中提取活动信息
+ * 仅处理以下有意义的事件：
+ * 1. type=assistant + content 含 tool_use → 提取工具名和参数
+ * 2. type=assistant + content 含 text → 提取文本片段
+ * 3. type=result → 最终结果，构造 ClaudeCodeResult
+ * @param {StreamEvent} event - 流式事件对象
+ * @returns {ParsedActivity | null} 提取的活动信息，无关事件返回 null
+ */
+export function parseStreamEvent(event: StreamEvent): ParsedActivity | null {
+  // 最终结果事件
+  if (event.type === 'result') {
+    const result: ClaudeCodeResult = {
+      type: event.type,
+      subtype: event.subtype ?? '',
+      is_error: event.is_error ?? false,
+      duration_ms: event.duration_ms ?? 0,
+      duration_api_ms: event.duration_api_ms ?? 0,
+      num_turns: event.num_turns ?? 0,
+      result: event.result ?? '',
+      stop_reason: event.stop_reason ?? '',
+      session_id: event.session_id ?? '',
+      total_cost_usd: event.total_cost_usd ?? 0,
+      usage: event.usage ?? {},
+    };
+    return { kind: 'result', activityText: '', result };
+  }
+
+  // assistant 消息：从 message.content 中提取
+  if (event.type === 'assistant') {
+    const content = event.message?.content;
+    if (!content || content.length === 0) return null;
+
+    // 优先查找 tool_use（取最后一个，代表最新操作）
+    let lastToolUse: StreamContentBlock | null = null;
+    let lastText: StreamContentBlock | null = null;
+
+    for (const block of content) {
+      if (block.type === 'tool_use') {
+        lastToolUse = block;
+      } else if (block.type === 'text') {
+        lastText = block;
+      }
+    }
+
+    // tool_use 优先级高于 text
+    if (lastToolUse) {
+      const activityText = formatActivityText(
+        'tool_use',
+        lastToolUse.name,
+        lastToolUse.input,
+      );
+      if (activityText) {
+        return { kind: 'tool_use', activityText };
+      }
+    }
+
+    if (lastText?.text) {
+      const activityText = formatActivityText('text', undefined, undefined, lastText.text);
+      if (activityText) {
+        return { kind: 'text', activityText };
+      }
+    }
+
+    return null;
+  }
+
+  // user 消息中的 tool_result 不更新活动文本（紧接着会有下一个 assistant 消息）
+  // 其他类型（system 等）忽略
+  return null;
+}