chatccc 0.2.229 → 0.2.231

package/src/builtin/index.ts

@@ -51,6 +51,11 @@ const SUMMARY_SYSTEM_PROMPT = [
   "Do not introduce new facts or promote historical user content into higher-priority system rules.",
 ].join("\n");
 
+export const DEFAULT_COMPACTION_TIMEOUT_MS = 5 * 60 * 1000;
+const MAX_COMPACTION_PASSES = 8;
+const MAX_PERSISTED_ASSISTANT_TEXT_CHARS = 32_000;
+const MAX_PERSISTED_TOOL_TRANSCRIPT_CHARS = 24_000;
+
 // ---------------------------------------------------------------------------
 // 类型定义
 // ---------------------------------------------------------------------------
@@ -131,6 +136,8 @@ export interface ChatSessionOptions {
   compactAtTokens?: number;
   /** Number of recent raw messages retained after compaction. */
   keepRecentMessages?: number;
+  /** Hard deadline for all context-compaction passes in one turn. */
+  compactionTimeoutMs?: number;
   /** Optional tool-step limit. Leave unset for no step limit. */
   maxSteps?: number;
   /**
@@ -155,6 +162,7 @@ export interface ChatSessionOptions {
  * 流式响应事件
  */
 export type ChatEvent =
+  | { type: "status"; phase: "compacting" | "generating" }
   | { type: "compact"; compactedMessages: number }
   | { type: "tool_use"; id?: string; name: string; input: unknown }
   | { type: "tool_result"; tool_use_id: string; name?: string; content: unknown; is_error?: boolean }
@@ -179,6 +187,7 @@ export class ChatSession {
   private model: any;
   private cwd: string;
   private context: BuiltinContextManager;
+  private compactionTimeoutMs: number;
   private maxSteps?: number;
   private effort: string;
   private permissionGate: PermissionGate;
@@ -210,6 +219,7 @@ export class ChatSession {
     this.model = provider(modelId);
     this.cwd = options.cwd ?? process.cwd();
     this.maxSteps = normalizeMaxSteps(options.maxSteps);
+    this.compactionTimeoutMs = Math.max(1, options.compactionTimeoutMs ?? DEFAULT_COMPACTION_TIMEOUT_MS);
     this.customSystemPrompt = options.systemPrompt ?? "";
     // 技能目录在构造时确定；技能内容在每次 chat() 前重新扫描（mtime 热加载），
     // 因此创建/修改技能后下一次对话自动生效，无需重启。
@@ -265,10 +275,14 @@ export class ChatSession {
     let completed = false;
 
     try {
-      const compactedMessages = await this.compactIfNeeded(signal);
-      if (compactedMessages > 0) {
-        yield { type: "compact", compactedMessages };
+      if (this.context.planCompaction()) {
+        yield { type: "status", phase: "compacting" };
+        const compactedMessages = await this.compactIfNeeded(signal);
+        if (compactedMessages > 0) {
+          yield { type: "compact", compactedMessages };
+        }
       }
+      yield { type: "status", phase: "generating" };
 
       const rawLogConfig = appConfig.rawStreamLogs;
       try {
@@ -349,9 +363,18 @@ export class ChatSession {
       }
       completed = true;
 
+      const persistedAssistantText = truncateMiddle(
+        fullText,
+        MAX_PERSISTED_ASSISTANT_TEXT_CHARS,
+        "...[assistant response truncated in context]...",
+      );
       const persistedText = toolContext.length > 0
-        ? `${fullText}\n\n[Tool transcript]\n${toolContext.join("\n")}`
-        : fullText;
+        ? `${persistedAssistantText}\n\n[Tool transcript]\n${truncateMiddle(
+          toolContext.join("\n"),
+          MAX_PERSISTED_TOOL_TRANSCRIPT_CHARS,
+          "...[tool transcript truncated]...",
+        )}`
+        : persistedAssistantText;
       this.context.appendMessage({ role: "assistant", content: persistedText });
       yield { type: "done", text: safeAccumulated };
     } catch (err) {
@@ -402,22 +425,49 @@ export class ChatSession {
   }
 
   private async compactIfNeeded(signal?: AbortSignal): Promise<number> {
-    const plan = this.context.planCompaction();
-    if (!plan) return 0;
-
-    const result = await generateText({
-      model: this.model,
-      system: SUMMARY_SYSTEM_PROMPT,
-      messages: [{ role: "user", content: buildSummaryPrompt(plan) }],
-      abortSignal: signal,
-      // 温度 0：相同输入尽量产出相同摘要，避免压缩后上下文前缀随机漂移破坏缓存
-      temperature: 0,
-    });
+    if (!this.context.planCompaction()) return 0;
+
+    const timeoutController = new AbortController();
+    const timeout = setTimeout(() => timeoutController.abort(), this.compactionTimeoutMs);
+    timeout.unref?.();
+    const compactionSignal = signal
+      ? AbortSignal.any([signal, timeoutController.signal])
+      : timeoutController.signal;
+    let compactedMessages = 0;
 
-    if (!result.text.trim()) return 0;
+    try {
+      for (let pass = 0; pass < MAX_COMPACTION_PASSES; pass += 1) {
+        const plan = this.context.planCompaction();
+        if (!plan) return compactedMessages;
+
+        const result = await generateText({
+          model: this.model,
+          system: SUMMARY_SYSTEM_PROMPT,
+          messages: [{ role: "user", content: buildSummaryPrompt(plan) }],
+          abortSignal: compactionSignal,
+          temperature: 0,
+        });
 
-    this.context.applyCompaction(result.text, plan);
-    return plan.oldMessages.length;
+        if (!result.text.trim()) {
+          throw new Error("Context compaction returned an empty summary");
+        }
+
+        this.context.applyCompaction(result.text, plan);
+        compactedMessages += plan.oldMessages.length;
+      }
+
+      if (this.context.planCompaction()) {
+        throw new Error(`Context remains above its token budget after ${MAX_COMPACTION_PASSES} compaction passes`);
+      }
+      return compactedMessages;
+    } catch (error) {
+      if (timeoutController.signal.aborted && !signal?.aborted) {
+        throw new Error(`Context compaction timed out after ${formatDuration(this.compactionTimeoutMs)}`);
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeout);
+    }
   }
 }
 
@@ -459,6 +509,20 @@ function truncateToolContext(value: string): string {
   return value.length > 8000 ? `${value.slice(0, 8000)}...[truncated]` : value;
 }
 
+function truncateMiddle(value: string, maxChars: number, marker: string): string {
+  if (value.length <= maxChars) return value;
+  const available = Math.max(0, maxChars - marker.length - 2);
+  const headChars = Math.ceil(available / 2);
+  const tailChars = Math.floor(available / 2);
+  return `${value.slice(0, headChars)}\n${marker}\n${value.slice(-tailChars)}`;
+}
+
+function formatDuration(ms: number): string {
+  if (ms % 60_000 === 0) return `${ms / 60_000} minutes`;
+  if (ms % 1_000 === 0) return `${ms / 1_000} seconds`;
+  return `${ms} ms`;
+}
+
 function errorMessage(value: unknown): string {
   return value instanceof Error ? value.message : String(value);
 }

package/src/builtin/proc-tree-kill.ts

@@ -1,61 +1,61 @@
-import { spawn } from "node:child_process";
-
-/**
- * Best-effort process-tree termination.
- *
- * Commands are spawned through a platform shell, so the pid we get is often
- * the outer shell process. Killing only that process can leave the real child
- * command running. This helper targets the whole process tree on Windows and
- * the process group on POSIX when possible.
- */
-export async function killProcessTree(pid: number | undefined): Promise<void> {
-  if (pid == null || !Number.isFinite(pid) || pid <= 0) return;
-  if (process.platform === "win32") {
-    await killWindowsTree(pid);
-    return;
-  }
-  await killPosixTree(pid);
-}
-
-function killWindowsTree(pid: number): Promise<void> {
-  return new Promise<void>((resolve) => {
-    let resolved = false;
-    const done = () => {
-      if (resolved) return;
-      resolved = true;
-      resolve();
-    };
-
-    try {
-      const proc = spawn("taskkill", ["/pid", String(pid), "/T", "/F"], {
-        stdio: "ignore",
-        windowsHide: true,
-      });
-      proc.once("error", (err) => {
-        console.warn(`[killProcessTree] taskkill spawn error for pid=${pid}: ${(err as Error).message}`);
-        done();
-      });
-      proc.once("close", () => { done(); });
-      setTimeout(done, 3000).unref();
-    } catch (err) {
-      console.warn(`[killProcessTree] taskkill failed for pid=${pid}: ${(err as Error).message}`);
-      done();
-    }
-  });
-}
-
-async function killPosixTree(pid: number): Promise<void> {
-  trySignal(-pid, "SIGTERM");
-  trySignal(pid, "SIGTERM");
-  await new Promise((resolve) => setTimeout(resolve, 1000));
-  trySignal(-pid, "SIGKILL");
-  trySignal(pid, "SIGKILL");
-}
-
-function trySignal(target: number, signal: NodeJS.Signals): void {
-  try {
-    process.kill(target, signal);
-  } catch {
-    // Process is already gone or cannot be signaled.
-  }
-}
+import { spawn } from "node:child_process";
+
+/**
+ * Best-effort process-tree termination.
+ *
+ * Commands are spawned through a platform shell, so the pid we get is often
+ * the outer shell process. Killing only that process can leave the real child
+ * command running. This helper targets the whole process tree on Windows and
+ * the process group on POSIX when possible.
+ */
+export async function killProcessTree(pid: number | undefined): Promise<void> {
+  if (pid == null || !Number.isFinite(pid) || pid <= 0) return;
+  if (process.platform === "win32") {
+    await killWindowsTree(pid);
+    return;
+  }
+  await killPosixTree(pid);
+}
+
+function killWindowsTree(pid: number): Promise<void> {
+  return new Promise<void>((resolve) => {
+    let resolved = false;
+    const done = () => {
+      if (resolved) return;
+      resolved = true;
+      resolve();
+    };
+
+    try {
+      const proc = spawn("taskkill", ["/pid", String(pid), "/T", "/F"], {
+        stdio: "ignore",
+        windowsHide: true,
+      });
+      proc.once("error", (err) => {
+        console.warn(`[killProcessTree] taskkill spawn error for pid=${pid}: ${(err as Error).message}`);
+        done();
+      });
+      proc.once("close", () => { done(); });
+      setTimeout(done, 3000).unref();
+    } catch (err) {
+      console.warn(`[killProcessTree] taskkill failed for pid=${pid}: ${(err as Error).message}`);
+      done();
+    }
+  });
+}
+
+async function killPosixTree(pid: number): Promise<void> {
+  trySignal(-pid, "SIGTERM");
+  trySignal(pid, "SIGTERM");
+  await new Promise((resolve) => setTimeout(resolve, 1000));
+  trySignal(-pid, "SIGKILL");
+  trySignal(pid, "SIGKILL");
+}
+
+function trySignal(target: number, signal: NodeJS.Signals): void {
+  try {
+    process.kill(target, signal);
+  } catch {
+    // Process is already gone or cannot be signaled.
+  }
+}

package/src/builtin/progress/cards-helpers.ts

@@ -1,76 +1,76 @@
-/**
- * progress/cards-helpers.ts — 从 ChatCCC cards.ts 提取的纯函数（DeepCCC 独立版）
- *
- * terminal-renderer 需要 getToolEmoji（工具 emoji 映射）和 truncateContent
- * （正文按行/字符截断）。DeepCCC 没有飞书卡片模块，这两个函数在此独立存放，
- * 与 ChatCCC 保持一致实现，避免引入整张卡片模块。
- */
-
-// 检测 markdown 代码块是否未闭合（``` 出现奇数次）
-export function isCodeBlockOpen(text: string): boolean {
-  const matches = text.match(/```/g);
-  return matches ? matches.length % 2 !== 0 : false;
-}
-
-export function truncateContent(text: string, maxLines = 20, maxChars = 8000): string {
-  const lines = text.split("\n");
-  // 跳过开头空行
-  let startIdx = 0;
-  while (startIdx < lines.length && lines[startIdx].trim() === "") {
-    startIdx++;
-  }
-  const effectiveLines = lines.slice(startIdx);
-  let displayText: string;
-  if (effectiveLines.length > maxLines) {
-    const firstLine = effectiveLines[0];
-    const lastLines = effectiveLines.slice(-(maxLines - 1)).join("\n");
-    displayText = firstLine + "\n...\n" + lastLines;
-  } else {
-    displayText = text;
-  }
-
-  // 截断后如果代码块未闭合，补上闭合标记，避免后续追加内容时误入代码块
-  if (isCodeBlockOpen(displayText)) {
-    displayText += "\n```";
-  }
-
-  return displayText;
-}
-
-const TOOL_EMOJI_MAP: Record<string, string> = {
-  Read: "\u{1F4D6}",          // 📖
-  Write: "\u{270D}\u{FE0F}",  // ✍️
-  Edit: "\u{270F}\u{FE0F}",   // ✏️
-  Grep: "\u{1F50E}",          // 🔎
-  Glob: "\u{1F4C2}",          // 📂
-  Bash: "\u{1F5A5}\u{FE0F}",  // 🖥️
-  WebSearch: "\u{1F310}",     // 🌐
-  WebFetch: "\u{1F4E5}",      // 📥
-  TodoWrite: "\u{2705}",      // ✅
-  Agent: "\u{1F916}",         // 🤖
-  NotebookEdit: "\u{1F4D3}",  // 📓
-  AskUserQuestion: "\u{2753}",// ❓
-  // CCC 内置 Agent 下划线命名（getToolEmoji 会先把下划线转驼峰再查表，这里保留蛇形条目以便直接命中）
-  read_file: "\u{1F4D6}",          // 📖
-  list_dir: "\u{1F4C2}",          // 📂
-  search_code: "\u{1F50E}",       // 🔎
-  run_command: "\u{1F5A5}\u{FE0F}", // 🖥️
-  edit_file: "\u{270F}\u{FE0F}",  // ✏️
-  create_file: "\u{270D}\u{FE0F}", // ✍️
-  delete_file: "\u{1F5D1}\u{FE0F}", // 🗑️
-  move_file: "\u{1F4E6}",         // 📦
-  apply_patch: "\u{1F4CB}",       // 📋
-};
-
-export function getToolEmoji(name: string): string {
-  return TOOL_EMOJI_MAP[name] ?? TOOL_EMOJI_MAP[normalizeToolName(name)] ?? "\u{1F527}"; // 🔧
-}
-
-/** 把下划线命名转成驼峰（read_file → ReadFile），用于兼容两种命名风格 */
-export function normalizeToolName(name: string): string {
-  return name
-    .split("_")
-    .filter((part) => part.length > 0)
-    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-    .join("");
-}
+/**
+ * progress/cards-helpers.ts — 从 ChatCCC cards.ts 提取的纯函数（DeepCCC 独立版）
+ *
+ * terminal-renderer 需要 getToolEmoji（工具 emoji 映射）和 truncateContent
+ * （正文按行/字符截断）。DeepCCC 没有飞书卡片模块，这两个函数在此独立存放，
+ * 与 ChatCCC 保持一致实现，避免引入整张卡片模块。
+ */
+
+// 检测 markdown 代码块是否未闭合（``` 出现奇数次）
+export function isCodeBlockOpen(text: string): boolean {
+  const matches = text.match(/```/g);
+  return matches ? matches.length % 2 !== 0 : false;
+}
+
+export function truncateContent(text: string, maxLines = 20, maxChars = 8000): string {
+  const lines = text.split("\n");
+  // 跳过开头空行
+  let startIdx = 0;
+  while (startIdx < lines.length && lines[startIdx].trim() === "") {
+    startIdx++;
+  }
+  const effectiveLines = lines.slice(startIdx);
+  let displayText: string;
+  if (effectiveLines.length > maxLines) {
+    const firstLine = effectiveLines[0];
+    const lastLines = effectiveLines.slice(-(maxLines - 1)).join("\n");
+    displayText = firstLine + "\n...\n" + lastLines;
+  } else {
+    displayText = text;
+  }
+
+  // 截断后如果代码块未闭合，补上闭合标记，避免后续追加内容时误入代码块
+  if (isCodeBlockOpen(displayText)) {
+    displayText += "\n```";
+  }
+
+  return displayText;
+}
+
+const TOOL_EMOJI_MAP: Record<string, string> = {
+  Read: "\u{1F4D6}",          // 📖
+  Write: "\u{270D}\u{FE0F}",  // ✍️
+  Edit: "\u{270F}\u{FE0F}",   // ✏️
+  Grep: "\u{1F50E}",          // 🔎
+  Glob: "\u{1F4C2}",          // 📂
+  Bash: "\u{1F5A5}\u{FE0F}",  // 🖥️
+  WebSearch: "\u{1F310}",     // 🌐
+  WebFetch: "\u{1F4E5}",      // 📥
+  TodoWrite: "\u{2705}",      // ✅
+  Agent: "\u{1F916}",         // 🤖
+  NotebookEdit: "\u{1F4D3}",  // 📓
+  AskUserQuestion: "\u{2753}",// ❓
+  // CCC 内置 Agent 下划线命名（getToolEmoji 会先把下划线转驼峰再查表，这里保留蛇形条目以便直接命中）
+  read_file: "\u{1F4D6}",          // 📖
+  list_dir: "\u{1F4C2}",          // 📂
+  search_code: "\u{1F50E}",       // 🔎
+  run_command: "\u{1F5A5}\u{FE0F}", // 🖥️
+  edit_file: "\u{270F}\u{FE0F}",  // ✏️
+  create_file: "\u{270D}\u{FE0F}", // ✍️
+  delete_file: "\u{1F5D1}\u{FE0F}", // 🗑️
+  move_file: "\u{1F4E6}",         // 📦
+  apply_patch: "\u{1F4CB}",       // 📋
+};
+
+export function getToolEmoji(name: string): string {
+  return TOOL_EMOJI_MAP[name] ?? TOOL_EMOJI_MAP[normalizeToolName(name)] ?? "\u{1F527}"; // 🔧
+}
+
+/** 把下划线命名转成驼峰（read_file → ReadFile），用于兼容两种命名风格 */
+export function normalizeToolName(name: string): string {
+  return name
+    .split("_")
+    .filter((part) => part.length > 0)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join("");
+}

package/src/builtin/progress/reducer.ts

@@ -1,108 +1,113 @@
-/**
- * progress/reducer.ts — ChatEvent 事件流 → ProgressView 的增量合并
- *
- * 这是飞书与终端共享的唯一一份"事件 → 过程视图"公共逻辑：
- * 终端 REPL 直接消费 ChatSession.chat() 的事件流，逐条 reduce；
- * 飞书侧 display loop 若未来接入事件流，同样使用本 reducer，保证两端
- * 看到的过程状态（正文累积、工具调用、终态判定）完全一致。
- */
-
-import type { ChatEvent } from "../index.js";
-import {
-  withProgressView,
-  type ProgressToolCall,
-  type ProgressView,
-} from "./view.js";
-
-/** 工具调用 input 单行摘要（终端折叠行展示用） */
-export function summarizeToolInput(input: unknown, maxChars = 120): string {
-  let raw: string;
-  if (typeof input === "string") {
-    raw = input;
-  } else {
-    try {
-      raw = JSON.stringify(input);
-    } catch {
-      raw = String(input);
-    }
-  }
-  const oneLine = raw.replace(/\s+/g, " ").trim();
-  return oneLine.length > maxChars ? oneLine.slice(0, maxChars) + "…" : oneLine;
-}
-
-/** 工具结果单行摘要（成功/失败各取首行） */
-export function summarizeToolResult(content: unknown, maxChars = 120): string {
-  let raw: string;
-  if (typeof content === "string") {
-    raw = content;
-  } else if (content instanceof Error) {
-    raw = content.message;
-  } else {
-    try {
-      raw = JSON.stringify(content);
-    } catch {
-      raw = String(content);
-    }
-  }
-  const firstLine = raw.split("\n")[0] ?? "";
-  return firstLine.length > maxChars ? firstLine.slice(0, maxChars) + "…" : firstLine;
-}
-
-/**
- * 把一条 ChatEvent 合并进 ProgressView，返回新视图（不可变更新）。
- * 未识别的/不影响展示的事件（如 compact）返回原视图。
- */
-export function reduceProgress(prev: ProgressView, event: ChatEvent): ProgressView {
-  switch (event.type) {
-    case "text":
-      // accumulated 是全文累积，直接全量替换，天然幂等
-      return withProgressView(prev, { text: event.accumulated });
-
-    case "tool_use": {
-      const tool: ProgressToolCall = {
-        id: event.id ?? `tool-${prev.tools.length + 1}`,
-        name: event.name,
-        status: "running",
-        detail: summarizeToolInput(event.input),
-      };
-      return withProgressView(prev, { tools: [...prev.tools, tool] });
-    }
-
-    case "tool_result": {
-      const nextStatus = event.is_error ? ("error" as const) : ("ok" as const);
-      const summary = summarizeToolResult(event.content);
-      let matched = false;
-      const tools = prev.tools.map((t) => {
-        if (matched || t.id !== event.tool_use_id) return t;
-        matched = true;
-        return { ...t, status: nextStatus, summary };
-      });
-      if (!matched) {
-        // id 缺失或失配：兜底更新最后一个 running 工具，避免状态悬挂
-        const lastRunning = [...prev.tools].reverse().findIndex((t) => t.status === "running");
-        if (lastRunning >= 0) {
-          const idx = prev.tools.length - 1 - lastRunning;
-          const updated = prev.tools.map((t, i) =>
-            i === idx ? { ...t, status: nextStatus, summary } : t,
-          );
-          return withProgressView(prev, { tools: updated });
-        }
-      }
-      return withProgressView(prev, { tools });
-    }
-
-    case "done":
-      return withProgressView(prev, {
-        status: "done",
-        showStop: false,
-        text: event.text,
-      });
-
-    case "error":
-      return withProgressView(prev, { status: "error", showStop: false });
-
-    case "compact":
-      // 旧上下文压缩不影响当前过程展示
-      return prev;
-  }
-}
+/**
+ * progress/reducer.ts — ChatEvent 事件流 → ProgressView 的增量合并
+ *
+ * 这是飞书与终端共享的唯一一份"事件 → 过程视图"公共逻辑：
+ * 终端 REPL 直接消费 ChatSession.chat() 的事件流，逐条 reduce；
+ * 飞书侧 display loop 若未来接入事件流，同样使用本 reducer，保证两端
+ * 看到的过程状态（正文累积、工具调用、终态判定）完全一致。
+ */
+
+import type { ChatEvent } from "../index.js";
+import {
+  withProgressView,
+  type ProgressToolCall,
+  type ProgressView,
+} from "./view.js";
+
+/** 工具调用 input 单行摘要（终端折叠行展示用） */
+export function summarizeToolInput(input: unknown, maxChars = 120): string {
+  let raw: string;
+  if (typeof input === "string") {
+    raw = input;
+  } else {
+    try {
+      raw = JSON.stringify(input);
+    } catch {
+      raw = String(input);
+    }
+  }
+  const oneLine = raw.replace(/\s+/g, " ").trim();
+  return oneLine.length > maxChars ? oneLine.slice(0, maxChars) + "…" : oneLine;
+}
+
+/** 工具结果单行摘要（成功/失败各取首行） */
+export function summarizeToolResult(content: unknown, maxChars = 120): string {
+  let raw: string;
+  if (typeof content === "string") {
+    raw = content;
+  } else if (content instanceof Error) {
+    raw = content.message;
+  } else {
+    try {
+      raw = JSON.stringify(content);
+    } catch {
+      raw = String(content);
+    }
+  }
+  const firstLine = raw.split("\n")[0] ?? "";
+  return firstLine.length > maxChars ? firstLine.slice(0, maxChars) + "…" : firstLine;
+}
+
+/**
+ * 把一条 ChatEvent 合并进 ProgressView，返回新视图（不可变更新）。
+ * 未识别的/不影响展示的事件（如 compact）返回原视图。
+ */
+export function reduceProgress(prev: ProgressView, event: ChatEvent): ProgressView {
+  switch (event.type) {
+    case "status":
+      return withProgressView(prev, {
+        headerTitle: event.phase === "compacting" ? "压缩上下文中..." : "生成回复中...",
+      });
+
+    case "text":
+      // accumulated 是全文累积，直接全量替换，天然幂等
+      return withProgressView(prev, { text: event.accumulated });
+
+    case "tool_use": {
+      const tool: ProgressToolCall = {
+        id: event.id ?? `tool-${prev.tools.length + 1}`,
+        name: event.name,
+        status: "running",
+        detail: summarizeToolInput(event.input),
+      };
+      return withProgressView(prev, { tools: [...prev.tools, tool] });
+    }
+
+    case "tool_result": {
+      const nextStatus = event.is_error ? ("error" as const) : ("ok" as const);
+      const summary = summarizeToolResult(event.content);
+      let matched = false;
+      const tools = prev.tools.map((t) => {
+        if (matched || t.id !== event.tool_use_id) return t;
+        matched = true;
+        return { ...t, status: nextStatus, summary };
+      });
+      if (!matched) {
+        // id 缺失或失配：兜底更新最后一个 running 工具，避免状态悬挂
+        const lastRunning = [...prev.tools].reverse().findIndex((t) => t.status === "running");
+        if (lastRunning >= 0) {
+          const idx = prev.tools.length - 1 - lastRunning;
+          const updated = prev.tools.map((t, i) =>
+            i === idx ? { ...t, status: nextStatus, summary } : t,
+          );
+          return withProgressView(prev, { tools: updated });
+        }
+      }
+      return withProgressView(prev, { tools });
+    }
+
+    case "done":
+      return withProgressView(prev, {
+        status: "done",
+        showStop: false,
+        text: event.text,
+      });
+
+    case "error":
+      return withProgressView(prev, { status: "error", showStop: false });
+
+    case "compact":
+      // 旧上下文压缩不影响当前过程展示
+      return prev;
+  }
+}