chatccc 0.2.222 → 0.2.224

package/src/session.ts

@@ -2,9 +2,9 @@ import { readFile, writeFile, mkdir } from "node:fs/promises";
 import { dirname, join } from "node:path";
 
 import {
-  CLAUDE_API_KEY,
-  CLAUDE_BASE_URL,
-  CLAUDE_MAX_TURN,
+  CLAUDE_API_KEY,
+  CLAUDE_BASE_URL,
+  CLAUDE_MAX_TURN,
   CLAUDE_MODEL,
   CLAUDE_SUBAGENT_MODEL,
   CHATCCC_PORT,
@@ -14,41 +14,42 @@ import {
   addRecentDir,
   anthropicConfigDisplay,
   config,
-  fileLog,
-  getDefaultCwd,
-  getDefaultEffortForTool,
-  isAnthropicConfigEmpty,
-  toolDisplayName,
-  ts,
-} from "./config.ts";
-import { buildProgressCard, getToolEmoji, isCodeBlockOpen, truncateContent } from "./cards.ts";
-import {
-  createAgentActivityTracker,
-  formatAgentActivityTitle,
-  updateAgentActivity,
-} from "./agent-activity.ts";
-import type { AgentActivityKind } from "./agent-activity.ts";
+  fileLog,
+  getDefaultCwd,
+  getDefaultEffortForTool,
+  isAnthropicConfigEmpty,
+  toolDisplayName,
+  ts,
+} from "./config.ts";
+import { buildProgressCard, getToolEmoji, isCodeBlockOpen, truncateContent } from "./cards.ts";
+import { progressView } from "./progress/view.ts";
+import {
+  createAgentActivityTracker,
+  formatAgentActivityTitle,
+  updateAgentActivity,
+} from "./agent-activity.ts";
+import type { AgentActivityKind } from "./agent-activity.ts";
 import { simplifyToolUse, simplifyToolResult } from "./simplify.ts";
 import { logTrace } from "./trace.ts";
 import type { UnifiedBlock } from "./adapters/adapter-interface.ts";
 import type { ToolAdapter } from "./adapters/adapter-interface.ts";
 import type { ToolProcessInfo } from "./adapters/adapter-interface.ts";
-import { createClaudeAdapter } from "./adapters/claude-adapter.ts";
-import { createCursorAdapter } from "./adapters/cursor-adapter.ts";
-import { createCodexAdapter } from "./adapters/codex-adapter.ts";
-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 {
-  MAX_PROCESSED,
-  clearFeishuMessageLedgerMemory,
-  processedMessages,
-} from "./feishu-message-ingress.ts";
-
-export { MAX_PROCESSED, processedMessages };
+import { createClaudeAdapter } from "./adapters/claude-adapter.ts";
+import { createCursorAdapter } from "./adapters/cursor-adapter.ts";
+import { createCodexAdapter } from "./adapters/codex-adapter.ts";
+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 {
+  MAX_PROCESSED,
+  clearFeishuMessageLedgerMemory,
+  processedMessages,
+} from "./feishu-message-ingress.ts";
+
+export { MAX_PROCESSED, processedMessages };
 
 // 微信显示循环压缩：头5 + ... + 尾5，避免在最后一步 sendText 中压缩指令回复
 function compressWechatDisplayText(text: string): string {
@@ -80,16 +81,16 @@ import {
   pickDisplayChat,
   dequeueMessage,
   consumeQueuedMessage,
-  cancelQueuedMessage,
-  setQueuePreservedChat,
-  consumeQueuePreservedChat,
-  markSessionFinalizing,
-  clearSessionFinalizing,
-  reserveAutoRecovery,
-  consumeAutoRecoveryReservation,
-  cancelAutoRecoveryReservation,
-  hasAutoRecoveryReservation,
-} from "./session-chat-binding.ts";
+  cancelQueuedMessage,
+  setQueuePreservedChat,
+  consumeQueuePreservedChat,
+  markSessionFinalizing,
+  clearSessionFinalizing,
+  reserveAutoRecovery,
+  consumeAutoRecoveryReservation,
+  cancelAutoRecoveryReservation,
+  hasAutoRecoveryReservation,
+} from "./session-chat-binding.ts";
 
 async function sendFinalReplyTextOnce(
   platform: PlatformAdapter,
@@ -103,19 +104,19 @@ async function sendFinalReplyTextOnce(
   return sent;
 }
 
-async function createVisibleProgressCard(
+async function createVisibleProgressCard(
   platform: PlatformAdapter,
   chatId: string,
   sessionId: string,
-  turnCount: number,
-  notifyFailureText?: string,
-  headerTitle = "正在启动 Agent · 0秒",
-): Promise<string | null> {
+  turnCount: number,
+  notifyFailureText?: string,
+  headerTitle = "正在启动 Agent · 0秒",
+): Promise<string | null> {
   for (let attempt = 1; attempt <= 2; attempt++) {
     let cardId: string | null = null;
     try {
-      cardId = await platform.cardCreate(
-        buildProgressCard("等待 Agent 输出...", { showStop: true, headerTitle }),
+      cardId = await platform.cardCreate(
+        buildProgressCard(progressView({ text: "等待 Agent 输出...", showStop: true, headerTitle })),
       );
       if (!cardId) throw new Error("empty card id");
       await platform.cardSend(chatId, cardId);
@@ -167,20 +168,20 @@ function platformForChat(chatId: string): PlatformAdapter | null {
   return chatPlatformMap.get(chatId) ?? platformRef;
 }
 
-const DEFAULT_PROCESS_MONITOR_INTERVAL_MS = 5000;
-const DEFAULT_RESPONSE_STALL_TIMEOUT_MS = 3 * 60 * 1000;
-const DEFAULT_RESPONSE_STALL_CHECK_INTERVAL_MS = 5000;
-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 分钟没有启动进展或新回复，本次不再自动继续。";
-const RESPONSE_STALL_RECOVERY_DELAY_MS = 200;
-let processMonitorIntervalMs = DEFAULT_PROCESS_MONITOR_INTERVAL_MS;
-let responseStallTimeoutMs = DEFAULT_RESPONSE_STALL_TIMEOUT_MS;
-let responseStallCheckIntervalMs = DEFAULT_RESPONSE_STALL_CHECK_INTERVAL_MS;
-let finalResponseCloseTimeoutMs = DEFAULT_FINAL_RESPONSE_CLOSE_TIMEOUT_MS;
+const DEFAULT_PROCESS_MONITOR_INTERVAL_MS = 5000;
+const DEFAULT_RESPONSE_STALL_TIMEOUT_MS = 3 * 60 * 1000;
+const DEFAULT_RESPONSE_STALL_CHECK_INTERVAL_MS = 5000;
+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 分钟没有启动进展或新回复，本次不再自动继续。";
+const RESPONSE_STALL_RECOVERY_DELAY_MS = 200;
+let processMonitorIntervalMs = DEFAULT_PROCESS_MONITOR_INTERVAL_MS;
+let responseStallTimeoutMs = DEFAULT_RESPONSE_STALL_TIMEOUT_MS;
+let responseStallCheckIntervalMs = DEFAULT_RESPONSE_STALL_CHECK_INTERVAL_MS;
+let finalResponseCloseTimeoutMs = DEFAULT_FINAL_RESPONSE_CLOSE_TIMEOUT_MS;
 let isProcessAliveImpl = (pid: number): boolean => {
   try {
     process.kill(pid, 0);
@@ -209,137 +210,137 @@ export function _setProcessMonitorIntervalForTest(ms: number): void {
   processMonitorIntervalMs = ms;
 }
 
-export function _resetProcessMonitorIntervalForTest(): void {
-  processMonitorIntervalMs = DEFAULT_PROCESS_MONITOR_INTERVAL_MS;
-}
-
-export function _setResponseStallTimeoutForTest(ms: number): void {
-  responseStallTimeoutMs = ms;
-}
-
-export function _resetResponseStallTimeoutForTest(): void {
-  responseStallTimeoutMs = DEFAULT_RESPONSE_STALL_TIMEOUT_MS;
-}
-
-export function _setResponseStallCheckIntervalForTest(ms: number): void {
-  responseStallCheckIntervalMs = ms;
-}
-
-export function _resetResponseStallCheckIntervalForTest(): void {
-  responseStallCheckIntervalMs = DEFAULT_RESPONSE_STALL_CHECK_INTERVAL_MS;
-}
-
-export function _setFinalResponseCloseTimeoutForTest(ms: number): void {
-  finalResponseCloseTimeoutMs = ms;
-}
-
-export function _resetFinalResponseCloseTimeoutForTest(): void {
-  finalResponseCloseTimeoutMs = DEFAULT_FINAL_RESPONSE_CLOSE_TIMEOUT_MS;
-}
-
-function clearPromptProcessMonitor(sessionId: string): void {
+export function _resetProcessMonitorIntervalForTest(): void {
+  processMonitorIntervalMs = DEFAULT_PROCESS_MONITOR_INTERVAL_MS;
+}
+
+export function _setResponseStallTimeoutForTest(ms: number): void {
+  responseStallTimeoutMs = ms;
+}
+
+export function _resetResponseStallTimeoutForTest(): void {
+  responseStallTimeoutMs = DEFAULT_RESPONSE_STALL_TIMEOUT_MS;
+}
+
+export function _setResponseStallCheckIntervalForTest(ms: number): void {
+  responseStallCheckIntervalMs = ms;
+}
+
+export function _resetResponseStallCheckIntervalForTest(): void {
+  responseStallCheckIntervalMs = DEFAULT_RESPONSE_STALL_CHECK_INTERVAL_MS;
+}
+
+export function _setFinalResponseCloseTimeoutForTest(ms: number): void {
+  finalResponseCloseTimeoutMs = ms;
+}
+
+export function _resetFinalResponseCloseTimeoutForTest(): void {
+  finalResponseCloseTimeoutMs = DEFAULT_FINAL_RESPONSE_CLOSE_TIMEOUT_MS;
+}
+
+function clearPromptProcessMonitor(sessionId: string): void {
   const prompt = activePrompts.get(sessionId);
   if (!prompt?.processMonitor) return;
   clearInterval(prompt.processMonitor);
   prompt.processMonitor = undefined;
-}
-
-function clearPromptResponseStallMonitor(sessionId: string): void {
-  const prompt = activePrompts.get(sessionId);
-  if (!prompt?.responseStallMonitor) return;
-  clearInterval(prompt.responseStallMonitor);
-  prompt.responseStallMonitor = undefined;
-}
-
-function clearPromptFinalResponseCloseTimer(sessionId: string): void {
-  const prompt = activePrompts.get(sessionId);
-  if (!prompt?.finalResponseCloseTimer) return;
-  clearTimeout(prompt.finalResponseCloseTimer);
-  prompt.finalResponseCloseTimer = undefined;
-}
-
-/**
- * 权威终态只说明 Agent 已完成本轮，不保证 CLI/SDK 的输出流会及时关闭。
- * 给正常清理保留 10 秒；若流仍悬挂，则关闭底层 session 并杀掉当前 CLI 树，
- * 让 runAgentSession 以 done 收尾。这里绝不触发自动续跑，因为答案已完整到达。
- */
-function scheduleFinalResponseCloseGuard(
-  sessionId: string,
-  runningPrompt: NonNullable<ReturnType<typeof activePrompts.get>>,
-): void {
-  if (runningPrompt.finalResponseCloseTimer) return;
-
-  const timeoutMs = finalResponseCloseTimeoutMs;
-  const handle = setTimeout(() => {
-    const current = activePrompts.get(sessionId);
-    if (
-      !current
-      || current !== runningPrompt
-      || !current.finalResponseObserved
-      || current.stopped
-      || current.abnormalExit
-      || current.resourceStuck
-      || current.autoEnded
-    ) {
-      return;
-    }
-
-    current.finalResponseCloseTimer = undefined;
-    clearPromptProcessMonitor(sessionId);
-    clearPromptResponseStallMonitor(sessionId);
-    try {
-      current.closeSession?.();
-    } catch (err) {
-      console.warn(
-        `[${ts()}] [FINAL-RESPONSE] closeSession failed for ${sessionId}: ${(err as Error).message}`,
-      );
-    }
-    current.controller.abort();
-    void killProcessTree(current.processPid);
-    console.warn(
-      `[${ts()}] [FINAL-RESPONSE] Session ${sessionId} stream stayed open for ${timeoutMs}ms after its authoritative final event; forced clean shutdown`,
-    );
-  }, timeoutMs);
-  handle.unref?.();
-  runningPrompt.finalResponseCloseTimer = handle;
-}
-
-function formatTerminalHeader(status: "running" | "done" | "stopped" | "error" | "auto_ended"): {
-  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: "异常结束", template: "red" };
-  return { title: "完成" };
-}
-
-function turnFinalStatus(status: "running" | "done" | "stopped" | "error" | "auto_ended"): "done" | "stopped" {
-  return status === "stopped" || status === "error" || status === "auto_ended" ? "stopped" : "done";
-}
-
-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,
-): string | null {
-  if (status === "auto_ended") return formatAutoEndedReply(finalReply);
-  return finalReply || null;
-}
+}
+
+function clearPromptResponseStallMonitor(sessionId: string): void {
+  const prompt = activePrompts.get(sessionId);
+  if (!prompt?.responseStallMonitor) return;
+  clearInterval(prompt.responseStallMonitor);
+  prompt.responseStallMonitor = undefined;
+}
+
+function clearPromptFinalResponseCloseTimer(sessionId: string): void {
+  const prompt = activePrompts.get(sessionId);
+  if (!prompt?.finalResponseCloseTimer) return;
+  clearTimeout(prompt.finalResponseCloseTimer);
+  prompt.finalResponseCloseTimer = undefined;
+}
+
+/**
+ * 权威终态只说明 Agent 已完成本轮，不保证 CLI/SDK 的输出流会及时关闭。
+ * 给正常清理保留 10 秒；若流仍悬挂，则关闭底层 session 并杀掉当前 CLI 树，
+ * 让 runAgentSession 以 done 收尾。这里绝不触发自动续跑，因为答案已完整到达。
+ */
+function scheduleFinalResponseCloseGuard(
+  sessionId: string,
+  runningPrompt: NonNullable<ReturnType<typeof activePrompts.get>>,
+): void {
+  if (runningPrompt.finalResponseCloseTimer) return;
+
+  const timeoutMs = finalResponseCloseTimeoutMs;
+  const handle = setTimeout(() => {
+    const current = activePrompts.get(sessionId);
+    if (
+      !current
+      || current !== runningPrompt
+      || !current.finalResponseObserved
+      || current.stopped
+      || current.abnormalExit
+      || current.resourceStuck
+      || current.autoEnded
+    ) {
+      return;
+    }
+
+    current.finalResponseCloseTimer = undefined;
+    clearPromptProcessMonitor(sessionId);
+    clearPromptResponseStallMonitor(sessionId);
+    try {
+      current.closeSession?.();
+    } catch (err) {
+      console.warn(
+        `[${ts()}] [FINAL-RESPONSE] closeSession failed for ${sessionId}: ${(err as Error).message}`,
+      );
+    }
+    current.controller.abort();
+    void killProcessTree(current.processPid);
+    console.warn(
+      `[${ts()}] [FINAL-RESPONSE] Session ${sessionId} stream stayed open for ${timeoutMs}ms after its authoritative final event; forced clean shutdown`,
+    );
+  }, timeoutMs);
+  handle.unref?.();
+  runningPrompt.finalResponseCloseTimer = handle;
+}
+
+function formatTerminalHeader(status: "running" | "done" | "stopped" | "error" | "auto_ended"): {
+  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: "异常结束", template: "red" };
+  return { title: "完成" };
+}
+
+function turnFinalStatus(status: "running" | "done" | "stopped" | "error" | "auto_ended"): "done" | "stopped" {
+  return status === "stopped" || status === "error" || status === "auto_ended" ? "stopped" : "done";
+}
+
+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,
+): string | null {
+  if (status === "auto_ended") return formatAutoEndedReply(finalReply);
+  return finalReply || null;
+}
 
 function isCardKitSequenceConflict(err: unknown): boolean {
   return err instanceof Error && err.message.includes("300317");
@@ -357,7 +358,7 @@ function startPromptProcessMonitor(sessionId: string, info: ToolProcessInfo): vo
       clearPromptProcessMonitor(sessionId);
       return;
     }
-    if (current.stopped || current.abnormalExit || current.resourceStuck || current.autoEnded) return;
+    if (current.stopped || current.abnormalExit || current.resourceStuck || current.autoEnded) return;
     if (isProcessAliveImpl(info.pid)) return;
 
     current.abnormalExit = true;
@@ -467,23 +468,23 @@ export function resetState(): void {
   }
   chatSessionMap.clear();
   sessionInfoMap.clear();
-  clearFeishuMessageLedgerMemory();
+  clearFeishuMessageLedgerMemory();
   lastMsgTimestamps.clear();
   chatPlatformMap.clear();
-  for (const prompt of activePrompts.values()) {
-    if (prompt.processMonitor) clearInterval(prompt.processMonitor);
-    if (prompt.responseStallMonitor) clearInterval(prompt.responseStallMonitor);
-    if (prompt.finalResponseCloseTimer) clearTimeout(prompt.finalResponseCloseTimer);
-  }
-  activePrompts.clear();
-  displayCards.clear();
-  sessionModelOverrides.clear();
-  sessionEffortOverrides.clear();
-  sessionFastModeOverrides.clear();
-  adapterCache.clear();
-  stopUnifiedDisplayLoop();
-  console.log(`[${ts()}] [RESET] State cleared (dedup + active sessions + bindings)`);
-}
+  for (const prompt of activePrompts.values()) {
+    if (prompt.processMonitor) clearInterval(prompt.processMonitor);
+    if (prompt.responseStallMonitor) clearInterval(prompt.responseStallMonitor);
+    if (prompt.finalResponseCloseTimer) clearTimeout(prompt.finalResponseCloseTimer);
+  }
+  activePrompts.clear();
+  displayCards.clear();
+  sessionModelOverrides.clear();
+  sessionEffortOverrides.clear();
+  sessionFastModeOverrides.clear();
+  adapterCache.clear();
+  stopUnifiedDisplayLoop();
+  console.log(`[${ts()}] [RESET] State cleared (dedup + active sessions + bindings)`);
+}
 
 // 注:`rebuildBindingsFromRegistry` 定义在下方与 loadSessionRegistry 同区域,
 // 是 onReady/onReconnected 取代 resetState 的正确入口。
@@ -495,9 +496,9 @@ export function resetState(): void {
 const adapterCache = new Map<string, ToolAdapter>();
 
 // Per-session 模型覆盖（/model 命令设置，不持久化）
-const sessionModelOverrides = new Map<string, string>();
-const sessionEffortOverrides = new Map<string, string>();
-const sessionFastModeOverrides = new Map<string, boolean>();
+const sessionModelOverrides = new Map<string, string>();
+const sessionEffortOverrides = new Map<string, string>();
+const sessionFastModeOverrides = new Map<string, boolean>();
 
 /** 返回 session 的生效模型：优先 per-session 覆盖，其次全局配置（Claude） */
 function getModelForSession(sessionId?: string): string {
@@ -509,47 +510,47 @@ function getModelForSession(sessionId?: string): string {
 }
 
 /** 返回指定 tool 的生效模型：优先 per-session 覆盖，其次 tool 默认配置 */
-export function getEffectiveModelForTool(tool: string, sessionId?: string): string {
-  if (sessionId) {
-    const override = sessionModelOverrides.get(sessionId);
-    if (override) return override;
-  }
-  if (tool === "cursor") return config.cursor.model;
-  if (tool === "codex") return config.codex.model;
-  if (tool === "ccc") return config.ccc.model;
-  return CLAUDE_MODEL;
-}
-
-export function getEffectiveEffortForTool(tool: string, sessionId?: string): string {
-  if (sessionId) {
-    const override = sessionEffortOverrides.get(sessionId);
-    if (override) return override;
-  }
-  if (tool === "claude" || tool === "codex") {
-    return getDefaultEffortForTool(tool);
-  }
-  return "";
-}
-
-export function getEffectiveFastModeForTool(tool: string, sessionId?: string): boolean {
-  if (tool !== "codex") return false;
-  if (sessionId && sessionFastModeOverrides.has(sessionId)) {
-    return sessionFastModeOverrides.get(sessionId) === true;
-  }
-  return config.codex.fastMode;
-}
-
-function setSessionChatAvatar(
-  platform: PlatformAdapter,
-  chatId: string,
-  tool: string,
-  status: string,
-  sessionId: string,
-): Promise<void> {
-  return getEffectiveFastModeForTool(tool, sessionId)
-    ? platform.setChatAvatar(chatId, tool, status, { fastMode: true })
-    : platform.setChatAvatar(chatId, tool, status);
-}
+export function getEffectiveModelForTool(tool: string, sessionId?: string): string {
+  if (sessionId) {
+    const override = sessionModelOverrides.get(sessionId);
+    if (override) return override;
+  }
+  if (tool === "cursor") return config.cursor.model;
+  if (tool === "codex") return config.codex.model;
+  if (tool === "ccc") return config.ccc.model;
+  return CLAUDE_MODEL;
+}
+
+export function getEffectiveEffortForTool(tool: string, sessionId?: string): string {
+  if (sessionId) {
+    const override = sessionEffortOverrides.get(sessionId);
+    if (override) return override;
+  }
+  if (tool === "claude" || tool === "codex" || tool === "ccc") {
+    return getDefaultEffortForTool(tool);
+  }
+  return "";
+}
+
+export function getEffectiveFastModeForTool(tool: string, sessionId?: string): boolean {
+  if (tool !== "codex") return false;
+  if (sessionId && sessionFastModeOverrides.has(sessionId)) {
+    return sessionFastModeOverrides.get(sessionId) === true;
+  }
+  return config.codex.fastMode;
+}
+
+function setSessionChatAvatar(
+  platform: PlatformAdapter,
+  chatId: string,
+  tool: string,
+  status: string,
+  sessionId: string,
+): Promise<void> {
+  return getEffectiveFastModeForTool(tool, sessionId)
+    ? platform.setChatAvatar(chatId, tool, status, { fastMode: true })
+    : platform.setChatAvatar(chatId, tool, status);
+}
 
 /** 为指定 session 设置模型覆盖（/model <name>） */
 export function setSessionModelOverride(sessionId: string, model: string): void {
@@ -558,53 +559,56 @@ export function setSessionModelOverride(sessionId: string, model: string): void
 }
 
 /** 清除指定 session 的模型覆盖（/model clear） */
-export function clearSessionModelOverride(sessionId: string): void {
-  sessionModelOverrides.delete(sessionId);
-  adapterCache.clear();
-}
-
-export function setSessionEffortOverride(sessionId: string, effort: string): void {
-  sessionEffortOverrides.set(sessionId, effort);
-  adapterCache.clear();
-}
-
-export function clearSessionEffortOverride(sessionId: string): void {
-  sessionEffortOverrides.delete(sessionId);
-  adapterCache.clear();
-}
-
-export function setSessionFastModeOverride(sessionId: string, fastMode: boolean): void {
-  sessionFastModeOverrides.set(sessionId, fastMode);
-  adapterCache.clear();
-}
-
-export function getAdapterForTool(tool: string, sessionId?: string): ToolAdapter {
-  const effectiveModel = getEffectiveModelForTool(tool, sessionId);
-  const effectiveEffort = getEffectiveEffortForTool(tool, sessionId);
-  const effectiveFastMode = getEffectiveFastModeForTool(tool, sessionId);
-  const cacheKey = `${tool}:${effectiveModel || ""}:${effectiveEffort || ""}:${effectiveFastMode ? "fast" : "default"}`;
-  const cached = adapterCache.get(cacheKey);
-  if (cached) return cached;
-
-  let adapter: ToolAdapter;
-  if (tool === "cursor") {
-    adapter = createCursorAdapter({ model: effectiveModel || undefined });
-  } else if (tool === "codex") {
-    adapter = createCodexAdapter({
-      model: effectiveModel || undefined,
-      effort: effectiveEffort || undefined,
-      fastMode: effectiveFastMode,
-    });
-  } else if (tool === "ccc") {
-    adapter = createCccAdapter({ model: effectiveModel || undefined });
-  } else {
-    adapter = createClaudeAdapter({
-      model: effectiveModel,
-      subagentModel: CLAUDE_SUBAGENT_MODEL,
-      effort: effectiveEffort,
-      apiKey: CLAUDE_API_KEY,
-      baseUrl: CLAUDE_BASE_URL,
-      isEmpty: isAnthropicConfigEmpty,
+export function clearSessionModelOverride(sessionId: string): void {
+  sessionModelOverrides.delete(sessionId);
+  adapterCache.clear();
+}
+
+export function setSessionEffortOverride(sessionId: string, effort: string): void {
+  sessionEffortOverrides.set(sessionId, effort);
+  adapterCache.clear();
+}
+
+export function clearSessionEffortOverride(sessionId: string): void {
+  sessionEffortOverrides.delete(sessionId);
+  adapterCache.clear();
+}
+
+export function setSessionFastModeOverride(sessionId: string, fastMode: boolean): void {
+  sessionFastModeOverrides.set(sessionId, fastMode);
+  adapterCache.clear();
+}
+
+export function getAdapterForTool(tool: string, sessionId?: string): ToolAdapter {
+  const effectiveModel = getEffectiveModelForTool(tool, sessionId);
+  const effectiveEffort = getEffectiveEffortForTool(tool, sessionId);
+  const effectiveFastMode = getEffectiveFastModeForTool(tool, sessionId);
+  const cacheKey = `${tool}:${effectiveModel || ""}:${effectiveEffort || ""}:${effectiveFastMode ? "fast" : "default"}`;
+  const cached = adapterCache.get(cacheKey);
+  if (cached) return cached;
+
+  let adapter: ToolAdapter;
+  if (tool === "cursor") {
+    adapter = createCursorAdapter({ model: effectiveModel || undefined });
+  } else if (tool === "codex") {
+    adapter = createCodexAdapter({
+      model: effectiveModel || undefined,
+      effort: effectiveEffort || undefined,
+      fastMode: effectiveFastMode,
+    });
+  } else if (tool === "ccc") {
+    adapter = createCccAdapter({
+      model: effectiveModel || undefined,
+      effort: effectiveEffort || undefined,
+    });
+  } else {
+    adapter = createClaudeAdapter({
+      model: effectiveModel,
+      subagentModel: CLAUDE_SUBAGENT_MODEL,
+      effort: effectiveEffort,
+      apiKey: CLAUDE_API_KEY,
+      baseUrl: CLAUDE_BASE_URL,
+      isEmpty: isAnthropicConfigEmpty,
       maxTurn: CLAUDE_MAX_TURN,
     });
   }
@@ -676,13 +680,13 @@ export function _resetSessionToolsFileForTest(): void {
 export const SESSION_REGISTRY_FILE = join(USER_DATA_DIR, "state", "session-registry.json");
 let sessionRegistryFile = SESSION_REGISTRY_FILE;
 
-export interface SessionRegistryUpdate {
-  chatId: string;
-  sessionId: string;
-  tool: string;
-  /** 会话容器类型；旧 registry 没有该字段，读取时必须兼容。 */
-  chatType?: string;
-  chatName?: string;
+export interface SessionRegistryUpdate {
+  chatId: string;
+  sessionId: string;
+  tool: string;
+  /** 会话容器类型；旧 registry 没有该字段，读取时必须兼容。 */
+  chatType?: string;
+  chatName?: string;
   turnCount?: number;
   lastContextTokens?: number;
   startTime?: number;
@@ -690,12 +694,12 @@ export interface SessionRegistryUpdate {
   running?: boolean;
 }
 
-interface SessionRegistryRecord {
-  chatId: string;
-  sessionId: string;
-  tool: string;
-  chatType?: string;
-  chatName: string;
+interface SessionRegistryRecord {
+  chatId: string;
+  sessionId: string;
+  tool: string;
+  chatType?: string;
+  chatName: string;
   turnCount: number;
   lastContextTokens: number;
   startTime: number;
@@ -756,11 +760,11 @@ export async function recordSessionRegistry(update: SessionRegistryUpdate): Prom
   const now = update.updatedAt ?? Date.now();
 
   data[update.chatId] = {
-    chatId: update.chatId,
-    sessionId: update.sessionId,
-    tool: update.tool,
-    chatType: update.chatType ?? existing?.chatType,
-    chatName: update.chatName ?? existing?.chatName ?? "",
+    chatId: update.chatId,
+    sessionId: update.sessionId,
+    tool: update.tool,
+    chatType: update.chatType ?? existing?.chatType,
+    chatName: update.chatName ?? existing?.chatName ?? "",
     turnCount: update.turnCount ?? existing?.turnCount ?? 0,
     lastContextTokens: update.lastContextTokens ?? existing?.lastContextTokens ?? 0,
     startTime: update.startTime ?? existing?.startTime ?? now,
@@ -1009,12 +1013,12 @@ export async function switchChatBinding(args: SwitchChatBindingArgs): Promise<Sw
 
   // Step 3: 持久化（registry + sessions.json）。
   // 这两步即使失败也不影响内存正确性,下次 prompt 会再写一次。
-  await recordSessionRegistry({
-    chatId,
-    sessionId: newSessionId,
-    tool,
-    chatType,
-    chatName,
+  await recordSessionRegistry({
+    chatId,
+    sessionId: newSessionId,
+    tool,
+    chatType,
+    chatName,
     turnCount: initialTurnCount,
     lastContextTokens: initialContextTokens,
     startTime: now,
@@ -1037,58 +1041,58 @@ export async function switchChatBinding(args: SwitchChatBindingArgs): Promise<Sw
 function formatToolConfigForLog(tool: string, sessionModel?: string, sessionId?: string): string {
   if (tool === "cursor") {
     return `model=${sessionModel ?? "(由 cursor-agent 决定，init 事件后学习)"}`;
-  }
-  if (tool === "codex") {
-    const m = getEffectiveModelForTool(tool, sessionId);
-    const e = getEffectiveEffortForTool(tool, sessionId);
-    const modelStr = m.trim() !== "" ? m : "(由 codex config.toml 决定)";
-    const effortStr = e.trim() !== ""
-      ? `effort=${e}`
-      : "effort=(由 codex config.toml 决定)";
-    return `model=${modelStr}, ${effortStr}, fast=${getEffectiveFastModeForTool(tool, sessionId) ? "on" : "off"}`;
-  }
-  if (tool === "ccc") {
-    const m = getEffectiveModelForTool(tool, sessionId);
-    const modelStr = m.trim() !== "" ? m : "(not configured)";
-    return `model=${modelStr}, baseURL=${config.ccc.DEEPSEEK_BASE_URL}`;
-  }
-  return `model=${anthropicConfigDisplay(getModelForSession(sessionId))}, subagentModel=${anthropicConfigDisplay(CLAUDE_SUBAGENT_MODEL)}, effort=${anthropicConfigDisplay(getEffectiveEffortForTool(tool, sessionId))}`;
-}
-
-export async function initClaudeSession(tool: string, overrideCwd?: string, chatId?: string): Promise<{ sessionId: string; cwd: string }> {
-  const cwd = overrideCwd ?? (await getDefaultCwd(chatId));
-  const adapter = getAdapterForTool(tool);
+  }
+  if (tool === "codex") {
+    const m = getEffectiveModelForTool(tool, sessionId);
+    const e = getEffectiveEffortForTool(tool, sessionId);
+    const modelStr = m.trim() !== "" ? m : "(由 codex config.toml 决定)";
+    const effortStr = e.trim() !== ""
+      ? `effort=${e}`
+      : "effort=(由 codex config.toml 决定)";
+    return `model=${modelStr}, ${effortStr}, fast=${getEffectiveFastModeForTool(tool, sessionId) ? "on" : "off"}`;
+  }
+  if (tool === "ccc") {
+    const m = getEffectiveModelForTool(tool, sessionId);
+    const modelStr = m.trim() !== "" ? m : "(not configured)";
+    return `model=${modelStr}, baseURL=${config.ccc.DEEPSEEK_BASE_URL}`;
+  }
+  return `model=${anthropicConfigDisplay(getModelForSession(sessionId))}, subagentModel=${anthropicConfigDisplay(CLAUDE_SUBAGENT_MODEL)}, effort=${anthropicConfigDisplay(getEffectiveEffortForTool(tool, sessionId))}`;
+}
+
+export async function initClaudeSession(tool: string, overrideCwd?: string, chatId?: string): Promise<{ sessionId: string; cwd: string }> {
+  const cwd = overrideCwd ?? (await getDefaultCwd(chatId));
+  const adapter = getAdapterForTool(tool);
   console.log(
-    `[${ts()}] [STEP 1/5] Creating ${adapter.displayName} session (${formatToolConfigForLog(tool)}, cwd=${cwd})`
-  );
-
-  // Claude/Cursor 创建会话时需要先等待 SDK/CLI 的 init 事件。它们若在首个
-  // 事件前卡死，正式 turn 尚未建立，runAgentSession 的看门狗无法介入。
-  // 因此创建入口也使用相同的三分钟阈值，并通过 AbortSignal 释放底层资源。
-  const createController = new AbortController();
-  let createTimeout: ReturnType<typeof setTimeout> | undefined;
-  const timeoutError = new Error(
-    `${adapter.displayName} session creation timed out after 3 minutes without an init event`,
-  );
-  const timeoutPromise = new Promise<never>((_resolve, reject) => {
-    createTimeout = setTimeout(() => {
-      // 先固定对外错误，再 abort 适配器，避免适配器自己的 abort 错误赢得竞态。
-      reject(timeoutError);
-      createController.abort();
-    }, responseStallTimeoutMs);
-    createTimeout.unref?.();
-  });
-
-  let result: Awaited<ReturnType<ToolAdapter["createSession"]>>;
-  try {
-    result = await Promise.race([
-      adapter.createSession(cwd, createController.signal),
-      timeoutPromise,
-    ]);
-  } finally {
-    if (createTimeout) clearTimeout(createTimeout);
-  }
-  const sessionId = result.sessionId;
+    `[${ts()}] [STEP 1/5] Creating ${adapter.displayName} session (${formatToolConfigForLog(tool)}, cwd=${cwd})`
+  );
+
+  // Claude/Cursor 创建会话时需要先等待 SDK/CLI 的 init 事件。它们若在首个
+  // 事件前卡死，正式 turn 尚未建立，runAgentSession 的看门狗无法介入。
+  // 因此创建入口也使用相同的三分钟阈值，并通过 AbortSignal 释放底层资源。
+  const createController = new AbortController();
+  let createTimeout: ReturnType<typeof setTimeout> | undefined;
+  const timeoutError = new Error(
+    `${adapter.displayName} session creation timed out after 3 minutes without an init event`,
+  );
+  const timeoutPromise = new Promise<never>((_resolve, reject) => {
+    createTimeout = setTimeout(() => {
+      // 先固定对外错误，再 abort 适配器，避免适配器自己的 abort 错误赢得竞态。
+      reject(timeoutError);
+      createController.abort();
+    }, responseStallTimeoutMs);
+    createTimeout.unref?.();
+  });
+
+  let result: Awaited<ReturnType<ToolAdapter["createSession"]>>;
+  try {
+    result = await Promise.race([
+      adapter.createSession(cwd, createController.signal),
+      timeoutPromise,
+    ]);
+  } finally {
+    if (createTimeout) clearTimeout(createTimeout);
+  }
+  const sessionId = result.sessionId;
   console.log(`[${ts()}]   → sessionId: ${sessionId}`);
 
   await saveSessionTool(sessionId, tool);
@@ -1110,41 +1114,41 @@ export async function resumeAndPrompt(
   return runAgentSession(sessionId, userText, platform, chatId, msgTimestamp, tool, traceId);
 }
 
-// ---------------------------------------------------------------------------
-// runAgentSession — session 中心的 agent prompt（文件持久化 + display 解耦）
-// ---------------------------------------------------------------------------
-
-interface RunAgentSessionOptions {
-  /**
-   * 标记本轮是 response-stall 后的唯一一次内部续跑。若本轮再次因相同原因
-   * 停滞，不再递归创建第三轮，避免服务异常期间无限消耗 token。
-   */
-  autoRecovery?: boolean;
-}
-
-export async function runAgentSession(
-  sessionId: string,
-  userText: string,
-  platform: PlatformAdapter,
-  _chatId: string,
-  msgTimestamp: number,
-  tool: string,
-  traceId?: string,
-  options: RunAgentSessionOptions = {},
-): Promise<void> {
-  const tid = traceId ?? "";
-
-  // runAgentSession 是飞书用户消息、队列消息与内部自动恢复共同使用的唯一
-  // prompt 执行入口。即使冷启动后的历史群只靠群描述解析出 sessionId、registry
-  // 尚未重建出内存映射，也必须在任何异步操作前补齐绑定，确保三种来源都有完全
-  // 相同的卡片、状态和收尾行为。
-  const previousSessionId = sessionInfoMap.get(_chatId)?.sessionId;
-  if (previousSessionId && previousSessionId !== sessionId) {
-    unbindChatFromSession(previousSessionId, _chatId);
-  }
-  bindChatToSession(sessionId, _chatId);
-
-  // 记录用户最后发送消息的群（display loop 只推送到该群）
+// ---------------------------------------------------------------------------
+// runAgentSession — session 中心的 agent prompt（文件持久化 + display 解耦）
+// ---------------------------------------------------------------------------
+
+interface RunAgentSessionOptions {
+  /**
+   * 标记本轮是 response-stall 后的唯一一次内部续跑。若本轮再次因相同原因
+   * 停滞，不再递归创建第三轮，避免服务异常期间无限消耗 token。
+   */
+  autoRecovery?: boolean;
+}
+
+export async function runAgentSession(
+  sessionId: string,
+  userText: string,
+  platform: PlatformAdapter,
+  _chatId: string,
+  msgTimestamp: number,
+  tool: string,
+  traceId?: string,
+  options: RunAgentSessionOptions = {},
+): Promise<void> {
+  const tid = traceId ?? "";
+
+  // runAgentSession 是飞书用户消息、队列消息与内部自动恢复共同使用的唯一
+  // prompt 执行入口。即使冷启动后的历史群只靠群描述解析出 sessionId、registry
+  // 尚未重建出内存映射，也必须在任何异步操作前补齐绑定，确保三种来源都有完全
+  // 相同的卡片、状态和收尾行为。
+  const previousSessionId = sessionInfoMap.get(_chatId)?.sessionId;
+  if (previousSessionId && previousSessionId !== sessionId) {
+    unbindChatFromSession(previousSessionId, _chatId);
+  }
+  bindChatToSession(sessionId, _chatId);
+
+  // 记录用户最后发送消息的群（display loop 只推送到该群）
   // 如果是从队列消费且队列消息来自其他群，保留原来的 display chat
   recordChatPlatform(_chatId, platform);
   recordLastActiveChat(sessionId, consumeQueuePreservedChat(sessionId) ?? _chatId);
@@ -1165,19 +1169,19 @@ export async function runAgentSession(
   // 注意：下面的 try/catch 在准备失败时会清理 activePrompts。
   const controller = new AbortController();
   const now = Date.now();
-  activePrompts.set(sessionId, {
-    controller,
-    stopped: false,
-    startTime: now,
-    autoRecovery: options.autoRecovery === true,
-    finalResponseObserved: false,
-  });
+  activePrompts.set(sessionId, {
+    controller,
+    stopped: false,
+    startTime: now,
+    autoRecovery: options.autoRecovery === true,
+    finalResponseObserved: false,
+  });
 
   // 资源监控僵死检测：CPU + 内存连续 3 分钟无变化 → 强制停止
   const onResourceStuck = (data: { pid: number; sessionId: string; idleMinutes: number }) => {
     if (data.sessionId !== sessionId) return;
     const prompt = activePrompts.get(sessionId);
-    if (!prompt || prompt.stopped || prompt.abnormalExit || prompt.resourceStuck || prompt.autoEnded) return;
+    if (!prompt || prompt.stopped || prompt.abnormalExit || prompt.resourceStuck || prompt.autoEnded) return;
     prompt.resourceStuck = true;
 
     const chatId = pickDisplayChat(sessionId) ?? getLastActiveChat(sessionId) ?? getChatsForSession(sessionId)[0];
@@ -1214,12 +1218,12 @@ export async function runAgentSession(
     const imSkillsCacheDir = join(USER_DATA_DIR, "im-skills");
     const skillVariables = {
       cwd,
-      session_id: sessionId,
-      im_skills_cache_dir: imSkillsCacheDir,
-      delegate_task_url: `http://127.0.0.1:${CHATCCC_PORT}/api/agent/delegate-task`,
-      send_image_url: `http://127.0.0.1:${CHATCCC_PORT}/api/agent/send-image`,
-      send_file_url: `http://127.0.0.1:${CHATCCC_PORT}/api/agent/send-file`,
-      send_image_script: join(feishuSkillDir, "send-image.mjs"),
+      session_id: sessionId,
+      im_skills_cache_dir: imSkillsCacheDir,
+      delegate_task_url: `http://127.0.0.1:${CHATCCC_PORT}/api/agent/delegate-task`,
+      send_image_url: `http://127.0.0.1:${CHATCCC_PORT}/api/agent/send-image`,
+      send_file_url: `http://127.0.0.1:${CHATCCC_PORT}/api/agent/send-file`,
+      send_image_script: join(feishuSkillDir, "send-image.mjs"),
       send_file_script: join(feishuSkillDir, "send-file.mjs"),
       download_video_script: join(feishuSkillDir, "download-video.mjs"),
       wechat_send_image_script: join(wechatImageSkillDir, "send-image.mjs"),
@@ -1284,10 +1288,10 @@ export async function runAgentSession(
   // 导致 finalReply 丢失、完成卡片空白。此处主动读取上一轮终端状态完成
   // 卡片终结和回复发送，不依赖 display loop 时序，保证"先发完上一个回答
   // 再开始缓存问题对应的任务"。
-  const prevState = await readStreamState(sessionId);
-  if (prevState && prevState.status !== "running") {
-    const prevTerminalReply = formatTerminalReply(prevState.status, prevState.finalReply);
-    const displayChatId = pickDisplayChat(sessionId);
+  const prevState = await readStreamState(sessionId);
+  if (prevState && prevState.status !== "running") {
+    const prevTerminalReply = formatTerminalReply(prevState.status, prevState.finalReply);
+    const displayChatId = pickDisplayChat(sessionId);
     if (displayChatId) {
       const pp = platformForChat(displayChatId);
       const display = displayCards.get(displayChatId);
@@ -1302,12 +1306,12 @@ export async function runAgentSession(
         if (displayCards.get(displayChatId) !== display) {
           const finalStatus = turnFinalStatus(prevState.status);
           finalizeTurnCards(sessionId, prevState.turnCount, finalStatus).catch(() => {});
-          setSessionChatAvatar(pp, displayChatId, prevState.tool, "idle", sessionId).catch(() => {});
+          setSessionChatAvatar(pp, displayChatId, prevState.tool, "idle", sessionId).catch(() => {});
         } else {
           const nextSeq = display.sequence + 1;
           const { title: headerTitle, template: headerTemplate } = formatTerminalHeader(prevState.status);
           const cardContent = truncateContent(prevState.accumulatedContent + prevState.finalReply) || " ";
-          const doneCard = buildProgressCard(cardContent, { showStop: false, headerTitle, headerTemplate });
+          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}`);
           });
@@ -1319,49 +1323,49 @@ export async function runAgentSession(
           const finalStatus = turnFinalStatus(prevState.status);
           finalizeTurnCards(sessionId, prevState.turnCount, finalStatus).catch(() => {});
 
-          if (prevTerminalReply && stillOursAfterUpdate && !isFinalReplySentForTurn(prevState)) {
-            await sendFinalReplyTextOnce(pp, displayChatId, sessionId, prevState.turnCount, prevTerminalReply);
-          }
-          setSessionChatAvatar(pp, displayChatId, prevState.tool, "idle", sessionId).catch(() => {});
+          if (prevTerminalReply && stillOursAfterUpdate && !isFinalReplySentForTurn(prevState)) {
+            await sendFinalReplyTextOnce(pp, displayChatId, sessionId, prevState.turnCount, prevTerminalReply);
+          }
+          setSessionChatAvatar(pp, displayChatId, prevState.tool, "idle", sessionId).catch(() => {});
         }
-      } else if (pp && prevTerminalReply && !isFinalReplySentForTurn(prevState)) {
+      } else if (pp && prevTerminalReply && !isFinalReplySentForTurn(prevState)) {
         // 无 display 记录但上一轮有 finalReply（极快轮次），至少发送
         const finalStatus = turnFinalStatus(prevState.status);
         finalizeTurnCards(sessionId, prevState.turnCount, finalStatus).catch(() => {});
-        await sendFinalReplyTextOnce(pp, displayChatId, sessionId, prevState.turnCount, prevTerminalReply);
+        await sendFinalReplyTextOnce(pp, displayChatId, sessionId, prevState.turnCount, prevTerminalReply);
       }
       // else: displayCards 无记录且无 finalReply → 无需处理
     }
   }
 
   // 初始化 stream-state.json
-  const initialState = createEmptyStreamState(sessionId, cwd, tool, nextTurnCount);
-  const activityTracker = createAgentActivityTracker(initialState.activity?.startedAt ?? Date.now());
-  await writeStreamState(initialState);
+  const initialState = createEmptyStreamState(sessionId, cwd, tool, nextTurnCount);
+  const activityTracker = createAgentActivityTracker(initialState.activity?.startedAt ?? Date.now());
+  await writeStreamState(initialState);
 
   // 为新 turn 创建第一张展示卡片，同时注册到 turn-cards 持久化。
   // 统一 display loop 始终运行，卡片创建后下一个 tick 即自动开始更新。
   const displayChatIdForNew = pickDisplayChat(sessionId);
-  if (displayChatIdForNew) {
-    const ppNew = platformForChat(displayChatIdForNew);
-    if (ppNew && ppNew.kind !== "wechat") {
-      const initialHeaderTitle = formatAgentActivityTitle(activityTracker.activity);
-      const cardId = await createVisibleProgressCard(
+  if (displayChatIdForNew) {
+    const ppNew = platformForChat(displayChatIdForNew);
+    if (ppNew && ppNew.kind !== "wechat") {
+      const initialHeaderTitle = formatAgentActivityTitle(activityTracker.activity);
+      const cardId = await createVisibleProgressCard(
         ppNew,
         displayChatIdForNew,
         sessionId,
-        nextTurnCount,
-        "生成中卡片发送失败，结果将以文本形式发送。",
-        initialHeaderTitle,
+        nextTurnCount,
+        "生成中卡片发送失败，结果将以文本形式发送。",
+        initialHeaderTitle,
       );
       if (cardId) {
         displayCards.set(displayChatIdForNew, {
           cardId,
           sequence: 1,
           cardBusy: false,
-          cardCreatedAt: Date.now(),
-          lastSentContent: "",
-          lastSentHeaderTitle: initialHeaderTitle,
+          cardCreatedAt: Date.now(),
+          lastSentContent: "",
+          lastSentHeaderTitle: initialHeaderTitle,
           streamErrorNotified: false,
           sessionId,
           turnCount: nextTurnCount,
@@ -1387,7 +1391,7 @@ export async function runAgentSession(
   // 设置最后活跃群头像为 busy
   const activeCid = getLastActiveChat(sessionId) ?? getChatsForSession(sessionId)[0];
   if (activeCid) {
-    setSessionChatAvatar(platform, activeCid, tool, "busy", sessionId).catch(() => {});
+    setSessionChatAvatar(platform, activeCid, tool, "busy", sessionId).catch(() => {});
   }
 
   const state: AccumulatorState = {
@@ -1397,106 +1401,106 @@ export async function runAgentSession(
     chunkCount: 0,
   };
 
-  let lastFileWrite = Date.now();
-  const FILE_WRITE_INTERVAL_MS = 2000;
-  const toolCallMap = new Map<string, { name: string; input: unknown }>();
-  let streamErrored = false;
-
-  const runningPrompt = activePrompts.get(sessionId);
-  if (runningPrompt) {
-    // 必须在消费第一个事件前建立零字符基线。部分 CLI 卡死时只启动了进程，
-    // 甚至一个事件都不会 yield；若等循环体更新进度，这种会话会永久停在
-    // “正在启动 Agent”，也永远触发不了三分钟保护。
-    runningPrompt.responseProgress = observeResponseProgress(
-      undefined,
-      true,
-      0,
-      activityTracker.activity.startedAt,
-    );
-
-    const checkResponseStall = async () => {
-      const current = activePrompts.get(sessionId);
-      if (!current || current !== runningPrompt) {
-        clearPromptResponseStallMonitor(sessionId);
-        return;
-      }
-      if (
-        current.stopped
-        || current.abnormalExit
-        || current.resourceStuck
-        || current.autoEnded
-        || current.finalResponseObserved
-        || !monitorsOutputProgress(activityTracker.activity.kind)
-        || !hasResponseStalled(current.responseProgress, Date.now(), responseStallTimeoutMs)
-      ) {
-        return;
-      }
-
-      const autoEndedAt = Date.now();
-      // 普通轮第一次因回复停滞结束时，立即预约同 session 的内部续跑。
-      // 预约先于 abort/收尾建立，isSessionRunning 会在整个交接窗口保持 true，
-      // 因此恰好到达的用户消息只能排队，绝不可能抢在恢复 prompt 前。
-      // 若当前已经是恢复轮，则不再预约第三轮。
-      if (!current.autoRecovery) {
-        reserveAutoRecovery(sessionId);
-      }
-      current.autoEnded = true;
-      current.autoEndedAt = autoEndedAt;
-      clearPromptResponseStallMonitor(sessionId);
-      clearPromptProcessMonitor(sessionId);
-
-      // First publish an atomic terminal state so the card cannot keep claiming the
-      // Agent is running while process cleanup is underway.
-      await writeStreamState({
-        sessionId,
-        status: "auto_ended",
-        accumulatedContent: state.accumulatedContent,
-        finalReply: pickFinalReply(state).trim(),
-        activity: activityTracker.activity,
-        chunkCount: state.chunkCount,
-        turnCount: nextTurnCount,
-        contextTokens: existingInfo?.lastContextTokens ?? 0,
-        updatedAt: autoEndedAt,
-        cwd,
-        tool,
-        autoEndedAt,
-      });
-
-      // 最终事件可能在上面的落盘 I/O 期间到达。只有适配器明确标记的完整
-      // final response 才能赢得这场竞态；普通文本片段绝不能取消超时。
-      if (current.finalResponseObserved) {
-        current.autoEnded = false;
-        current.autoEndedAt = undefined;
-        cancelAutoRecoveryReservation(sessionId);
-        console.log(
-          `[${ts()}] [RESPONSE-STALL] Authoritative final response won timeout race for ${sessionId}`,
-        );
-        return;
-      }
-
-      try {
-        current.closeSession?.();
-      } catch (err) {
-        console.warn(`[${ts()}] [RESPONSE-STALL] closeSession failed for ${sessionId}: ${(err as Error).message}`);
-      }
-      current.controller.abort();
-      await killProcessTree(current.processPid);
-      console.warn(
-        `[${ts()}] [RESPONSE-STALL] Session ${sessionId} auto-ended after 3 minutes without startup or reply progress`,
-      );
-    };
-
-    const responseStallMonitor = setInterval(() => {
-      void checkResponseStall().catch((err) => {
-        console.warn(`[${ts()}] [RESPONSE-STALL] check failed for ${sessionId}: ${(err as Error).message}`);
-      });
-    }, responseStallCheckIntervalMs);
-    responseStallMonitor.unref?.();
-    runningPrompt.responseStallMonitor = responseStallMonitor;
-  }
-
-  try {
-    for await (const unifiedMsg of adapter.prompt(sessionId, userTextWithCapabilities, cwd, controller.signal, {
+  let lastFileWrite = Date.now();
+  const FILE_WRITE_INTERVAL_MS = 2000;
+  const toolCallMap = new Map<string, { name: string; input: unknown }>();
+  let streamErrored = false;
+
+  const runningPrompt = activePrompts.get(sessionId);
+  if (runningPrompt) {
+    // 必须在消费第一个事件前建立零字符基线。部分 CLI 卡死时只启动了进程，
+    // 甚至一个事件都不会 yield；若等循环体更新进度，这种会话会永久停在
+    // “正在启动 Agent”，也永远触发不了三分钟保护。
+    runningPrompt.responseProgress = observeResponseProgress(
+      undefined,
+      true,
+      0,
+      activityTracker.activity.startedAt,
+    );
+
+    const checkResponseStall = async () => {
+      const current = activePrompts.get(sessionId);
+      if (!current || current !== runningPrompt) {
+        clearPromptResponseStallMonitor(sessionId);
+        return;
+      }
+      if (
+        current.stopped
+        || current.abnormalExit
+        || current.resourceStuck
+        || current.autoEnded
+        || current.finalResponseObserved
+        || !monitorsOutputProgress(activityTracker.activity.kind)
+        || !hasResponseStalled(current.responseProgress, Date.now(), responseStallTimeoutMs)
+      ) {
+        return;
+      }
+
+      const autoEndedAt = Date.now();
+      // 普通轮第一次因回复停滞结束时，立即预约同 session 的内部续跑。
+      // 预约先于 abort/收尾建立，isSessionRunning 会在整个交接窗口保持 true，
+      // 因此恰好到达的用户消息只能排队，绝不可能抢在恢复 prompt 前。
+      // 若当前已经是恢复轮，则不再预约第三轮。
+      if (!current.autoRecovery) {
+        reserveAutoRecovery(sessionId);
+      }
+      current.autoEnded = true;
+      current.autoEndedAt = autoEndedAt;
+      clearPromptResponseStallMonitor(sessionId);
+      clearPromptProcessMonitor(sessionId);
+
+      // First publish an atomic terminal state so the card cannot keep claiming the
+      // Agent is running while process cleanup is underway.
+      await writeStreamState({
+        sessionId,
+        status: "auto_ended",
+        accumulatedContent: state.accumulatedContent,
+        finalReply: pickFinalReply(state).trim(),
+        activity: activityTracker.activity,
+        chunkCount: state.chunkCount,
+        turnCount: nextTurnCount,
+        contextTokens: existingInfo?.lastContextTokens ?? 0,
+        updatedAt: autoEndedAt,
+        cwd,
+        tool,
+        autoEndedAt,
+      });
+
+      // 最终事件可能在上面的落盘 I/O 期间到达。只有适配器明确标记的完整
+      // final response 才能赢得这场竞态；普通文本片段绝不能取消超时。
+      if (current.finalResponseObserved) {
+        current.autoEnded = false;
+        current.autoEndedAt = undefined;
+        cancelAutoRecoveryReservation(sessionId);
+        console.log(
+          `[${ts()}] [RESPONSE-STALL] Authoritative final response won timeout race for ${sessionId}`,
+        );
+        return;
+      }
+
+      try {
+        current.closeSession?.();
+      } catch (err) {
+        console.warn(`[${ts()}] [RESPONSE-STALL] closeSession failed for ${sessionId}: ${(err as Error).message}`);
+      }
+      current.controller.abort();
+      await killProcessTree(current.processPid);
+      console.warn(
+        `[${ts()}] [RESPONSE-STALL] Session ${sessionId} auto-ended after 3 minutes without startup or reply progress`,
+      );
+    };
+
+    const responseStallMonitor = setInterval(() => {
+      void checkResponseStall().catch((err) => {
+        console.warn(`[${ts()}] [RESPONSE-STALL] check failed for ${sessionId}: ${(err as Error).message}`);
+      });
+    }, responseStallCheckIntervalMs);
+    responseStallMonitor.unref?.();
+    runningPrompt.responseStallMonitor = responseStallMonitor;
+  }
+
+  try {
+    for await (const unifiedMsg of adapter.prompt(sessionId, userTextWithCapabilities, cwd, controller.signal, {
       onProcessStart: (processInfo) => {
         startPromptProcessMonitor(sessionId, processInfo);
         if (processInfo.pid !== undefined) registerProcess(processInfo.pid, sessionId);
@@ -1505,27 +1509,27 @@ export async function runAgentSession(
         clearPromptProcessMonitor(sessionId);
         if (exitInfo.pid !== undefined) unregisterProcess(exitInfo.pid);
       },
-      onSessionCreated: (closeSession) => {
-        const prompt = activePrompts.get(sessionId);
-        if (prompt) prompt.closeSession = closeSession;
-      },
-    })) {
-      if (unifiedMsg.isFinalResponse) {
-        const prompt = activePrompts.get(sessionId);
-        if (prompt && prompt === runningPrompt) {
-          // 同步标记必须发生在任何 await 之前，让 watchdog 无法在已收到完整
-          // 最终事件后仍把本轮判为停滞。
-          if (!prompt.finalResponseObserved) {
-            prompt.finalResponseObserved = true;
-            scheduleFinalResponseCloseGuard(sessionId, prompt);
-          }
-        }
-      }
-
-      let activityChanged = false;
-      for (const block of unifiedMsg.blocks) {
-        if (updateAgentActivity(activityTracker, block)) activityChanged = true;
-        accumulateBlockContent(block, state, toolCallMap);
+      onSessionCreated: (closeSession) => {
+        const prompt = activePrompts.get(sessionId);
+        if (prompt) prompt.closeSession = closeSession;
+      },
+    })) {
+      if (unifiedMsg.isFinalResponse) {
+        const prompt = activePrompts.get(sessionId);
+        if (prompt && prompt === runningPrompt) {
+          // 同步标记必须发生在任何 await 之前，让 watchdog 无法在已收到完整
+          // 最终事件后仍把本轮判为停滞。
+          if (!prompt.finalResponseObserved) {
+            prompt.finalResponseObserved = true;
+            scheduleFinalResponseCloseGuard(sessionId, prompt);
+          }
+        }
+      }
+
+      let activityChanged = false;
+      for (const block of unifiedMsg.blocks) {
+        if (updateAgentActivity(activityTracker, block)) activityChanged = true;
+        accumulateBlockContent(block, state, toolCallMap);
 
         if (block.type === "compact_boundary" && block.post_tokens) {
           for (const cid of getChatsForSession(sessionId)) {
@@ -1539,32 +1543,32 @@ export async function runAgentSession(
             lastContextTokens: block.post_tokens,
             running: true,
           });
-        }
-      }
-
-      const prompt = activePrompts.get(sessionId);
-      if (prompt && !prompt.autoEnded) {
-        const totalChars = state.accumulatedContent.length + pickFinalReply(state).length;
-        prompt.responseProgress = observeResponseProgress(
-          // starting → responding 本身是一次有效进展，即便首个文本块仍为空也应
-          // 重新计时；其它活动阶段会清空观察窗口。
-          activityChanged ? undefined : prompt.responseProgress,
-          monitorsOutputProgress(activityTracker.activity.kind),
-          totalChars,
-          Date.now(),
-        );
-      }
-
-      // 定时写入文件
+        }
+      }
+
+      const prompt = activePrompts.get(sessionId);
+      if (prompt && !prompt.autoEnded) {
+        const totalChars = state.accumulatedContent.length + pickFinalReply(state).length;
+        prompt.responseProgress = observeResponseProgress(
+          // starting → responding 本身是一次有效进展，即便首个文本块仍为空也应
+          // 重新计时；其它活动阶段会清空观察窗口。
+          activityChanged ? undefined : prompt.responseProgress,
+          monitorsOutputProgress(activityTracker.activity.kind),
+          totalChars,
+          Date.now(),
+        );
+      }
+
+      // 定时写入文件
       const now2 = Date.now();
-      if (activityChanged || now2 - lastFileWrite >= FILE_WRITE_INTERVAL_MS) {
-        lastFileWrite = now2;
-        await writeStreamState({
+      if (activityChanged || now2 - lastFileWrite >= FILE_WRITE_INTERVAL_MS) {
+        lastFileWrite = now2;
+        await writeStreamState({
           sessionId,
           status: "running",
-          accumulatedContent: state.accumulatedContent,
-          finalReply: pickFinalReply(state),
-          activity: activityTracker.activity,
+          accumulatedContent: state.accumulatedContent,
+          finalReply: pickFinalReply(state),
+          activity: activityTracker.activity,
           chunkCount: state.chunkCount,
           turnCount: nextTurnCount,
           contextTokens: existingInfo?.lastContextTokens ?? 0,
@@ -1573,58 +1577,58 @@ export async function runAgentSession(
           tool,
         });
       }
-    }
-  } catch (streamErr) {
-    streamErrored = true;
-    console.error(`[${ts()}] [STREAM] Error in stream loop for ${sessionId}: ${(streamErr as Error).message}`);
-  } finally {
+    }
+  } catch (streamErr) {
+    streamErrored = true;
+    console.error(`[${ts()}] [STREAM] Error in stream loop for ${sessionId}: ${(streamErr as Error).message}`);
+  } finally {
     // 标记 prompt 结束
     resourceMonitor.off("stuck", onResourceStuck);
     const prompt = activePrompts.get(sessionId);
-    const wasStopped = prompt?.stopped ?? false;
-    const wasAbnormalExit = prompt?.abnormalExit ?? false;
-    const wasResourceStuck = prompt?.resourceStuck ?? false;
-    const timeoutTriggered = prompt?.autoEnded ?? false;
-    const completedAtTimeoutBoundary =
-      timeoutTriggered && (prompt?.finalResponseObserved ?? false);
-    const wasAutoEnded = timeoutTriggered && !completedAtTimeoutBoundary;
-    const wasAutoRecovery = prompt?.autoRecovery ?? false;
-    const autoEndedAt = wasAutoEnded ? prompt?.autoEndedAt : undefined;
-    clearPromptResponseStallMonitor(sessionId);
-    clearPromptProcessMonitor(sessionId);
-    clearPromptFinalResponseCloseTimer(sessionId);
-    markSessionFinalizing(sessionId);
-    activePrompts.delete(sessionId);
-
-    try {
-      if (completedAtTimeoutBoundary) {
-        // reservation 可能在 watchdog 开始终止普通轮时已经建立。最终回复若在
-        // abort/kill 清理边界到达，本轮按完成处理，并原子取消尚未启动的恢复轮。
-        cancelAutoRecoveryReservation(sessionId);
-        console.log(
-          `[${ts()}] [RESPONSE-STALL] Session ${sessionId} completed with an authoritative final response during timeout cleanup`,
-        );
-      }
-      // 即使运行期间映射被异常清空，也必须更新本次实际触发 chat，避免 registry
-      // 永久残留 running=true。
-      const finalizationChatIds = [...new Set([
-        ...getChatsForSession(sessionId),
-        _chatId,
-      ])];
-      // 先写最终状态（done/stopped），确保 display loop 在下一轮消费前
-      // 读到新状态并终结旧卡片。否则 setImmediate 在 CHECK 阶段先于
-      // writeFile I/O（POLL 阶段）执行，display loop 会误以为旧轮仍在
-      // 运行中并更新旧卡片，而不是新建卡片。
-      const finalStatus = completedAtTimeoutBoundary
-        ? "done"
-        : wasAutoEnded
-          ? "auto_ended"
-          : (streamErrored || wasAbnormalExit || wasResourceStuck)
-            ? "error"
-            : wasStopped
-              ? "stopped"
-              : "done";
-      const finalReply = pickFinalReply(state).trim();
+    const wasStopped = prompt?.stopped ?? false;
+    const wasAbnormalExit = prompt?.abnormalExit ?? false;
+    const wasResourceStuck = prompt?.resourceStuck ?? false;
+    const timeoutTriggered = prompt?.autoEnded ?? false;
+    const completedAtTimeoutBoundary =
+      timeoutTriggered && (prompt?.finalResponseObserved ?? false);
+    const wasAutoEnded = timeoutTriggered && !completedAtTimeoutBoundary;
+    const wasAutoRecovery = prompt?.autoRecovery ?? false;
+    const autoEndedAt = wasAutoEnded ? prompt?.autoEndedAt : undefined;
+    clearPromptResponseStallMonitor(sessionId);
+    clearPromptProcessMonitor(sessionId);
+    clearPromptFinalResponseCloseTimer(sessionId);
+    markSessionFinalizing(sessionId);
+    activePrompts.delete(sessionId);
+
+    try {
+      if (completedAtTimeoutBoundary) {
+        // reservation 可能在 watchdog 开始终止普通轮时已经建立。最终回复若在
+        // abort/kill 清理边界到达，本轮按完成处理，并原子取消尚未启动的恢复轮。
+        cancelAutoRecoveryReservation(sessionId);
+        console.log(
+          `[${ts()}] [RESPONSE-STALL] Session ${sessionId} completed with an authoritative final response during timeout cleanup`,
+        );
+      }
+      // 即使运行期间映射被异常清空，也必须更新本次实际触发 chat，避免 registry
+      // 永久残留 running=true。
+      const finalizationChatIds = [...new Set([
+        ...getChatsForSession(sessionId),
+        _chatId,
+      ])];
+      // 先写最终状态（done/stopped），确保 display loop 在下一轮消费前
+      // 读到新状态并终结旧卡片。否则 setImmediate 在 CHECK 阶段先于
+      // writeFile I/O（POLL 阶段）执行，display loop 会误以为旧轮仍在
+      // 运行中并更新旧卡片，而不是新建卡片。
+      const finalStatus = completedAtTimeoutBoundary
+        ? "done"
+        : wasAutoEnded
+          ? "auto_ended"
+          : (streamErrored || wasAbnormalExit || wasResourceStuck)
+            ? "error"
+            : wasStopped
+              ? "stopped"
+              : "done";
+      const finalReply = pickFinalReply(state).trim();
 
     // stop-stuck-loop 接口可能在 fire-and-forget 中已写入带 final_reply 的
     // stream state，finally 不应覆盖它。同时保留 stuckAt 标记，防止
@@ -1644,25 +1648,25 @@ export async function runAgentSession(
     await writeStreamState({
       sessionId,
       status: finalStatus,
-      accumulatedContent: state.accumulatedContent,
-      finalReply: finalReplyToWrite,
-      activity: activityTracker.activity,
+      accumulatedContent: state.accumulatedContent,
+      finalReply: finalReplyToWrite,
+      activity: activityTracker.activity,
       chunkCount: state.chunkCount,
       turnCount: nextTurnCount,
       contextTokens: existingInfo?.lastContextTokens ?? 0,
       updatedAt: Date.now(),
       cwd,
-      tool,
-      ...(preserveStuckAt ? { stuckAt: preserveStuckAt } : {}),
-      ...(autoEndedAt !== undefined ? { autoEndedAt } : {}),
-    });
-
-    // display loop 下一轮会读到最终状态并发送消息
-
-    let autoRecoveryTarget: { chatId: string; platform: PlatformAdapter } | undefined;
-
-    if (wasStopped) {
-      for (const cid of finalizationChatIds) {
+      tool,
+      ...(preserveStuckAt ? { stuckAt: preserveStuckAt } : {}),
+      ...(autoEndedAt !== undefined ? { autoEndedAt } : {}),
+    });
+
+    // display loop 下一轮会读到最终状态并发送消息
+
+    let autoRecoveryTarget: { chatId: string; platform: PlatformAdapter } | undefined;
+
+    if (wasStopped) {
+      for (const cid of finalizationChatIds) {
         const finfo = sessionInfoMap.get(cid);
         await recordSessionRegistry({
           chatId: cid,
@@ -1674,62 +1678,15 @@ export async function runAgentSession(
           running: false,
         });
       }
-      const active1 = getLastActiveChat(sessionId) ?? finalizationChatIds[0];
+      const active1 = getLastActiveChat(sessionId) ?? finalizationChatIds[0];
       if (active1) {
         await platform.sendText(active1, "会话已停止。").catch(() => {});
-        setSessionChatAvatar(platform, active1, tool, "idle", sessionId).catch(() => {});
+        setSessionChatAvatar(platform, active1, tool, "idle", sessionId).catch(() => {});
       }
       console.log(`[${ts()}] Session ${sessionId} stopped (content chunks: ${state.chunkCount})`);
       if (tid) logTrace(tid, "SESSION_END", { sessionId, outcome: "stopped", chunks: state.chunkCount });
-    } else if (wasAutoEnded) {
-      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 activeAutoEnded = getLastActiveChat(sessionId) ?? finalizationChatIds[0];
-      if (activeAutoEnded) {
-        const pp = platformForChat(activeAutoEnded) ?? platform;
-        const terminalState = await readStreamState(sessionId);
-        if (!displayCards.has(activeAutoEnded) && (!terminalState || !isFinalReplySentForTurn(terminalState))) {
-          await sendFinalReplyTextOnce(
-            pp,
-            activeAutoEnded,
-            sessionId,
-            nextTurnCount,
-            formatAutoEndedReply(finalReplyToWrite),
-          );
-        }
-        setSessionChatAvatar(pp, activeAutoEnded, tool, "idle", sessionId).catch(() => {});
-
-        if (wasAutoRecovery) {
-          // 这是紧接第一次停滞而启动的恢复轮；再次发生相同停滞即终止
-          // 自动链，避免第三轮及之后的无限续跑。
-          await pp.sendText(
-            activeAutoEnded,
-            RESPONSE_STALL_RECOVERY_EXHAUSTED_NOTICE,
-          ).catch(() => {});
-        } else if (hasAutoRecoveryReservation(sessionId)) {
-          // 用户可见提示与内部恢复 prompt 分离：提示发送失败不影响恢复，
-          // 内部恢复仍由 reservation 保证先于普通缓存消息。
-          await pp.sendText(
-            activeAutoEnded,
-            RESPONSE_STALL_RECOVERY_NOTICE,
-          ).catch(() => {});
-          autoRecoveryTarget = { chatId: activeAutoEnded, platform: pp };
-        }
-      }
-      console.warn(`[${ts()}] Session ${sessionId} auto-ended after stalled startup or response output (content chunks: ${state.chunkCount})`);
-      if (tid) logTrace(tid, "SESSION_END", { sessionId, outcome: "response_stall", chunks: state.chunkCount });
-    } else if (wasAbnormalExit) {
-      for (const cid of finalizationChatIds) {
+    } else if (wasAutoEnded) {
+      for (const cid of finalizationChatIds) {
         const finfo = sessionInfoMap.get(cid);
         await recordSessionRegistry({
           chatId: cid,
@@ -1741,12 +1698,59 @@ export async function runAgentSession(
           running: false,
         });
       }
-      const activeErr = getLastActiveChat(sessionId) ?? finalizationChatIds[0];
-      if (activeErr) setSessionChatAvatar(platform, activeErr, tool, "idle", sessionId).catch(() => {});
+      const activeAutoEnded = getLastActiveChat(sessionId) ?? finalizationChatIds[0];
+      if (activeAutoEnded) {
+        const pp = platformForChat(activeAutoEnded) ?? platform;
+        const terminalState = await readStreamState(sessionId);
+        if (!displayCards.has(activeAutoEnded) && (!terminalState || !isFinalReplySentForTurn(terminalState))) {
+          await sendFinalReplyTextOnce(
+            pp,
+            activeAutoEnded,
+            sessionId,
+            nextTurnCount,
+            formatAutoEndedReply(finalReplyToWrite),
+          );
+        }
+        setSessionChatAvatar(pp, activeAutoEnded, tool, "idle", sessionId).catch(() => {});
+
+        if (wasAutoRecovery) {
+          // 这是紧接第一次停滞而启动的恢复轮；再次发生相同停滞即终止
+          // 自动链，避免第三轮及之后的无限续跑。
+          await pp.sendText(
+            activeAutoEnded,
+            RESPONSE_STALL_RECOVERY_EXHAUSTED_NOTICE,
+          ).catch(() => {});
+        } else if (hasAutoRecoveryReservation(sessionId)) {
+          // 用户可见提示与内部恢复 prompt 分离：提示发送失败不影响恢复，
+          // 内部恢复仍由 reservation 保证先于普通缓存消息。
+          await pp.sendText(
+            activeAutoEnded,
+            RESPONSE_STALL_RECOVERY_NOTICE,
+          ).catch(() => {});
+          autoRecoveryTarget = { chatId: activeAutoEnded, platform: pp };
+        }
+      }
+      console.warn(`[${ts()}] Session ${sessionId} auto-ended after stalled startup or response output (content chunks: ${state.chunkCount})`);
+      if (tid) logTrace(tid, "SESSION_END", { sessionId, outcome: "response_stall", chunks: state.chunkCount });
+    } else if (wasAbnormalExit) {
+      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) 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 {
-      for (const cid of finalizationChatIds) {
+    } else {
+      for (const cid of finalizationChatIds) {
         const finfo = sessionInfoMap.get(cid);
         await recordSessionRegistry({
           chatId: cid,
@@ -1758,107 +1762,107 @@ export async function runAgentSession(
           running: false,
         });
       }
-      const active2 = getLastActiveChat(sessionId) ?? finalizationChatIds[0];
+      const active2 = getLastActiveChat(sessionId) ?? finalizationChatIds[0];
       if (active2) {
         const terminalState = await readStreamState(sessionId);
         if (finalReply && !displayCards.has(active2) && (!terminalState || !isFinalReplySentForTurn(terminalState))) {
           const pp = platformForChat(active2) ?? platform;
           await sendFinalReplyTextOnce(pp, active2, sessionId, nextTurnCount, finalReply);
         }
-        setSessionChatAvatar(platform, active2, tool, "idle", sessionId).catch(() => {});
+        setSessionChatAvatar(platform, active2, tool, "idle", sessionId).catch(() => {});
+      }
+      console.log(`[${ts()}] Session ${sessionId} stream complete (content chunks: ${state.chunkCount})`);
+      if (tid) logTrace(tid, "SESSION_END", { sessionId, chunks: state.chunkCount, finalTextLen: finalReply.length });
+    }
+
+    // 失去聊天绑定时无法安全选择恢复轮的展示目标，取消本次进程内预约。
+    if (
+      wasAutoEnded
+      && hasAutoRecoveryReservation(sessionId)
+      && !autoRecoveryTarget
+    ) {
+      cancelAutoRecoveryReservation(sessionId);
+    }
+    const shouldScheduleAutoRecovery =
+      autoRecoveryTarget !== undefined
+      && hasAutoRecoveryReservation(sessionId);
+
+    // 必须等本轮最终卡片、registry 和头像全部收尾后再取出并调度队列消息。
+    // 在收尾期间新到达的消息也会因 finalizingSessions 被正确排入这里。
+    let queuedForConsumption: ReturnType<typeof dequeueMessage> = undefined;
+    if (wasStopped) {
+      const discarded = dequeueMessage(sessionId);
+      if (discarded) {
+        console.log(`[${ts()}] [QUEUE] Discarding queued message for stopped session ${sessionId}`);
+      }
+    } else if (!shouldScheduleAutoRecovery) {
+      // 第一次 response-stall 后保留普通缓存；恢复轮结束后由恢复轮的
+      // finally 再消费，顺序固定为“自动恢复 → 用户缓存”。
+      queuedForConsumption = dequeueMessage(sessionId);
+    }
+
+    if (queuedForConsumption) {
+      const queued = queuedForConsumption;
+      // 队列消息可能来自其他群，保存当前 display chat 避免 display loop 被
+      // 错误重定向（runAgentSession 会 consumeQueuePreservedChat 并在存在时
+      // 用保存的 chat 替代 queued.chatId 作为 display 目标）。
+      const preservedChat = getLastActiveChat(sessionId);
+      if (preservedChat && preservedChat !== queued.chatId) {
+        setQueuePreservedChat(sessionId, preservedChat);
       }
-      console.log(`[${ts()}] Session ${sessionId} stream complete (content chunks: ${state.chunkCount})`);
-      if (tid) logTrace(tid, "SESSION_END", { sessionId, chunks: state.chunkCount, finalTextLen: finalReply.length });
-    }
-
-    // 失去聊天绑定时无法安全选择恢复轮的展示目标，取消本次进程内预约。
-    if (
-      wasAutoEnded
-      && hasAutoRecoveryReservation(sessionId)
-      && !autoRecoveryTarget
-    ) {
-      cancelAutoRecoveryReservation(sessionId);
-    }
-    const shouldScheduleAutoRecovery =
-      autoRecoveryTarget !== undefined
-      && hasAutoRecoveryReservation(sessionId);
-
-    // 必须等本轮最终卡片、registry 和头像全部收尾后再取出并调度队列消息。
-    // 在收尾期间新到达的消息也会因 finalizingSessions 被正确排入这里。
-    let queuedForConsumption: ReturnType<typeof dequeueMessage> = undefined;
-    if (wasStopped) {
-      const discarded = dequeueMessage(sessionId);
-      if (discarded) {
-        console.log(`[${ts()}] [QUEUE] Discarding queued message for stopped session ${sessionId}`);
-      }
-    } else if (!shouldScheduleAutoRecovery) {
-      // 第一次 response-stall 后保留普通缓存；恢复轮结束后由恢复轮的
-      // finally 再消费，顺序固定为“自动恢复 → 用户缓存”。
-      queuedForConsumption = dequeueMessage(sessionId);
-    }
-
-    if (queuedForConsumption) {
-      const queued = queuedForConsumption;
-      // 队列消息可能来自其他群，保存当前 display chat 避免 display loop 被
-      // 错误重定向（runAgentSession 会 consumeQueuePreservedChat 并在存在时
-      // 用保存的 chat 替代 queued.chatId 作为 display 目标）。
-      const preservedChat = getLastActiveChat(sessionId);
-      if (preservedChat && preservedChat !== queued.chatId) {
-        setQueuePreservedChat(sessionId, preservedChat);
-      }
-      console.log(`[${ts()}] [QUEUE] Consuming queued message for session ${sessionId}: "${queued.text.slice(0, 50)}"`);
-      // setTimeout 而非 setImmediate：给 display loop 的 setInterval
-      // 足够时间读到最终状态并终结旧卡片，避免新轮更新旧卡片。
-      setTimeout(() => {
-        consumeQueuedMessage(platform, queued);
-      }, RESPONSE_STALL_RECOVERY_DELAY_MS);
-    }
-
-    if (shouldScheduleAutoRecovery && autoRecoveryTarget) {
-      const target = autoRecoveryTarget;
-      console.log(
-        `[${ts()}] [RESPONSE-STALL] Reserved automatic recovery for session ${sessionId}`,
-      );
-      // 延迟与普通队列原有策略一致，让上一轮终态先完成展示。reservation
-      // 在定时器等待期间仍令 isSessionRunning=true；调用 runAgentSession
-      // 时会在首次 await 前同步写入 activePrompts，然后才消费 reservation，
-      // 因而不存在普通用户消息可插入的事件循环空窗。
-      setTimeout(() => {
-        if (!hasAutoRecoveryReservation(sessionId)) return;
-        const recoveryRun = runAgentSession(
-          sessionId,
-          RESPONSE_STALL_RECOVERY_PROMPT,
-          target.platform,
-          target.chatId,
-          Date.now(),
-          tool,
-          undefined,
-          { autoRecovery: true },
-        );
-        consumeAutoRecoveryReservation(sessionId);
-        void recoveryRun.catch((err) => {
-          console.error(
-            `[${ts()}] [RESPONSE-STALL] Automatic recovery failed for ${sessionId}: ${(err as Error).message}`,
-          );
-          target.platform.sendText(
-            target.chatId,
-            `⚠️ 自动续跑启动失败：${(err as Error).message}`,
-          ).catch(() => {});
-
-          // 若恢复轮在进入主 stream try/finally 前即准备失败，它不会自然
-          // 消费此前保留的用户缓存；在错误回调中补做一次，避免队列悬挂。
-          const queued = dequeueMessage(sessionId);
-          if (queued) {
-            consumeQueuedMessage(target.platform, queued);
-          }
-        });
-      }, RESPONSE_STALL_RECOVERY_DELAY_MS);
-    }
-    } finally {
-      clearSessionFinalizing(sessionId);
-    }
-  }
-}
+      console.log(`[${ts()}] [QUEUE] Consuming queued message for session ${sessionId}: "${queued.text.slice(0, 50)}"`);
+      // setTimeout 而非 setImmediate：给 display loop 的 setInterval
+      // 足够时间读到最终状态并终结旧卡片，避免新轮更新旧卡片。
+      setTimeout(() => {
+        consumeQueuedMessage(platform, queued);
+      }, RESPONSE_STALL_RECOVERY_DELAY_MS);
+    }
+
+    if (shouldScheduleAutoRecovery && autoRecoveryTarget) {
+      const target = autoRecoveryTarget;
+      console.log(
+        `[${ts()}] [RESPONSE-STALL] Reserved automatic recovery for session ${sessionId}`,
+      );
+      // 延迟与普通队列原有策略一致，让上一轮终态先完成展示。reservation
+      // 在定时器等待期间仍令 isSessionRunning=true；调用 runAgentSession
+      // 时会在首次 await 前同步写入 activePrompts，然后才消费 reservation，
+      // 因而不存在普通用户消息可插入的事件循环空窗。
+      setTimeout(() => {
+        if (!hasAutoRecoveryReservation(sessionId)) return;
+        const recoveryRun = runAgentSession(
+          sessionId,
+          RESPONSE_STALL_RECOVERY_PROMPT,
+          target.platform,
+          target.chatId,
+          Date.now(),
+          tool,
+          undefined,
+          { autoRecovery: true },
+        );
+        consumeAutoRecoveryReservation(sessionId);
+        void recoveryRun.catch((err) => {
+          console.error(
+            `[${ts()}] [RESPONSE-STALL] Automatic recovery failed for ${sessionId}: ${(err as Error).message}`,
+          );
+          target.platform.sendText(
+            target.chatId,
+            `⚠️ 自动续跑启动失败：${(err as Error).message}`,
+          ).catch(() => {});
+
+          // 若恢复轮在进入主 stream try/finally 前即准备失败，它不会自然
+          // 消费此前保留的用户缓存；在错误回调中补做一次，避免队列悬挂。
+          const queued = dequeueMessage(sessionId);
+          if (queued) {
+            consumeQueuedMessage(target.platform, queued);
+          }
+        });
+      }, RESPONSE_STALL_RECOVERY_DELAY_MS);
+    }
+    } finally {
+      clearSessionFinalizing(sessionId);
+    }
+  }
+}
 
 // ---------------------------------------------------------------------------
 // startUnifiedDisplayLoop — 全局统一 display 循环，遍历 displayCards 更新卡片
@@ -1932,14 +1936,14 @@ export function startUnifiedDisplayLoop(): void {
               // 还没执行，当前 stream state 可能是 stopSession fire-and-forget
               // 写入的，finalReply 滞后于内存态。跳过发送，等 finally 落盘后
               // 下一次 tick 再处理，避免发送过期内容或与后续发送重复。
-              if (activePrompts.has(sessionId)) continue;
-
-              const tail = "━━━ 回答结束 ━━━";
-              const finalMsg = state.status === "auto_ended"
-                ? formatAutoEndedReply(remaining)
-                : remaining
-                  ? remaining + "\n" + tail
-                  : tail;
+              if (activePrompts.has(sessionId)) continue;
+
+              const tail = "━━━ 回答结束 ━━━";
+              const finalMsg = state.status === "auto_ended"
+                ? formatAutoEndedReply(remaining)
+                : remaining
+                  ? remaining + "\n" + tail
+                  : tail;
               if (!isFinalReplySentForTurn(state)) {
                 await sendFinalReplyTextOnce(p, chatId, sessionId, state.turnCount, finalMsg);
               }
@@ -1963,7 +1967,7 @@ export function startUnifiedDisplayLoop(): void {
                 const nextSeq = display.sequence + 1;
                 const { title: headerTitle, template: headerTemplate } = formatTerminalHeader(state.status);
                 const cardContent = truncateContent(state.accumulatedContent + state.finalReply) || " ";
-                const doneCard = buildProgressCard(cardContent, { showStop: false, headerTitle, headerTemplate });
+                const doneCard = buildProgressCard(progressView({ text: cardContent, status: "done", showStop: false, headerTitle, headerTemplate }));
                 await p.cardUpdate(display.cardId, doneCard, nextSeq).then(() => {
                   display.sequence = nextSeq;
                   terminalCardUpdateAccepted = true;
@@ -1988,12 +1992,12 @@ export function startUnifiedDisplayLoop(): void {
                 continue;
               }
 
-              let terminalTextDelivered = true;
-              const terminalReply = formatTerminalReply(state.status, state.finalReply);
-              if (terminalReply) {
-                if (!isFinalReplySentForTurn(state)) {
-                  terminalTextDelivered = await sendFinalReplyTextOnce(p, chatId, sessionId, state.turnCount, terminalReply);
-                }
+              let terminalTextDelivered = true;
+              const terminalReply = formatTerminalReply(state.status, state.finalReply);
+              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);
@@ -2008,7 +2012,7 @@ export function startUnifiedDisplayLoop(): void {
               finalizeTurnCards(sessionId, state.turnCount, finalSt).catch(() => {});
               displayCards.delete(chatId);
             }
-            setSessionChatAvatar(p, chatId, state.tool, "idle", sessionId).catch(() => {});
+            setSessionChatAvatar(p, chatId, state.tool, "idle", sessionId).catch(() => {});
             console.log(`[${ts()}] [DISPLAY] unified loop deleted display for ${chatId} (terminal: ${state.status})`);
           } else {
             // running: 创建或更新展示
@@ -2045,16 +2049,16 @@ export function startUnifiedDisplayLoop(): void {
               }
             } else {
               // 非 WeChat: 卡片流程
-              if (display.turnCount !== state.turnCount) {
+              if (display.turnCount !== state.turnCount) {
                 console.log(`[${ts()}] [DISPLAY] turn mismatch for ${chatId}: display.turnCount=${display.turnCount} state.turnCount=${state.turnCount}, resetting`);
                 finalizeTurnCards(sessionId, display.turnCount, "done").catch(() => {});
                 displayCards.delete(chatId);
-                continue;
-              }
-
-              const activityHeaderTitle = formatAgentActivityTitle(state.activity, Date.now());
-
-              // 卡片轮转
+                continue;
+              }
+
+              const activityHeaderTitle = formatAgentActivityTitle(state.activity, Date.now());
+
+              // 卡片轮转
               if (Date.now() - display.cardCreatedAt > CARD_ROTATE_MS) {
                 display.cardBusy = true;
                 try {
@@ -2062,9 +2066,9 @@ export function startUnifiedDisplayLoop(): void {
                     p,
                     chatId,
                     sessionId,
-                    display.turnCount,
-                    display.streamErrorNotified ? undefined : "生成中卡片发送失败，结果将继续更新在上一张卡片中。",
-                    activityHeaderTitle,
+                    display.turnCount,
+                    display.streamErrorNotified ? undefined : "生成中卡片发送失败，结果将继续更新在上一张卡片中。",
+                    activityHeaderTitle,
                   );
                   if (!newCardId) {
                     display.streamErrorNotified = true;
@@ -2072,7 +2076,7 @@ export function startUnifiedDisplayLoop(): void {
                   }
                   const oldSeqBase = display.sequence;
                   const oldContent = state.accumulatedContent + state.finalReply;
-                  const oldCard = buildProgressCard(truncateContent(oldContent) || " ", { showStop: false, headerTitle: "上一阶段记录" });
+                  const oldCard = buildProgressCard(progressView({ text: truncateContent(oldContent) || " ", status: "done", showStop: false, headerTitle: "上一阶段记录" }));
                   await p.cardUpdate(display.cardId, oldCard, oldSeqBase + 1).then(() => {
                     display.sequence = oldSeqBase + 1;
                   }).catch(err => {
@@ -2083,10 +2087,10 @@ export function startUnifiedDisplayLoop(): void {
                   display.sequence = 1;
                   display.cardCreatedAt = Date.now();
                   display.rotationAccLen = state.accumulatedContent.length;
-                  display.rotationFinalReply = state.finalReply;
-                  display.lastSentContent = "";
-                  display.lastSentHeaderTitle = activityHeaderTitle;
-                  display.streamErrorNotified = false;
+                  display.rotationFinalReply = state.finalReply;
+                  display.lastSentContent = "";
+                  display.lastSentHeaderTitle = activityHeaderTitle;
+                  display.streamErrorNotified = false;
                 } catch (err) {
                   console.error(`[${ts()}] [CARDIKT] rotation FAIL for ${chatId}: ${(err as Error).message}`);
                 } finally {
@@ -2104,24 +2108,21 @@ export function startUnifiedDisplayLoop(): void {
                   replyDelta = state.finalReply.slice(rotReply.length);
                 } else {
                   replyDelta = state.finalReply;
-                }
-                const delta = (accDelta + replyDelta).trim();
-
-                display.dotCount = (display.dotCount % 9) + 1;
-                let deltaBase = delta;
-                if (isCodeBlockOpen(deltaBase)) deltaBase += "\n```";
-                const displayContent = deltaBase + "\n" + "。".repeat(display.dotCount);
-                if (
-                  displayContent === display.lastSentContent
-                  && activityHeaderTitle === display.lastSentHeaderTitle
-                ) continue;
-
-                display.lastSentContent = displayContent;
-                display.lastSentHeaderTitle = activityHeaderTitle;
-                const deltaCard = buildProgressCard(truncateContent(displayContent) || "等待 Agent 输出...", {
-                  showStop: true,
-                  headerTitle: activityHeaderTitle,
-                });
+                }
+                const delta = (accDelta + replyDelta).trim();
+
+                display.dotCount = (display.dotCount % 9) + 1;
+                let deltaBase = delta;
+                if (isCodeBlockOpen(deltaBase)) deltaBase += "\n```";
+                const displayContent = deltaBase + "\n" + "。".repeat(display.dotCount);
+                if (
+                  displayContent === display.lastSentContent
+                  && activityHeaderTitle === display.lastSentHeaderTitle
+                ) continue;
+
+                display.lastSentContent = displayContent;
+                display.lastSentHeaderTitle = activityHeaderTitle;
+                const deltaCard = buildProgressCard(progressView({ text: truncateContent(displayContent) || "等待 Agent 输出...", showStop: true, headerTitle: activityHeaderTitle }));
                 display.cardBusy = true;
                 const mySeq = display.sequence + 1;
                 try {
@@ -2140,24 +2141,24 @@ export function startUnifiedDisplayLoop(): void {
                   display.cardBusy = false;
                 }
                 continue;
-              }
-
-              display.dotCount = (display.dotCount % 9) + 1;
-              let contentBase = state.accumulatedContent + state.finalReply;
-              if (isCodeBlockOpen(contentBase)) contentBase += "\n```";
-              const fullContent = contentBase + "\n" + "。".repeat(display.dotCount);
-              if (
-                fullContent === display.lastSentContent
-                && activityHeaderTitle === display.lastSentHeaderTitle
-              ) continue;
-
-              display.lastSentContent = fullContent;
-              display.lastSentHeaderTitle = activityHeaderTitle;
-              const cardContent = truncateContent(fullContent) || "等待 Agent 输出...";
+              }
+
+              display.dotCount = (display.dotCount % 9) + 1;
+              let contentBase = state.accumulatedContent + state.finalReply;
+              if (isCodeBlockOpen(contentBase)) contentBase += "\n```";
+              const fullContent = contentBase + "\n" + "。".repeat(display.dotCount);
+              if (
+                fullContent === display.lastSentContent
+                && activityHeaderTitle === display.lastSentHeaderTitle
+              ) continue;
+
+              display.lastSentContent = fullContent;
+              display.lastSentHeaderTitle = activityHeaderTitle;
+              const cardContent = truncateContent(fullContent) || "等待 Agent 输出...";
               display.cardBusy = true;
               const mySeq = display.sequence + 1;
               try {
-                const card = buildProgressCard(cardContent, { showStop: true, headerTitle: activityHeaderTitle });
+                const card = buildProgressCard(progressView({ text: cardContent, showStop: true, headerTitle: activityHeaderTitle }));
                 await p.cardUpdate(display.cardId, card, mySeq);
                 display.sequence = mySeq;
               } catch (err) {
@@ -2214,37 +2215,37 @@ export function stopUnifiedDisplayLoop(): void {
 //    虽然很快但仍是异步，期间 display loop 可能多读到 1–2 帧 "running"，
 //    用户体验上"按下停止后还要等几秒卡片才变成已停止"。先把状态标好，
 //    finally 后续再写一次也不冲突——status 最终值仍然是 stopped。
-export function stopSession(sessionId: string): boolean {
-  // /stop 拥有高于内部自动恢复的优先级。旧轮已经完成、恢复轮尚在 200ms
-  // 预约窗口时 activePrompts 为空，因此必须单独取消 reservation。
-  const cancelledRecovery = cancelAutoRecoveryReservation(sessionId);
-  const prompt = activePrompts.get(sessionId);
-  if (!prompt) {
-    if (cancelledRecovery) {
-      cancelQueuedMessage(sessionId);
-      console.log(`[${ts()}] [STOP] Reserved automatic recovery for ${sessionId} cancelled`);
-      return true;
-    }
-    return false;
-  }
-  prompt.stopped = true;
-  clearPromptResponseStallMonitor(sessionId);
-  clearPromptProcessMonitor(sessionId);
-  clearPromptFinalResponseCloseTimer(sessionId);
-  cancelQueuedMessage(sessionId);
-
-  // 先发起整棵进程树清理，再触发 close/abort。Windows 上 CLI 由
-  // cmd.exe → node → 实际二进制组成；若先 process.kill(cmd.exe)，taskkill
-  // 随后便无法从已消失的根 PID 找到后代，正是幽灵 Codex/Cursor 的来源。
-  // killProcessTree 在返回 Promise 前已启动 taskkill，因此这里无需阻塞。
-  void killProcessTree(prompt.processPid);
-  try {
-    prompt.closeSession?.();
-  } catch (err) {
+export function stopSession(sessionId: string): boolean {
+  // /stop 拥有高于内部自动恢复的优先级。旧轮已经完成、恢复轮尚在 200ms
+  // 预约窗口时 activePrompts 为空，因此必须单独取消 reservation。
+  const cancelledRecovery = cancelAutoRecoveryReservation(sessionId);
+  const prompt = activePrompts.get(sessionId);
+  if (!prompt) {
+    if (cancelledRecovery) {
+      cancelQueuedMessage(sessionId);
+      console.log(`[${ts()}] [STOP] Reserved automatic recovery for ${sessionId} cancelled`);
+      return true;
+    }
+    return false;
+  }
+  prompt.stopped = true;
+  clearPromptResponseStallMonitor(sessionId);
+  clearPromptProcessMonitor(sessionId);
+  clearPromptFinalResponseCloseTimer(sessionId);
+  cancelQueuedMessage(sessionId);
+
+  // 先发起整棵进程树清理，再触发 close/abort。Windows 上 CLI 由
+  // cmd.exe → node → 实际二进制组成；若先 process.kill(cmd.exe)，taskkill
+  // 随后便无法从已消失的根 PID 找到后代，正是幽灵 Codex/Cursor 的来源。
+  // killProcessTree 在返回 Promise 前已启动 taskkill，因此这里无需阻塞。
+  void killProcessTree(prompt.processPid);
+  try {
+    prompt.closeSession?.();
+  } catch (err) {
     console.warn(`[${ts()}] [STOP] closeSession failed for ${sessionId}: ${(err as Error).message}`);
-  }
-  prompt.controller.abort();
-  console.log(`[${ts()}] [STOP] Session ${sessionId} aborted`);
+  }
+  prompt.controller.abort();
+  console.log(`[${ts()}] [STOP] Session ${sessionId} aborted`);
 
   // fire-and-forget：立刻把 stream-state.status 改成 stopped，
   // 让 display loop 下一次扫到立刻渲染"已停止"卡片，不必再等几秒。
@@ -2314,27 +2315,27 @@ async function resolveModelEffort(
       // adapter 异常时降级为占位符（不阻塞 /state 卡片）
     }
     return { model, effort: null };
-  }
-  if (tool === "codex") {
-    const m = getEffectiveModelForTool(tool, sessionId);
-    const e = getEffectiveEffortForTool(tool, sessionId);
-    return {
-      model: m.trim() !== "" ? m : UNKNOWN_MODEL_PLACEHOLDER,
-      effort: e.trim() !== "" ? e : UNKNOWN_MODEL_PLACEHOLDER,
-    };
-  }
-  if (tool === "ccc") {
-    const m = getEffectiveModelForTool(tool, sessionId);
-    return {
-      model: m.trim() !== "" ? m : UNKNOWN_MODEL_PLACEHOLDER,
-      effort: null,
-    };
-  }
-  return {
-    model: anthropicConfigDisplay(getModelForSession(sessionId)),
-    effort: anthropicConfigDisplay(getEffectiveEffortForTool(tool, sessionId)),
-  };
-}
+  }
+  if (tool === "codex") {
+    const m = getEffectiveModelForTool(tool, sessionId);
+    const e = getEffectiveEffortForTool(tool, sessionId);
+    return {
+      model: m.trim() !== "" ? m : UNKNOWN_MODEL_PLACEHOLDER,
+      effort: e.trim() !== "" ? e : UNKNOWN_MODEL_PLACEHOLDER,
+    };
+  }
+  if (tool === "ccc") {
+    const m = getEffectiveModelForTool(tool, sessionId);
+    return {
+      model: m.trim() !== "" ? m : UNKNOWN_MODEL_PLACEHOLDER,
+      effort: null,
+    };
+  }
+  return {
+    model: anthropicConfigDisplay(getModelForSession(sessionId)),
+    effort: anthropicConfigDisplay(getEffectiveEffortForTool(tool, sessionId)),
+  };
+}
 
 export async function getSessionStatus(chatId: string): Promise<SessionStatus | null> {
   const info = sessionInfoMap.get(chatId);
@@ -2367,10 +2368,10 @@ export async function getSessionStatus(chatId: string): Promise<SessionStatus |
   };
 }
 
-export interface SessionsListEntry {
-  chatId: string;
-  chatType?: string;
-  sessionId: string;
+export interface SessionsListEntry {
+  chatId: string;
+  chatType?: string;
+  sessionId: string;
   chatName: string;
   active: boolean;
   turnCount: number;
@@ -2393,10 +2394,10 @@ export async function getAllSessionsStatus(): Promise<SessionsListEntry[]> {
     .map(([sessionId, record]) => {
       const createdAt = Number.isFinite(record.createdAt) ? record.createdAt : 0;
       const active = activePrompts.get(sessionId);
-      return {
-        chatId: "",
-        chatType: undefined,
-        sessionId,
+      return {
+        chatId: "",
+        chatType: undefined,
+        sessionId,
         tool: record.tool,
         chatName: record.chatName ?? "",
         turnCount: 0,
@@ -2414,10 +2415,10 @@ export async function getAllSessionsStatus(): Promise<SessionsListEntry[]> {
   return Promise.all(
     entries.map(async (info) => {
       const { model, effort } = await resolveModelEffort(info.tool, info.sessionId);
-      return {
-        chatId: info.chatId,
-        chatType: info.chatType,
-        sessionId: info.sessionId,
+      return {
+        chatId: info.chatId,
+        chatType: info.chatType,
+        sessionId: info.sessionId,
         chatName: info.chatName || "",
         active: !!activePrompts.get(info.sessionId) &&
           !activePrompts.get(info.sessionId)?.stopped &&
@@ -2442,11 +2443,11 @@ export async function getAllSessionsStatus(): Promise<SessionsListEntry[]> {
 export function _setAdapterForToolForTest(tool: string, adapter: ToolAdapter): void {
   adapterCache.set(tool, adapter);
   // 同时设置当前配置模型对应的 key（getAdapterForTool 会优先 lookup 含 model 的 key）
-  const effective = getEffectiveModelForTool(tool);
-  const effort = getEffectiveEffortForTool(tool);
-  const fastMode = getEffectiveFastModeForTool(tool);
-  adapterCache.set(`${tool}:${effective || ""}:${effort || ""}:${fastMode ? "fast" : "default"}`, adapter);
-  if (effective) adapterCache.set(`${tool}:${effective}`, adapter);
+  const effective = getEffectiveModelForTool(tool);
+  const effort = getEffectiveEffortForTool(tool);
+  const fastMode = getEffectiveFastModeForTool(tool);
+  adapterCache.set(`${tool}:${effective || ""}:${effort || ""}:${fastMode ? "fast" : "default"}`, adapter);
+  if (effective) adapterCache.set(`${tool}:${effective}`, adapter);
 }
 
 export function clearAdapterCache(): void {