chatccc 0.2.230 → 0.2.232

package/src/progress/reducer.ts

@@ -54,6 +54,11 @@ export function summarizeToolResult(content: unknown, maxChars = 120): string {
  */
 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 });

package/src/session.ts

@@ -41,14 +41,14 @@ import { createCccAdapter } from "./adapters/ccc-adapter.ts";
 import { killProcessTree } from "./adapters/proc-tree-kill.ts";
 import { resourceMonitor, registerProcess, unregisterProcess } from "./adapters/resource-monitor.ts";
 import { buildImSkillsPromptCached, exportSkillSubDocs, clearImSkillsPromptCache } from "./im-skills.ts";
-import type { PlatformAdapter } from "./platform-adapter.ts";
-import { hasResponseStalled, observeResponseProgress } from "./response-stall.ts";
-import {
-  classifyTerminalError,
-  formatTerminalErrorNotice,
-  formatTerminalErrorReason,
-  type TerminalErrorInfo,
-} from "./terminal-error.ts";
+import type { PlatformAdapter } from "./platform-adapter.ts";
+import { hasResponseStalled, observeResponseProgress } from "./response-stall.ts";
+import {
+  classifyTerminalError,
+  formatTerminalErrorNotice,
+  formatTerminalErrorReason,
+  type TerminalErrorInfo,
+} from "./terminal-error.ts";
 import {
   MAX_PROCESSED,
   clearFeishuMessageLedgerMemory,
@@ -181,8 +181,8 @@ const DEFAULT_FINAL_RESPONSE_CLOSE_TIMEOUT_MS = 10_000;
 export const RESPONSE_STALL_RECOVERY_PROMPT = "完成了吗？如果没完成继续";
 export const RESPONSE_STALL_RECOVERY_NOTICE =
   `检测到会话停滞，正在自动确认并继续。\n\n${RESPONSE_STALL_RECOVERY_PROMPT}`;
-export const RESPONSE_STALL_RECOVERY_EXHAUSTED_NOTICE =
-  "⚠️ 自动续跑仍连续 3 分钟没有启动进展或新回复，本次不再自动继续。";
+export const RESPONSE_STALL_RECOVERY_EXHAUSTED_NOTICE =
+  "⚠️ 自动续跑仍连续 3 分钟没有生成新回复，本次不再自动继续。";
 const RESPONSE_STALL_RECOVERY_DELAY_MS = 200;
 let processMonitorIntervalMs = DEFAULT_PROCESS_MONITOR_INTERVAL_MS;
 let responseStallTimeoutMs = DEFAULT_RESPONSE_STALL_TIMEOUT_MS;
@@ -311,18 +311,18 @@ function scheduleFinalResponseCloseGuard(
   runningPrompt.finalResponseCloseTimer = handle;
 }
 
-function formatTerminalHeader(
-  status: "running" | "done" | "stopped" | "error" | "auto_ended",
-  terminalError?: TerminalErrorInfo,
-): {
+function formatTerminalHeader(
+  status: "running" | "done" | "stopped" | "error" | "auto_ended",
+  terminalError?: TerminalErrorInfo,
+): {
   title: string;
   template?: string;
 } {
   if (status === "auto_ended") return { title: "已自动结束 · 3分钟无新内容", template: "orange" };
   if (status === "stopped") return { title: "已停止", template: "red" };
-  if (status === "error") {
-    return { title: terminalError ? `异常结束 · ${terminalError.title}` : "异常结束", template: "red" };
-  }
+  if (status === "error") {
+    return { title: terminalError ? `异常结束 · ${terminalError.title}` : "异常结束", template: "red" };
+  }
   return { title: "完成" };
 }
 
@@ -330,59 +330,59 @@ function turnFinalStatus(status: "running" | "done" | "stopped" | "error" | "aut
   return status === "stopped" || status === "error" || status === "auto_ended" ? "stopped" : "done";
 }
 
-function formatAutoEndedReply(finalReply: string): string {
-  const reason = "⚠️ 已自动结束：连续 3 分钟没有启动进展或回复字符变化。";
+function formatAutoEndedReply(finalReply: string): string {
+  const reason = "⚠️ 已自动结束：生成回复阶段连续 3 分钟没有字符变化。";
   return finalReply
     ? `${reason}以下回复可能不完整。\n\n${finalReply}`
     : `${reason}本轮没有可发送的回复内容。`;
 }
 
 /**
- * 只监控用户无法判断是否仍有进展的两个阶段。思考、工具调用和搜索可能合法地
- * 长时间不产生回复字符，由资源监控负责识别真正僵死，不能在这里误杀。
+ * 只监控明确的回复生成阶段。启动、压缩、思考、工具调用和搜索都有各自的
+ * 状态或资源保护，不能把它们消耗的时间算入回复停滞窗口。
  */
-function monitorsOutputProgress(kind: AgentActivityKind): boolean {
-  return kind === "starting" || kind === "responding";
-}
-
-function formatTerminalReply(
-  status: "running" | "done" | "stopped" | "error" | "auto_ended",
-  finalReply: string,
-  terminalError?: TerminalErrorInfo,
-): string | null {
-  if (status === "auto_ended") return formatAutoEndedReply(finalReply);
-  if (status === "error") {
-    const error = terminalError ?? {
-      kind: "unknown" as const,
-      title: "原因未记录",
-      message: "当前状态中没有可用的错误详情，请查看运行日志。",
-      occurredAt: Date.now(),
-    };
-    return formatTerminalErrorNotice(error, finalReply);
-  }
-  return finalReply || null;
-}
-
-function formatTerminalCardContent(state: {
-  status: "running" | "done" | "stopped" | "error" | "auto_ended";
-  accumulatedContent: string;
-  finalReply: string;
-  terminalError?: TerminalErrorInfo;
-}): string {
-  const content = state.accumulatedContent + state.finalReply;
-  if (state.status !== "error") return content;
-
-  const error = state.terminalError ?? {
-    kind: "unknown" as const,
-    title: "原因未记录",
-    message: "当前状态中没有可用的错误详情，请查看运行日志。",
-    occurredAt: Date.now(),
-  };
-  const reason = formatTerminalErrorReason(error);
-  return content.trim()
-    ? `${content}\n\n${reason}\n以上内容可能不完整。`
-    : reason;
-}
+function monitorsOutputProgress(kind: AgentActivityKind): boolean {
+  return kind === "responding";
+}
+
+function formatTerminalReply(
+  status: "running" | "done" | "stopped" | "error" | "auto_ended",
+  finalReply: string,
+  terminalError?: TerminalErrorInfo,
+): string | null {
+  if (status === "auto_ended") return formatAutoEndedReply(finalReply);
+  if (status === "error") {
+    const error = terminalError ?? {
+      kind: "unknown" as const,
+      title: "原因未记录",
+      message: "当前状态中没有可用的错误详情，请查看运行日志。",
+      occurredAt: Date.now(),
+    };
+    return formatTerminalErrorNotice(error, finalReply);
+  }
+  return finalReply || null;
+}
+
+function formatTerminalCardContent(state: {
+  status: "running" | "done" | "stopped" | "error" | "auto_ended";
+  accumulatedContent: string;
+  finalReply: string;
+  terminalError?: TerminalErrorInfo;
+}): string {
+  const content = state.accumulatedContent + state.finalReply;
+  if (state.status !== "error") return content;
+
+  const error = state.terminalError ?? {
+    kind: "unknown" as const,
+    title: "原因未记录",
+    message: "当前状态中没有可用的错误详情，请查看运行日志。",
+    occurredAt: Date.now(),
+  };
+  const reason = formatTerminalErrorReason(error);
+  return content.trim()
+    ? `${content}\n\n${reason}\n以上内容可能不完整。`
+    : reason;
+}
 
 function isCardKitSequenceConflict(err: unknown): boolean {
   return err instanceof Error && err.message.includes("300317");
@@ -948,14 +948,16 @@ export function accumulateBlockContent(
       // 覆盖而非追加：适配器已保证这是一段完整最终文本（如 Cursor 流末快照）
       state.finalCompleteText = block.text;
       break;
-    case "compact_boundary": {
+    case "compact_boundary": {
       const triggerLabel = block.trigger === "manual" ? "手动" : "自动"; // 手动 / 自动
       state.accumulatedContent +=
         `\n\n🔄 上下文压缩(${triggerLabel}): **${block.pre_tokens}** → **${block.post_tokens}** tokens\n`; // 🔄 / →
-      break;
-    }
-  }
-}
+      break;
+    }
+    case "agent_status":
+      break;
+  }
+}
 
 // ---------------------------------------------------------------------------
 // switchChatBinding — /newh、/session N 共用的事务式"切换 chat 绑定"
@@ -1144,7 +1146,7 @@ export async function initClaudeSession(tool: string, overrideCwd?: string, chat
   return { sessionId, cwd };
 }
 
-export async function resumeAndPrompt(
+export async function resumeAndPrompt(
   sessionId: string,
   userText: string,
   platform: PlatformAdapter,
@@ -1152,25 +1154,25 @@ export async function resumeAndPrompt(
   msgTimestamp: number,
   tool: string,
   traceId?: string,
-): Promise<SessionRunOutcome> {
-  return runAgentSession(sessionId, userText, platform, chatId, msgTimestamp, tool, traceId);
-}
+): Promise<SessionRunOutcome> {
+  return runAgentSession(sessionId, userText, platform, chatId, msgTimestamp, tool, traceId);
+}
 
 // ---------------------------------------------------------------------------
 // runAgentSession — session 中心的 agent prompt（文件持久化 + display 解耦）
 // ---------------------------------------------------------------------------
 
-interface RunAgentSessionOptions {
+interface RunAgentSessionOptions {
   /**
    * 标记本轮是 response-stall 后的唯一一次内部续跑。若本轮再次因相同原因
    * 停滞，不再递归创建第三轮，避免服务异常期间无限消耗 token。
    */
   autoRecovery?: boolean;
-}
-
-export type SessionRunOutcome = "busy" | "done" | "stopped" | "error" | "auto_ended";
+}
+
+export type SessionRunOutcome = "busy" | "done" | "stopped" | "error" | "auto_ended";
 
-export async function runAgentSession(
+export async function runAgentSession(
   sessionId: string,
   userText: string,
   platform: PlatformAdapter,
@@ -1179,7 +1181,7 @@ export async function runAgentSession(
   tool: string,
   traceId?: string,
   options: RunAgentSessionOptions = {},
-): Promise<SessionRunOutcome> {
+): Promise<SessionRunOutcome> {
   const tid = traceId ?? "";
 
   // runAgentSession 是飞书用户消息、队列消息与内部自动恢复共同使用的唯一
@@ -1206,7 +1208,7 @@ export async function runAgentSession(
       ? "当前正在生成回复中，请等待完成后再发送消息。也可以发送 /stop 结束，已完成的步骤不会丢失。"
       : "该会话正在生成回复中，请等待完成后再发送消息。也可以发送 /stop 结束，已完成的步骤不会丢失。";
     await platform.sendText(_chatId, busyMsg).catch(() => {});
-    return "busy";
+    return "busy";
   }
 
   // 立即标记活跃，确保 /sessions、isSessionRunning 等查询在异步准备阶段就能看到运行状态。
@@ -1334,7 +1336,7 @@ export async function runAgentSession(
   // 再开始缓存问题对应的任务"。
   const prevState = await readStreamState(sessionId);
   if (prevState && prevState.status !== "running") {
-    const prevTerminalReply = formatTerminalReply(prevState.status, prevState.finalReply, prevState.terminalError);
+    const prevTerminalReply = formatTerminalReply(prevState.status, prevState.finalReply, prevState.terminalError);
     const displayChatId = pickDisplayChat(sessionId);
     if (displayChatId) {
       const pp = platformForChat(displayChatId);
@@ -1353,8 +1355,8 @@ export async function runAgentSession(
           setSessionChatAvatar(pp, displayChatId, prevState.tool, "idle", sessionId).catch(() => {});
         } else {
           const nextSeq = display.sequence + 1;
-          const { title: headerTitle, template: headerTemplate } = formatTerminalHeader(prevState.status, prevState.terminalError);
-          const cardContent = truncateContent(formatTerminalCardContent(prevState)) || " ";
+          const { title: headerTitle, template: headerTemplate } = formatTerminalHeader(prevState.status, prevState.terminalError);
+          const cardContent = truncateContent(formatTerminalCardContent(prevState)) || " ";
           const doneCard = buildProgressCard(progressView({ text: cardContent, status: "done", showStop: false, headerTitle, headerTemplate }));
           await pp.cardUpdate(display.cardId, doneCard, nextSeq).catch(err => {
             console.error(`[${ts()}] [DISPLAY] prevState final cardUpdate failed: ${(err as Error).message}`);
@@ -1447,22 +1449,21 @@ export async function runAgentSession(
 
   let lastFileWrite = Date.now();
   const FILE_WRITE_INTERVAL_MS = 2000;
-  const toolCallMap = new Map<string, { name: string; input: unknown }>();
-  let streamErrored = false;
-  let streamTerminalError: TerminalErrorInfo | undefined;
-  let runOutcome: SessionRunOutcome = "error";
-
-  const runningPrompt = activePrompts.get(sessionId);
-  if (runningPrompt) {
-    // 必须在消费第一个事件前建立零字符基线。部分 CLI 卡死时只启动了进程，
-    // 甚至一个事件都不会 yield；若等循环体更新进度，这种会话会永久停在
-    // “正在启动 Agent”，也永远触发不了三分钟保护。
-    runningPrompt.responseProgress = observeResponseProgress(
-      undefined,
-      true,
-      0,
-      activityTracker.activity.startedAt,
-    );
+  const toolCallMap = new Map<string, { name: string; input: unknown }>();
+  let streamErrored = false;
+  let streamTerminalError: TerminalErrorInfo | undefined;
+  let runOutcome: SessionRunOutcome = "error";
+
+  const runningPrompt = activePrompts.get(sessionId);
+  if (runningPrompt) {
+    // 在消费第一个事件前建立阶段感知的零字符基线；启动阶段不计时，只有后续
+    // 收到明确的 responding 状态后才会启动三分钟回复停滞保护。
+    runningPrompt.responseProgress = observeResponseProgress(
+      undefined,
+      monitorsOutputProgress(activityTracker.activity.kind),
+      0,
+      activityTracker.activity.startedAt,
+    );
 
     const checkResponseStall = async () => {
       const current = activePrompts.get(sessionId);
@@ -1532,7 +1533,7 @@ export async function runAgentSession(
       current.controller.abort();
       await killProcessTree(current.processPid);
       console.warn(
-        `[${ts()}] [RESPONSE-STALL] Session ${sessionId} auto-ended after 3 minutes without startup or reply progress`,
+        `[${ts()}] [RESPONSE-STALL] Session ${sessionId} auto-ended after 3 minutes without reply progress`,
       );
     };
 
@@ -1624,10 +1625,10 @@ export async function runAgentSession(
         });
       }
     }
-  } catch (streamErr) {
-    streamErrored = true;
-    streamTerminalError = classifyTerminalError(streamErr);
-    console.error(`[${ts()}] [STREAM] Error in stream loop for ${sessionId}: ${(streamErr as Error).message}`);
+  } catch (streamErr) {
+    streamErrored = true;
+    streamTerminalError = classifyTerminalError(streamErr);
+    console.error(`[${ts()}] [STREAM] Error in stream loop for ${sessionId}: ${(streamErr as Error).message}`);
   } finally {
     // 标记 prompt 结束
     resourceMonitor.off("stuck", onResourceStuck);
@@ -1675,24 +1676,24 @@ export async function runAgentSession(
             : wasStopped
               ? "stopped"
               : "done";
-      const finalReply = pickFinalReply(state).trim();
-      const terminalError = streamTerminalError
-        ?? (wasAbnormalExit
-          ? {
-              kind: "process" as const,
-              title: "Agent 进程意外退出",
-              message: "Agent CLI 进程已退出。若回复不完整，请重新发送上一条指令。",
-              occurredAt: Date.now(),
-            }
-          : wasResourceStuck
-            ? {
-                kind: "resource" as const,
-                title: "Agent 进程失去响应",
-                message: "Agent 进程长时间没有 CPU 或内存变化，已被强制停止。若回复不完整，请重新发送上一条指令。",
-                occurredAt: Date.now(),
-              }
-            : undefined);
-      runOutcome = finalStatus;
+      const finalReply = pickFinalReply(state).trim();
+      const terminalError = streamTerminalError
+        ?? (wasAbnormalExit
+          ? {
+              kind: "process" as const,
+              title: "Agent 进程意外退出",
+              message: "Agent CLI 进程已退出。若回复不完整，请重新发送上一条指令。",
+              occurredAt: Date.now(),
+            }
+          : wasResourceStuck
+            ? {
+                kind: "resource" as const,
+                title: "Agent 进程失去响应",
+                message: "Agent 进程长时间没有 CPU 或内存变化，已被强制停止。若回复不完整，请重新发送上一条指令。",
+                occurredAt: Date.now(),
+              }
+            : undefined);
+      runOutcome = finalStatus;
 
     // stop-stuck-loop 接口可能在 fire-and-forget 中已写入带 final_reply 的
     // stream state，finally 不应覆盖它。同时保留 stuckAt 标记，防止
@@ -1722,9 +1723,9 @@ export async function runAgentSession(
       cwd,
       tool,
       ...(preserveStuckAt ? { stuckAt: preserveStuckAt } : {}),
-      ...(autoEndedAt !== undefined ? { autoEndedAt } : {}),
-      ...(terminalError ? { terminalError } : {}),
-    });
+      ...(autoEndedAt !== undefined ? { autoEndedAt } : {}),
+      ...(terminalError ? { terminalError } : {}),
+    });
 
     // display loop 下一轮会读到最终状态并发送消息
 
@@ -1795,9 +1796,9 @@ export async function runAgentSession(
           autoRecoveryTarget = { chatId: activeAutoEnded, platform: pp };
         }
       }
-      console.warn(`[${ts()}] Session ${sessionId} auto-ended after stalled startup or response output (content chunks: ${state.chunkCount})`);
+      console.warn(`[${ts()}] Session ${sessionId} auto-ended after stalled response output (content chunks: ${state.chunkCount})`);
       if (tid) logTrace(tid, "SESSION_END", { sessionId, outcome: "response_stall", chunks: state.chunkCount });
-    } else if (wasAbnormalExit) {
+    } else if (wasAbnormalExit) {
       for (const cid of finalizationChatIds) {
         const finfo = sessionInfoMap.get(cid);
         await recordSessionRegistry({
@@ -1812,55 +1813,55 @@ export async function runAgentSession(
       }
       const activeErr = getLastActiveChat(sessionId) ?? finalizationChatIds[0];
       if (activeErr) setSessionChatAvatar(platform, activeErr, tool, "idle", sessionId).catch(() => {});
-      console.log(`[${ts()}] Session ${sessionId} process exited unexpectedly (content chunks: ${state.chunkCount})`);
-      if (tid) logTrace(tid, "SESSION_END", { sessionId, outcome: "process_missing", chunks: state.chunkCount });
-    } else if (streamErrored || wasResourceStuck) {
-      for (const cid of finalizationChatIds) {
-        const finfo = sessionInfoMap.get(cid);
-        await recordSessionRegistry({
-          chatId: cid,
-          sessionId,
-          tool,
-          turnCount: finfo?.turnCount ?? nextTurnCount,
-          lastContextTokens: finfo?.lastContextTokens ?? nextContextTokens,
-          startTime: finfo?.startTime ?? now,
-          running: false,
-        });
-      }
-      const activeErr = getLastActiveChat(sessionId) ?? finalizationChatIds[0];
-      if (activeErr) {
-        const pp = platformForChat(activeErr) ?? platform;
-        const terminalState = await readStreamState(sessionId);
-        if (
-          terminalError
-          && !displayCards.has(activeErr)
-          && (!terminalState || !isFinalReplySentForTurn(terminalState))
-        ) {
-          await sendFinalReplyTextOnce(
-            pp,
-            activeErr,
-            sessionId,
-            nextTurnCount,
-            formatTerminalErrorNotice(terminalError, finalReplyToWrite),
-          );
-        }
-        setSessionChatAvatar(pp, activeErr, tool, "idle", sessionId).catch(() => {});
-      }
-      const errorOutcome = wasResourceStuck ? "resource_stuck" : "stream_error";
-      console.error(
-        `[${ts()}] Session ${sessionId} ended with ${errorOutcome}` +
-        `${terminalError ? ` (${terminalError.kind}: ${terminalError.title})` : ""} (content chunks: ${state.chunkCount})`,
-      );
-      if (tid) {
-        logTrace(tid, "SESSION_END", {
-          sessionId,
-          outcome: errorOutcome,
-          errorKind: terminalError?.kind,
-          errorTitle: terminalError?.title,
-          chunks: state.chunkCount,
-        });
-      }
-    } else {
+      console.log(`[${ts()}] Session ${sessionId} process exited unexpectedly (content chunks: ${state.chunkCount})`);
+      if (tid) logTrace(tid, "SESSION_END", { sessionId, outcome: "process_missing", chunks: state.chunkCount });
+    } else if (streamErrored || wasResourceStuck) {
+      for (const cid of finalizationChatIds) {
+        const finfo = sessionInfoMap.get(cid);
+        await recordSessionRegistry({
+          chatId: cid,
+          sessionId,
+          tool,
+          turnCount: finfo?.turnCount ?? nextTurnCount,
+          lastContextTokens: finfo?.lastContextTokens ?? nextContextTokens,
+          startTime: finfo?.startTime ?? now,
+          running: false,
+        });
+      }
+      const activeErr = getLastActiveChat(sessionId) ?? finalizationChatIds[0];
+      if (activeErr) {
+        const pp = platformForChat(activeErr) ?? platform;
+        const terminalState = await readStreamState(sessionId);
+        if (
+          terminalError
+          && !displayCards.has(activeErr)
+          && (!terminalState || !isFinalReplySentForTurn(terminalState))
+        ) {
+          await sendFinalReplyTextOnce(
+            pp,
+            activeErr,
+            sessionId,
+            nextTurnCount,
+            formatTerminalErrorNotice(terminalError, finalReplyToWrite),
+          );
+        }
+        setSessionChatAvatar(pp, activeErr, tool, "idle", sessionId).catch(() => {});
+      }
+      const errorOutcome = wasResourceStuck ? "resource_stuck" : "stream_error";
+      console.error(
+        `[${ts()}] Session ${sessionId} ended with ${errorOutcome}` +
+        `${terminalError ? ` (${terminalError.kind}: ${terminalError.title})` : ""} (content chunks: ${state.chunkCount})`,
+      );
+      if (tid) {
+        logTrace(tid, "SESSION_END", {
+          sessionId,
+          outcome: errorOutcome,
+          errorKind: terminalError?.kind,
+          errorTitle: terminalError?.title,
+          chunks: state.chunkCount,
+        });
+      }
+    } else {
       for (const cid of finalizationChatIds) {
         const finfo = sessionInfoMap.get(cid);
         await recordSessionRegistry({
@@ -1972,9 +1973,9 @@ export async function runAgentSession(
     } finally {
       clearSessionFinalizing(sessionId);
     }
-  }
-  return runOutcome;
-}
+  }
+  return runOutcome;
+}
 
 // ---------------------------------------------------------------------------
 // startUnifiedDisplayLoop — 全局统一 display 循环，遍历 displayCards 更新卡片
@@ -2051,13 +2052,13 @@ export function startUnifiedDisplayLoop(): void {
               if (activePrompts.has(sessionId)) continue;
 
               const tail = "━━━ 回答结束 ━━━";
-              const finalMsg = state.status === "auto_ended"
-                ? formatAutoEndedReply(remaining)
-                : state.status === "error"
-                  ? formatTerminalReply(state.status, remaining, state.terminalError) ?? tail
-                  : remaining
-                    ? remaining + "\n" + tail
-                    : tail;
+              const finalMsg = state.status === "auto_ended"
+                ? formatAutoEndedReply(remaining)
+                : state.status === "error"
+                  ? formatTerminalReply(state.status, remaining, state.terminalError) ?? tail
+                  : remaining
+                    ? remaining + "\n" + tail
+                    : tail;
               if (!isFinalReplySentForTurn(state)) {
                 await sendFinalReplyTextOnce(p, chatId, sessionId, state.turnCount, finalMsg);
               }
@@ -2079,8 +2080,8 @@ export function startUnifiedDisplayLoop(): void {
               let terminalCardUpdateAccepted = terminalCardAlreadyUpdated;
               if (!terminalCardAlreadyUpdated) {
                 const nextSeq = display.sequence + 1;
-                const { title: headerTitle, template: headerTemplate } = formatTerminalHeader(state.status, state.terminalError);
-                const cardContent = truncateContent(formatTerminalCardContent(state)) || " ";
+                const { title: headerTitle, template: headerTemplate } = formatTerminalHeader(state.status, state.terminalError);
+                const cardContent = truncateContent(formatTerminalCardContent(state)) || " ";
                 const doneCard = buildProgressCard(progressView({ text: cardContent, status: "done", showStop: false, headerTitle, headerTemplate }));
                 await p.cardUpdate(display.cardId, doneCard, nextSeq).then(() => {
                   display.sequence = nextSeq;
@@ -2107,19 +2108,19 @@ export function startUnifiedDisplayLoop(): void {
               }
 
               let terminalTextDelivered = true;
-              const terminalReply = formatTerminalReply(state.status, state.finalReply, state.terminalError);
-              const errorWasDeliveredByCard =
-                state.status === "error"
-                && !state.finalReply.trim()
-                && terminalCardUpdateAccepted;
-              if (errorWasDeliveredByCard) {
-                if (!isFinalReplySentForTurn(state)) {
-                  await markFinalReplySent(sessionId, state.turnCount);
-                }
-              } else if (terminalReply) {
-                if (!isFinalReplySentForTurn(state)) {
-                  terminalTextDelivered = await sendFinalReplyTextOnce(p, chatId, sessionId, state.turnCount, terminalReply);
-                }
+              const terminalReply = formatTerminalReply(state.status, state.finalReply, state.terminalError);
+              const errorWasDeliveredByCard =
+                state.status === "error"
+                && !state.finalReply.trim()
+                && terminalCardUpdateAccepted;
+              if (errorWasDeliveredByCard) {
+                if (!isFinalReplySentForTurn(state)) {
+                  await markFinalReplySent(sessionId, state.turnCount);
+                }
+              } else if (terminalReply) {
+                if (!isFinalReplySentForTurn(state)) {
+                  terminalTextDelivered = await sendFinalReplyTextOnce(p, chatId, sessionId, state.turnCount, terminalReply);
+                }
               } else if (state.accumulatedContent.trim()) {
                 const short = truncateContent(state.accumulatedContent, 30, 4000);
                 terminalTextDelivered = await p.sendText(chatId, `[生成过程]\n${short}`).then((ok) => ok !== false).catch(() => false);