chatccc 0.2.243 → 0.2.245

package/src/session.ts

@@ -41,14 +41,14 @@ import { createCccAdapter } from "./adapters/ccc-adapter.ts";
 import { killProcessTree } from "./adapters/proc-tree-kill.ts";
 import { resourceMonitor, registerProcess, unregisterProcess } from "./adapters/resource-monitor.ts";
 import { buildImSkillsPromptCached, exportSkillSubDocs, clearImSkillsPromptCache } from "./im-skills.ts";
-import type { PlatformAdapter } from "./platform-adapter.ts";
-import { hasResponseStalled, observeResponseProgress } from "./response-stall.ts";
-import {
-  classifyTerminalError,
-  formatTerminalErrorNotice,
-  formatTerminalErrorReason,
-  type TerminalErrorInfo,
-} from "./terminal-error.ts";
+import type { PlatformAdapter } from "./platform-adapter.ts";
+import { hasResponseStalled, observeResponseProgress } from "./response-stall.ts";
+import {
+  classifyTerminalError,
+  formatTerminalErrorNotice,
+  formatTerminalErrorReason,
+  type TerminalErrorInfo,
+} from "./terminal-error.ts";
 import {
   MAX_PROCESSED,
   clearFeishuMessageLedgerMemory,
@@ -174,20 +174,20 @@ function platformForChat(chatId: string): PlatformAdapter | null {
   return chatPlatformMap.get(chatId) ?? platformRef;
 }
 
-const DEFAULT_PROCESS_MONITOR_INTERVAL_MS = 5000;
-const DEFAULT_AVATAR_REFRESH_INTERVAL_MS = 5 * 60 * 1000;
-const DEFAULT_RESPONSE_STALL_TIMEOUT_MS = 3 * 60 * 1000;
+const DEFAULT_PROCESS_MONITOR_INTERVAL_MS = 5000;
+const DEFAULT_AVATAR_REFRESH_INTERVAL_MS = 5 * 60 * 1000;
+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 分钟没有生成新回复，本次不再自动继续。";
+export const RESPONSE_STALL_RECOVERY_EXHAUSTED_NOTICE =
+  "⚠️ 自动续跑仍连续 3 分钟没有生成新回复，本次不再自动继续。";
 const RESPONSE_STALL_RECOVERY_DELAY_MS = 200;
-let processMonitorIntervalMs = DEFAULT_PROCESS_MONITOR_INTERVAL_MS;
-let avatarRefreshIntervalMs = DEFAULT_AVATAR_REFRESH_INTERVAL_MS;
-let responseStallTimeoutMs = DEFAULT_RESPONSE_STALL_TIMEOUT_MS;
+let processMonitorIntervalMs = DEFAULT_PROCESS_MONITOR_INTERVAL_MS;
+let avatarRefreshIntervalMs = DEFAULT_AVATAR_REFRESH_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 => {
@@ -218,17 +218,17 @@ export function _setProcessMonitorIntervalForTest(ms: number): void {
   processMonitorIntervalMs = ms;
 }
 
-export function _resetProcessMonitorIntervalForTest(): void {
-  processMonitorIntervalMs = DEFAULT_PROCESS_MONITOR_INTERVAL_MS;
-}
-
-export function _setAvatarRefreshIntervalForTest(ms: number): void {
-  avatarRefreshIntervalMs = ms;
-}
-
-export function _resetAvatarRefreshIntervalForTest(): void {
-  avatarRefreshIntervalMs = DEFAULT_AVATAR_REFRESH_INTERVAL_MS;
-}
+export function _resetProcessMonitorIntervalForTest(): void {
+  processMonitorIntervalMs = DEFAULT_PROCESS_MONITOR_INTERVAL_MS;
+}
+
+export function _setAvatarRefreshIntervalForTest(ms: number): void {
+  avatarRefreshIntervalMs = ms;
+}
+
+export function _resetAvatarRefreshIntervalForTest(): void {
+  avatarRefreshIntervalMs = DEFAULT_AVATAR_REFRESH_INTERVAL_MS;
+}
 
 export function _setResponseStallTimeoutForTest(ms: number): void {
   responseStallTimeoutMs = ms;
@@ -261,21 +261,21 @@ function clearPromptProcessMonitor(sessionId: string): void {
   prompt.processMonitor = undefined;
 }
 
-function clearPromptResponseStallMonitor(sessionId: string): void {
-  const prompt = activePrompts.get(sessionId);
-  if (!prompt?.responseStallMonitor) return;
-  clearInterval(prompt.responseStallMonitor);
-  prompt.responseStallMonitor = undefined;
-}
-
-function clearPromptAvatarRefreshTimer(sessionId: string): void {
-  const prompt = activePrompts.get(sessionId);
-  if (!prompt?.avatarRefreshTimer) return;
-  clearInterval(prompt.avatarRefreshTimer);
-  prompt.avatarRefreshTimer = undefined;
-}
-
-function clearPromptFinalResponseCloseTimer(sessionId: string): void {
+function clearPromptResponseStallMonitor(sessionId: string): void {
+  const prompt = activePrompts.get(sessionId);
+  if (!prompt?.responseStallMonitor) return;
+  clearInterval(prompt.responseStallMonitor);
+  prompt.responseStallMonitor = undefined;
+}
+
+function clearPromptAvatarRefreshTimer(sessionId: string): void {
+  const prompt = activePrompts.get(sessionId);
+  if (!prompt?.avatarRefreshTimer) return;
+  clearInterval(prompt.avatarRefreshTimer);
+  prompt.avatarRefreshTimer = undefined;
+}
+
+function clearPromptFinalResponseCloseTimer(sessionId: string): void {
   const prompt = activePrompts.get(sessionId);
   if (!prompt?.finalResponseCloseTimer) return;
   clearTimeout(prompt.finalResponseCloseTimer);
@@ -328,18 +328,18 @@ function scheduleFinalResponseCloseGuard(
   runningPrompt.finalResponseCloseTimer = handle;
 }
 
-function formatTerminalHeader(
-  status: "running" | "done" | "stopped" | "error" | "auto_ended",
-  terminalError?: TerminalErrorInfo,
-): {
+function formatTerminalHeader(
+  status: "running" | "done" | "stopped" | "error" | "auto_ended",
+  terminalError?: TerminalErrorInfo,
+): {
   title: string;
   template?: string;
 } {
   if (status === "auto_ended") return { title: "已自动结束 · 3分钟无新内容", template: "orange" };
   if (status === "stopped") return { title: "已停止", template: "red" };
-  if (status === "error") {
-    return { title: terminalError ? `异常结束 · ${terminalError.title}` : "异常结束", template: "red" };
-  }
+  if (status === "error") {
+    return { title: terminalError ? `异常结束 · ${terminalError.title}` : "异常结束", template: "red" };
+  }
   return { title: "完成" };
 }
 
@@ -347,59 +347,59 @@ function turnFinalStatus(status: "running" | "done" | "stopped" | "error" | "aut
   return status === "stopped" || status === "error" || status === "auto_ended" ? "stopped" : "done";
 }
 
-function formatAutoEndedReply(finalReply: string): string {
-  const reason = "⚠️ 已自动结束：生成回复阶段连续 3 分钟没有字符变化。";
+function formatAutoEndedReply(finalReply: string): string {
+  const reason = "⚠️ 已自动结束：生成回复阶段连续 3 分钟没有字符变化。";
   return finalReply
     ? `${reason}以下回复可能不完整。\n\n${finalReply}`
     : `${reason}本轮没有可发送的回复内容。`;
 }
 
 /**
- * 只监控明确的回复生成阶段。启动、压缩、思考、工具调用和搜索都有各自的
- * 状态或资源保护，不能把它们消耗的时间算入回复停滞窗口。
+ * 只监控明确的回复生成阶段。启动、压缩、思考、工具调用和搜索都有各自的
+ * 状态或资源保护，不能把它们消耗的时间算入回复停滞窗口。
  */
-function monitorsOutputProgress(kind: AgentActivityKind): boolean {
-  return kind === "responding";
-}
-
-function formatTerminalReply(
-  status: "running" | "done" | "stopped" | "error" | "auto_ended",
-  finalReply: string,
-  terminalError?: TerminalErrorInfo,
-): string | null {
-  if (status === "auto_ended") return formatAutoEndedReply(finalReply);
-  if (status === "error") {
-    const error = terminalError ?? {
-      kind: "unknown" as const,
-      title: "原因未记录",
-      message: "当前状态中没有可用的错误详情，请查看运行日志。",
-      occurredAt: Date.now(),
-    };
-    return formatTerminalErrorNotice(error, finalReply);
-  }
-  return finalReply || null;
-}
-
-function formatTerminalCardContent(state: {
-  status: "running" | "done" | "stopped" | "error" | "auto_ended";
-  accumulatedContent: string;
-  finalReply: string;
-  terminalError?: TerminalErrorInfo;
-}): string {
-  const content = state.accumulatedContent + state.finalReply;
-  if (state.status !== "error") return content;
-
-  const error = state.terminalError ?? {
-    kind: "unknown" as const,
-    title: "原因未记录",
-    message: "当前状态中没有可用的错误详情，请查看运行日志。",
-    occurredAt: Date.now(),
-  };
-  const reason = formatTerminalErrorReason(error);
-  return content.trim()
-    ? `${content}\n\n${reason}\n以上内容可能不完整。`
-    : reason;
-}
+function monitorsOutputProgress(kind: AgentActivityKind): boolean {
+  return kind === "responding";
+}
+
+function formatTerminalReply(
+  status: "running" | "done" | "stopped" | "error" | "auto_ended",
+  finalReply: string,
+  terminalError?: TerminalErrorInfo,
+): string | null {
+  if (status === "auto_ended") return formatAutoEndedReply(finalReply);
+  if (status === "error") {
+    const error = terminalError ?? {
+      kind: "unknown" as const,
+      title: "原因未记录",
+      message: "当前状态中没有可用的错误详情，请查看运行日志。",
+      occurredAt: Date.now(),
+    };
+    return formatTerminalErrorNotice(error, finalReply);
+  }
+  return finalReply || null;
+}
+
+function formatTerminalCardContent(state: {
+  status: "running" | "done" | "stopped" | "error" | "auto_ended";
+  accumulatedContent: string;
+  finalReply: string;
+  terminalError?: TerminalErrorInfo;
+}): string {
+  const content = state.accumulatedContent + state.finalReply;
+  if (state.status !== "error") return content;
+
+  const error = state.terminalError ?? {
+    kind: "unknown" as const,
+    title: "原因未记录",
+    message: "当前状态中没有可用的错误详情，请查看运行日志。",
+    occurredAt: Date.now(),
+  };
+  const reason = formatTerminalErrorReason(error);
+  return content.trim()
+    ? `${content}\n\n${reason}\n以上内容可能不完整。`
+    : reason;
+}
 
 function isCardKitSequenceConflict(err: unknown): boolean {
   return err instanceof Error && err.message.includes("300317");
@@ -530,11 +530,11 @@ export function resetState(): void {
   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.avatarRefreshTimer) clearInterval(prompt.avatarRefreshTimer);
-    if (prompt.finalResponseCloseTimer) clearTimeout(prompt.finalResponseCloseTimer);
+  for (const prompt of activePrompts.values()) {
+    if (prompt.processMonitor) clearInterval(prompt.processMonitor);
+    if (prompt.responseStallMonitor) clearInterval(prompt.responseStallMonitor);
+    if (prompt.avatarRefreshTimer) clearInterval(prompt.avatarRefreshTimer);
+    if (prompt.finalResponseCloseTimer) clearTimeout(prompt.finalResponseCloseTimer);
   }
   activePrompts.clear();
   displayCards.clear();
@@ -600,7 +600,7 @@ export function getEffectiveFastModeForTool(tool: string, sessionId?: string): b
   return config.codex.fastMode;
 }
 
-function setSessionChatAvatar(
+function setSessionChatAvatar(
   platform: PlatformAdapter,
   chatId: string,
   tool: string,
@@ -609,59 +609,59 @@ function setSessionChatAvatar(
 ): Promise<void> {
   return getEffectiveFastModeForTool(tool, sessionId)
     ? platform.setChatAvatar(chatId, tool, status, { fastMode: true })
-    : platform.setChatAvatar(chatId, tool, status);
-}
-
-async function refreshBusySessionAvatar(
-  sessionId: string,
-  tool: string,
-  fallbackPlatform: PlatformAdapter,
-): Promise<void> {
-  const chatId = pickDisplayChat(sessionId) ?? getLastActiveChat(sessionId) ?? getChatsForSession(sessionId)[0];
-  if (!chatId) return;
-  const platform = platformForChat(chatId) ?? fallbackPlatform;
-  await setSessionChatAvatar(platform, chatId, tool, "busy", sessionId);
-}
-
-function startPromptAvatarRefresh(
-  sessionId: string,
-  tool: string,
-  fallbackPlatform: PlatformAdapter,
-  runningPrompt: NonNullable<ReturnType<typeof activePrompts.get>>,
-): void {
-  let refreshInFlight = false;
-  const timer = setInterval(() => {
-    const current = activePrompts.get(sessionId);
-    if (!current || current !== runningPrompt) {
-      clearInterval(timer);
-      if (runningPrompt.avatarRefreshTimer === timer) {
-        runningPrompt.avatarRefreshTimer = undefined;
-      }
-      return;
-    }
-    if (
-      refreshInFlight
-      || current.stopped
-      || current.abnormalExit
-      || current.resourceStuck
-      || current.autoEnded
-      || current.finalResponseObserved
-    ) {
-      return;
-    }
-
-    refreshInFlight = true;
-    void refreshBusySessionAvatar(sessionId, tool, fallbackPlatform)
-      .catch((err) => {
-        console.warn(`[${ts()}] [AVATAR] Periodic refresh failed for ${sessionId}: ${(err as Error).message}`);
-      })
-      .finally(() => {
-        refreshInFlight = false;
-      });
-  }, avatarRefreshIntervalMs);
-  timer.unref?.();
-  runningPrompt.avatarRefreshTimer = timer;
-}
+    : platform.setChatAvatar(chatId, tool, status);
+}
+
+async function refreshBusySessionAvatar(
+  sessionId: string,
+  tool: string,
+  fallbackPlatform: PlatformAdapter,
+): Promise<void> {
+  const chatId = pickDisplayChat(sessionId) ?? getLastActiveChat(sessionId) ?? getChatsForSession(sessionId)[0];
+  if (!chatId) return;
+  const platform = platformForChat(chatId) ?? fallbackPlatform;
+  await setSessionChatAvatar(platform, chatId, tool, "busy", sessionId);
+}
+
+function startPromptAvatarRefresh(
+  sessionId: string,
+  tool: string,
+  fallbackPlatform: PlatformAdapter,
+  runningPrompt: NonNullable<ReturnType<typeof activePrompts.get>>,
+): void {
+  let refreshInFlight = false;
+  const timer = setInterval(() => {
+    const current = activePrompts.get(sessionId);
+    if (!current || current !== runningPrompt) {
+      clearInterval(timer);
+      if (runningPrompt.avatarRefreshTimer === timer) {
+        runningPrompt.avatarRefreshTimer = undefined;
+      }
+      return;
+    }
+    if (
+      refreshInFlight
+      || current.stopped
+      || current.abnormalExit
+      || current.resourceStuck
+      || current.autoEnded
+      || current.finalResponseObserved
+    ) {
+      return;
+    }
+
+    refreshInFlight = true;
+    void refreshBusySessionAvatar(sessionId, tool, fallbackPlatform)
+      .catch((err) => {
+        console.warn(`[${ts()}] [AVATAR] Periodic refresh failed for ${sessionId}: ${(err as Error).message}`);
+      })
+      .finally(() => {
+        refreshInFlight = false;
+      });
+  }, avatarRefreshIntervalMs);
+  timer.unref?.();
+  runningPrompt.avatarRefreshTimer = timer;
+}
 
 /** 为指定 session 设置模型覆盖（/model <name>） */
 export function setSessionModelOverride(sessionId: string, model: string): void {
@@ -707,13 +707,13 @@ export function getAdapterForTool(tool: string, sessionId?: string): ToolAdapter
       effort: effectiveEffort || undefined,
       fastMode: effectiveFastMode,
     });
-  } else if (tool === "ccc") {
-    adapter = createCccAdapter({
-      apiKey: config.ccc.DEEPSEEK_API_KEY,
-      baseURL: config.ccc.DEEPSEEK_BASE_URL,
-      model: effectiveModel || undefined,
-      effort: effectiveEffort || undefined,
-    });
+  } else if (tool === "ccc") {
+    adapter = createCccAdapter({
+      apiKey: config.ccc.DEEPSEEK_API_KEY,
+      baseURL: config.ccc.DEEPSEEK_BASE_URL,
+      model: effectiveModel || undefined,
+      effort: effectiveEffort || undefined,
+    });
   } else {
     adapter = createClaudeAdapter({
       model: effectiveModel,
@@ -1019,16 +1019,16 @@ export function accumulateBlockContent(
       // 覆盖而非追加：适配器已保证这是一段完整最终文本（如 Cursor 流末快照）
       state.finalCompleteText = block.text;
       break;
-    case "compact_boundary": {
+    case "compact_boundary": {
       const triggerLabel = block.trigger === "manual" ? "手动" : "自动"; // 手动 / 自动
       state.accumulatedContent +=
         `\n\n🔄 上下文压缩(${triggerLabel}): **${block.pre_tokens}** → **${block.post_tokens}** tokens\n`; // 🔄 / →
-      break;
-    }
-    case "agent_status":
-      break;
-  }
-}
+      break;
+    }
+    case "agent_status":
+      break;
+  }
+}
 
 // ---------------------------------------------------------------------------
 // switchChatBinding — /newh、/session N 共用的事务式"切换 chat 绑定"
@@ -1217,7 +1217,7 @@ export async function initClaudeSession(tool: string, overrideCwd?: string, chat
   return { sessionId, cwd };
 }
 
-export async function resumeAndPrompt(
+export async function resumeAndPrompt(
   sessionId: string,
   userText: string,
   platform: PlatformAdapter,
@@ -1225,25 +1225,25 @@ export async function resumeAndPrompt(
   msgTimestamp: number,
   tool: string,
   traceId?: string,
-): Promise<SessionRunOutcome> {
-  return runAgentSession(sessionId, userText, platform, chatId, msgTimestamp, tool, traceId);
-}
+): Promise<SessionRunOutcome> {
+  return runAgentSession(sessionId, userText, platform, chatId, msgTimestamp, tool, traceId);
+}
 
 // ---------------------------------------------------------------------------
 // runAgentSession — session 中心的 agent prompt（文件持久化 + display 解耦）
 // ---------------------------------------------------------------------------
 
-interface RunAgentSessionOptions {
+interface RunAgentSessionOptions {
   /**
    * 标记本轮是 response-stall 后的唯一一次内部续跑。若本轮再次因相同原因
    * 停滞，不再递归创建第三轮，避免服务异常期间无限消耗 token。
    */
   autoRecovery?: boolean;
-}
-
-export type SessionRunOutcome = "busy" | "done" | "stopped" | "error" | "auto_ended";
+}
+
+export type SessionRunOutcome = "busy" | "done" | "stopped" | "error" | "auto_ended";
 
-export async function runAgentSession(
+export async function runAgentSession(
   sessionId: string,
   userText: string,
   platform: PlatformAdapter,
@@ -1252,7 +1252,7 @@ export async function runAgentSession(
   tool: string,
   traceId?: string,
   options: RunAgentSessionOptions = {},
-): Promise<SessionRunOutcome> {
+): Promise<SessionRunOutcome> {
   const tid = traceId ?? "";
 
   // runAgentSession 是飞书用户消息、队列消息与内部自动恢复共同使用的唯一
@@ -1279,7 +1279,7 @@ export async function runAgentSession(
       ? "当前正在生成回复中，请等待完成后再发送消息。也可以发送 /stop 结束，已完成的步骤不会丢失。"
       : "该会话正在生成回复中，请等待完成后再发送消息。也可以发送 /stop 结束，已完成的步骤不会丢失。";
     await platform.sendText(_chatId, busyMsg).catch(() => {});
-    return "busy";
+    return "busy";
   }
 
   // 立即标记活跃，确保 /sessions、isSessionRunning 等查询在异步准备阶段就能看到运行状态。
@@ -1407,7 +1407,7 @@ export async function runAgentSession(
   // 再开始缓存问题对应的任务"。
   const prevState = await readStreamState(sessionId);
   if (prevState && prevState.status !== "running") {
-    const prevTerminalReply = formatTerminalReply(prevState.status, prevState.finalReply, prevState.terminalError);
+    const prevTerminalReply = formatTerminalReply(prevState.status, prevState.finalReply, prevState.terminalError);
     const displayChatId = pickDisplayChat(sessionId);
     if (displayChatId) {
       const pp = platformForChat(displayChatId);
@@ -1426,8 +1426,8 @@ export async function runAgentSession(
           setSessionChatAvatar(pp, displayChatId, prevState.tool, "idle", sessionId).catch(() => {});
         } else {
           const nextSeq = display.sequence + 1;
-          const { title: headerTitle, template: headerTemplate } = formatTerminalHeader(prevState.status, prevState.terminalError);
-          const cardContent = truncateContent(formatTerminalCardContent(prevState)) || " ";
+          const { title: headerTitle, template: headerTemplate } = formatTerminalHeader(prevState.status, prevState.terminalError);
+          const cardContent = truncateContent(formatTerminalCardContent(prevState)) || " ";
           const doneCard = buildProgressCard(progressView({ text: cardContent, status: "done", showStop: false, headerTitle, headerTemplate }));
           await pp.cardUpdate(display.cardId, doneCard, nextSeq).catch(err => {
             console.error(`[${ts()}] [DISPLAY] prevState final cardUpdate failed: ${(err as Error).message}`);
@@ -1506,7 +1506,7 @@ export async function runAgentSession(
   }
 
   // 设置最后活跃群头像为 busy
-  refreshBusySessionAvatar(sessionId, tool, platform).catch(() => {});
+  refreshBusySessionAvatar(sessionId, tool, platform).catch(() => {});
 
   const state: AccumulatorState = {
     accumulatedContent: "",
@@ -1517,23 +1517,24 @@ export async function runAgentSession(
 
   let lastFileWrite = Date.now();
   const FILE_WRITE_INTERVAL_MS = 2000;
-  const toolCallMap = new Map<string, { name: string; input: unknown }>();
-  let streamErrored = false;
-  let streamTerminalError: TerminalErrorInfo | undefined;
-  let runOutcome: SessionRunOutcome = "error";
-
-  const runningPrompt = activePrompts.get(sessionId);
-  if (runningPrompt) {
-    startPromptAvatarRefresh(sessionId, tool, platform, runningPrompt);
-
-    // 在消费第一个事件前建立阶段感知的零字符基线；启动阶段不计时，只有后续
-    // 收到明确的 responding 状态后才会启动三分钟回复停滞保护。
-    runningPrompt.responseProgress = observeResponseProgress(
-      undefined,
-      monitorsOutputProgress(activityTracker.activity.kind),
-      0,
-      activityTracker.activity.startedAt,
-    );
+  const toolCallMap = new Map<string, { name: string; input: unknown }>();
+  let streamErrored = false;
+  let streamTerminalError: TerminalErrorInfo | undefined;
+  let runOutcome: SessionRunOutcome = "error";
+  const responseStallDetectionEnabled = adapter.responseStallDetectionEnabled !== false;
+
+  const runningPrompt = activePrompts.get(sessionId);
+  if (runningPrompt) {
+    startPromptAvatarRefresh(sessionId, tool, platform, runningPrompt);
+
+    // 在消费第一个事件前建立阶段感知的零字符基线；启动阶段不计时，只有后续
+    // 收到明确的 responding 状态后才会启动三分钟回复停滞保护。
+    runningPrompt.responseProgress = observeResponseProgress(
+      undefined,
+      monitorsOutputProgress(activityTracker.activity.kind),
+      0,
+      activityTracker.activity.startedAt,
+    );
 
     const checkResponseStall = async () => {
       const current = activePrompts.get(sessionId);
@@ -1603,18 +1604,20 @@ export async function runAgentSession(
       current.controller.abort();
       await killProcessTree(current.processPid);
       console.warn(
-        `[${ts()}] [RESPONSE-STALL] Session ${sessionId} auto-ended after 3 minutes without reply progress`,
+        `[${ts()}] [RESPONSE-STALL] Session ${sessionId} auto-ended after 3 minutes without 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;
-  }
+    if (responseStallDetectionEnabled) {
+      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, {
@@ -1664,7 +1667,7 @@ export async function runAgentSession(
       }
 
       const prompt = activePrompts.get(sessionId);
-      if (prompt && !prompt.autoEnded) {
+      if (prompt && !prompt.autoEnded) {
         const totalChars = state.accumulatedContent.length + pickFinalReply(state).length;
         prompt.responseProgress = observeResponseProgress(
           // starting → responding 本身是一次有效进展，即便首个文本块仍为空也应
@@ -1695,10 +1698,10 @@ export async function runAgentSession(
         });
       }
     }
-  } catch (streamErr) {
-    streamErrored = true;
-    streamTerminalError = classifyTerminalError(streamErr);
-    console.error(`[${ts()}] [STREAM] Error in stream loop for ${sessionId}: ${(streamErr as Error).message}`);
+  } catch (streamErr) {
+    streamErrored = true;
+    streamTerminalError = classifyTerminalError(streamErr);
+    console.error(`[${ts()}] [STREAM] Error in stream loop for ${sessionId}: ${(streamErr as Error).message}`);
   } finally {
     // 标记 prompt 结束
     resourceMonitor.off("stuck", onResourceStuck);
@@ -1712,10 +1715,10 @@ export async function runAgentSession(
     const wasAutoEnded = timeoutTriggered && !completedAtTimeoutBoundary;
     const wasAutoRecovery = prompt?.autoRecovery ?? false;
     const autoEndedAt = wasAutoEnded ? prompt?.autoEndedAt : undefined;
-    clearPromptResponseStallMonitor(sessionId);
-    clearPromptProcessMonitor(sessionId);
-    clearPromptAvatarRefreshTimer(sessionId);
-    clearPromptFinalResponseCloseTimer(sessionId);
+    clearPromptResponseStallMonitor(sessionId);
+    clearPromptProcessMonitor(sessionId);
+    clearPromptAvatarRefreshTimer(sessionId);
+    clearPromptFinalResponseCloseTimer(sessionId);
     markSessionFinalizing(sessionId);
     activePrompts.delete(sessionId);
 
@@ -1747,24 +1750,24 @@ export async function runAgentSession(
             : wasStopped
               ? "stopped"
               : "done";
-      const finalReply = pickFinalReply(state).trim();
-      const terminalError = streamTerminalError
-        ?? (wasAbnormalExit
-          ? {
-              kind: "process" as const,
-              title: "Agent 进程意外退出",
-              message: "Agent CLI 进程已退出。若回复不完整，请重新发送上一条指令。",
-              occurredAt: Date.now(),
-            }
-          : wasResourceStuck
-            ? {
-                kind: "resource" as const,
-                title: "Agent 进程失去响应",
-                message: "Agent 进程长时间没有 CPU 或内存变化，已被强制停止。若回复不完整，请重新发送上一条指令。",
-                occurredAt: Date.now(),
-              }
-            : undefined);
-      runOutcome = finalStatus;
+      const finalReply = pickFinalReply(state).trim();
+      const terminalError = streamTerminalError
+        ?? (wasAbnormalExit
+          ? {
+              kind: "process" as const,
+              title: "Agent 进程意外退出",
+              message: "Agent CLI 进程已退出。若回复不完整，请重新发送上一条指令。",
+              occurredAt: Date.now(),
+            }
+          : wasResourceStuck
+            ? {
+                kind: "resource" as const,
+                title: "Agent 进程失去响应",
+                message: "Agent 进程长时间没有 CPU 或内存变化，已被强制停止。若回复不完整，请重新发送上一条指令。",
+                occurredAt: Date.now(),
+              }
+            : undefined);
+      runOutcome = finalStatus;
 
     // stop-stuck-loop 接口可能在 fire-and-forget 中已写入带 final_reply 的
     // stream state，finally 不应覆盖它。同时保留 stuckAt 标记，防止
@@ -1794,9 +1797,9 @@ export async function runAgentSession(
       cwd,
       tool,
       ...(preserveStuckAt ? { stuckAt: preserveStuckAt } : {}),
-      ...(autoEndedAt !== undefined ? { autoEndedAt } : {}),
-      ...(terminalError ? { terminalError } : {}),
-    });
+      ...(autoEndedAt !== undefined ? { autoEndedAt } : {}),
+      ...(terminalError ? { terminalError } : {}),
+    });
 
     // display loop 下一轮会读到最终状态并发送消息
 
@@ -1867,9 +1870,9 @@ export async function runAgentSession(
           autoRecoveryTarget = { chatId: activeAutoEnded, platform: pp };
         }
       }
-      console.warn(`[${ts()}] Session ${sessionId} auto-ended after stalled response output (content chunks: ${state.chunkCount})`);
+      console.warn(`[${ts()}] Session ${sessionId} auto-ended after stalled response output (content chunks: ${state.chunkCount})`);
       if (tid) logTrace(tid, "SESSION_END", { sessionId, outcome: "response_stall", chunks: state.chunkCount });
-    } else if (wasAbnormalExit) {
+    } else if (wasAbnormalExit) {
       for (const cid of finalizationChatIds) {
         const finfo = sessionInfoMap.get(cid);
         await recordSessionRegistry({
@@ -1884,55 +1887,55 @@ export async function runAgentSession(
       }
       const activeErr = getLastActiveChat(sessionId) ?? finalizationChatIds[0];
       if (activeErr) setSessionChatAvatar(platform, activeErr, tool, "idle", sessionId).catch(() => {});
-      console.log(`[${ts()}] Session ${sessionId} process exited unexpectedly (content chunks: ${state.chunkCount})`);
-      if (tid) logTrace(tid, "SESSION_END", { sessionId, outcome: "process_missing", chunks: state.chunkCount });
-    } else if (streamErrored || wasResourceStuck) {
-      for (const cid of finalizationChatIds) {
-        const finfo = sessionInfoMap.get(cid);
-        await recordSessionRegistry({
-          chatId: cid,
-          sessionId,
-          tool,
-          turnCount: finfo?.turnCount ?? nextTurnCount,
-          lastContextTokens: finfo?.lastContextTokens ?? nextContextTokens,
-          startTime: finfo?.startTime ?? now,
-          running: false,
-        });
-      }
-      const activeErr = getLastActiveChat(sessionId) ?? finalizationChatIds[0];
-      if (activeErr) {
-        const pp = platformForChat(activeErr) ?? platform;
-        const terminalState = await readStreamState(sessionId);
-        if (
-          terminalError
-          && !displayCards.has(activeErr)
-          && (!terminalState || !isFinalReplySentForTurn(terminalState))
-        ) {
-          await sendFinalReplyTextOnce(
-            pp,
-            activeErr,
-            sessionId,
-            nextTurnCount,
-            formatTerminalErrorNotice(terminalError, finalReplyToWrite),
-          );
-        }
-        setSessionChatAvatar(pp, activeErr, tool, "idle", sessionId).catch(() => {});
-      }
-      const errorOutcome = wasResourceStuck ? "resource_stuck" : "stream_error";
-      console.error(
-        `[${ts()}] Session ${sessionId} ended with ${errorOutcome}` +
-        `${terminalError ? ` (${terminalError.kind}: ${terminalError.title})` : ""} (content chunks: ${state.chunkCount})`,
-      );
-      if (tid) {
-        logTrace(tid, "SESSION_END", {
-          sessionId,
-          outcome: errorOutcome,
-          errorKind: terminalError?.kind,
-          errorTitle: terminalError?.title,
-          chunks: state.chunkCount,
-        });
-      }
-    } else {
+      console.log(`[${ts()}] Session ${sessionId} process exited unexpectedly (content chunks: ${state.chunkCount})`);
+      if (tid) logTrace(tid, "SESSION_END", { sessionId, outcome: "process_missing", chunks: state.chunkCount });
+    } else if (streamErrored || wasResourceStuck) {
+      for (const cid of finalizationChatIds) {
+        const finfo = sessionInfoMap.get(cid);
+        await recordSessionRegistry({
+          chatId: cid,
+          sessionId,
+          tool,
+          turnCount: finfo?.turnCount ?? nextTurnCount,
+          lastContextTokens: finfo?.lastContextTokens ?? nextContextTokens,
+          startTime: finfo?.startTime ?? now,
+          running: false,
+        });
+      }
+      const activeErr = getLastActiveChat(sessionId) ?? finalizationChatIds[0];
+      if (activeErr) {
+        const pp = platformForChat(activeErr) ?? platform;
+        const terminalState = await readStreamState(sessionId);
+        if (
+          terminalError
+          && !displayCards.has(activeErr)
+          && (!terminalState || !isFinalReplySentForTurn(terminalState))
+        ) {
+          await sendFinalReplyTextOnce(
+            pp,
+            activeErr,
+            sessionId,
+            nextTurnCount,
+            formatTerminalErrorNotice(terminalError, finalReplyToWrite),
+          );
+        }
+        setSessionChatAvatar(pp, activeErr, tool, "idle", sessionId).catch(() => {});
+      }
+      const errorOutcome = wasResourceStuck ? "resource_stuck" : "stream_error";
+      console.error(
+        `[${ts()}] Session ${sessionId} ended with ${errorOutcome}` +
+        `${terminalError ? ` (${terminalError.kind}: ${terminalError.title})` : ""} (content chunks: ${state.chunkCount})`,
+      );
+      if (tid) {
+        logTrace(tid, "SESSION_END", {
+          sessionId,
+          outcome: errorOutcome,
+          errorKind: terminalError?.kind,
+          errorTitle: terminalError?.title,
+          chunks: state.chunkCount,
+        });
+      }
+    } else {
       for (const cid of finalizationChatIds) {
         const finfo = sessionInfoMap.get(cid);
         await recordSessionRegistry({
@@ -2044,9 +2047,9 @@ export async function runAgentSession(
     } finally {
       clearSessionFinalizing(sessionId);
     }
-  }
-  return runOutcome;
-}
+  }
+  return runOutcome;
+}
 
 // ---------------------------------------------------------------------------
 // startUnifiedDisplayLoop — 全局统一 display 循环，遍历 displayCards 更新卡片
@@ -2123,13 +2126,13 @@ export function startUnifiedDisplayLoop(): void {
               if (activePrompts.has(sessionId)) continue;
 
               const tail = "━━━ 回答结束 ━━━";
-              const finalMsg = state.status === "auto_ended"
-                ? formatAutoEndedReply(remaining)
-                : state.status === "error"
-                  ? formatTerminalReply(state.status, remaining, state.terminalError) ?? tail
-                  : remaining
-                    ? remaining + "\n" + tail
-                    : tail;
+              const finalMsg = state.status === "auto_ended"
+                ? formatAutoEndedReply(remaining)
+                : state.status === "error"
+                  ? formatTerminalReply(state.status, remaining, state.terminalError) ?? tail
+                  : remaining
+                    ? remaining + "\n" + tail
+                    : tail;
               if (!isFinalReplySentForTurn(state)) {
                 await sendFinalReplyTextOnce(p, chatId, sessionId, state.turnCount, finalMsg);
               }
@@ -2151,8 +2154,8 @@ export function startUnifiedDisplayLoop(): void {
               let terminalCardUpdateAccepted = terminalCardAlreadyUpdated;
               if (!terminalCardAlreadyUpdated) {
                 const nextSeq = display.sequence + 1;
-                const { title: headerTitle, template: headerTemplate } = formatTerminalHeader(state.status, state.terminalError);
-                const cardContent = truncateContent(formatTerminalCardContent(state)) || " ";
+                const { title: headerTitle, template: headerTemplate } = formatTerminalHeader(state.status, state.terminalError);
+                const cardContent = truncateContent(formatTerminalCardContent(state)) || " ";
                 const doneCard = buildProgressCard(progressView({ text: cardContent, status: "done", showStop: false, headerTitle, headerTemplate }));
                 await p.cardUpdate(display.cardId, doneCard, nextSeq).then(() => {
                   display.sequence = nextSeq;
@@ -2179,19 +2182,19 @@ export function startUnifiedDisplayLoop(): void {
               }
 
               let terminalTextDelivered = true;
-              const terminalReply = formatTerminalReply(state.status, state.finalReply, state.terminalError);
-              const errorWasDeliveredByCard =
-                state.status === "error"
-                && !state.finalReply.trim()
-                && terminalCardUpdateAccepted;
-              if (errorWasDeliveredByCard) {
-                if (!isFinalReplySentForTurn(state)) {
-                  await markFinalReplySent(sessionId, state.turnCount);
-                }
-              } else if (terminalReply) {
-                if (!isFinalReplySentForTurn(state)) {
-                  terminalTextDelivered = await sendFinalReplyTextOnce(p, chatId, sessionId, state.turnCount, terminalReply);
-                }
+              const terminalReply = formatTerminalReply(state.status, state.finalReply, state.terminalError);
+              const errorWasDeliveredByCard =
+                state.status === "error"
+                && !state.finalReply.trim()
+                && terminalCardUpdateAccepted;
+              if (errorWasDeliveredByCard) {
+                if (!isFinalReplySentForTurn(state)) {
+                  await markFinalReplySent(sessionId, state.turnCount);
+                }
+              } else if (terminalReply) {
+                if (!isFinalReplySentForTurn(state)) {
+                  terminalTextDelivered = await sendFinalReplyTextOnce(p, chatId, sessionId, state.turnCount, terminalReply);
+                }
               } else if (state.accumulatedContent.trim()) {
                 const short = truncateContent(state.accumulatedContent, 30, 4000);
                 terminalTextDelivered = await p.sendText(chatId, `[生成过程]\n${short}`).then((ok) => ok !== false).catch(() => false);
@@ -2422,11 +2425,11 @@ export function stopSession(sessionId: string): boolean {
     }
     return false;
   }
-  prompt.stopped = true;
-  clearPromptResponseStallMonitor(sessionId);
-  clearPromptProcessMonitor(sessionId);
-  clearPromptAvatarRefreshTimer(sessionId);
-  clearPromptFinalResponseCloseTimer(sessionId);
+  prompt.stopped = true;
+  clearPromptResponseStallMonitor(sessionId);
+  clearPromptProcessMonitor(sessionId);
+  clearPromptAvatarRefreshTimer(sessionId);
+  clearPromptFinalResponseCloseTimer(sessionId);
   cancelQueuedMessage(sessionId);
 
   // 先发起整棵进程树清理，再触发 close/abort。Windows 上 CLI 由