chatccc 0.2.205 → 0.2.207

package/src/session.ts

@@ -36,9 +36,11 @@ 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 { resourceMonitor, registerProcess, unregisterProcess } from "./adapters/resource-monitor.ts";
-import { buildImSkillsPromptCached, exportSkillSubDocs, clearImSkillsPromptCache } from "./im-skills.ts";
-import type { PlatformAdapter } from "./platform-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";
 
 // 微信显示循环压缩：头5 + ... + 尾5，避免在最后一步 sendText 中压缩指令回复
 function compressWechatDisplayText(text: string): string {
@@ -70,10 +72,12 @@ import {
   pickDisplayChat,
   dequeueMessage,
   consumeQueuedMessage,
-  cancelQueuedMessage,
-  setQueuePreservedChat,
-  consumeQueuePreservedChat,
-} from "./session-chat-binding.ts";
+  cancelQueuedMessage,
+  setQueuePreservedChat,
+  consumeQueuePreservedChat,
+  markSessionFinalizing,
+  clearSessionFinalizing,
+} from "./session-chat-binding.ts";
 
 async function sendFinalReplyTextOnce(
   platform: PlatformAdapter,
@@ -154,8 +158,12 @@ function platformForChat(chatId: string): PlatformAdapter | null {
   return chatPlatformMap.get(chatId) ?? platformRef;
 }
 
-const DEFAULT_PROCESS_MONITOR_INTERVAL_MS = 5000;
-let processMonitorIntervalMs = DEFAULT_PROCESS_MONITOR_INTERVAL_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;
+let processMonitorIntervalMs = DEFAULT_PROCESS_MONITOR_INTERVAL_MS;
+let responseStallTimeoutMs = DEFAULT_RESPONSE_STALL_TIMEOUT_MS;
+let responseStallCheckIntervalMs = DEFAULT_RESPONSE_STALL_CHECK_INTERVAL_MS;
 let isProcessAliveImpl = (pid: number): boolean => {
   try {
     process.kill(pid, 0);
@@ -184,29 +192,68 @@ export function _setProcessMonitorIntervalForTest(ms: number): void {
   processMonitorIntervalMs = ms;
 }
 
-export function _resetProcessMonitorIntervalForTest(): void {
-  processMonitorIntervalMs = DEFAULT_PROCESS_MONITOR_INTERVAL_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;
+}
 
-function clearPromptProcessMonitor(sessionId: string): void {
+function clearPromptProcessMonitor(sessionId: string): void {
   const prompt = activePrompts.get(sessionId);
   if (!prompt?.processMonitor) return;
   clearInterval(prompt.processMonitor);
   prompt.processMonitor = undefined;
-}
-
-function formatTerminalHeader(status: "running" | "done" | "stopped" | "error"): {
-  title: string;
-  template?: string;
-} {
-  if (status === "stopped") return { title: "已停止", template: "red" };
-  if (status === "error") return { title: "异常结束", template: "red" };
-  return { title: "完成" };
-}
-
-function turnFinalStatus(status: "running" | "done" | "stopped" | "error"): "done" | "stopped" {
-  return status === "stopped" || status === "error" ? "stopped" : "done";
-}
+}
+
+function clearPromptResponseStallMonitor(sessionId: string): void {
+  const prompt = activePrompts.get(sessionId);
+  if (!prompt?.responseStallMonitor) return;
+  clearInterval(prompt.responseStallMonitor);
+  prompt.responseStallMonitor = undefined;
+}
+
+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 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");
@@ -224,7 +271,7 @@ function startPromptProcessMonitor(sessionId: string, info: ToolProcessInfo): vo
       clearPromptProcessMonitor(sessionId);
       return;
     }
-    if (current.stopped || current.abnormalExit || current.resourceStuck) return;
+    if (current.stopped || current.abnormalExit || current.resourceStuck || current.autoEnded) return;
     if (isProcessAliveImpl(info.pid)) return;
 
     current.abnormalExit = true;
@@ -337,9 +384,10 @@ export function resetState(): void {
   processedMessages.clear();
   lastMsgTimestamps.clear();
   chatPlatformMap.clear();
-  for (const prompt of activePrompts.values()) {
-    if (prompt.processMonitor) clearInterval(prompt.processMonitor);
-  }
+  for (const prompt of activePrompts.values()) {
+    if (prompt.processMonitor) clearInterval(prompt.processMonitor);
+    if (prompt.responseStallMonitor) clearInterval(prompt.responseStallMonitor);
+  }
   activePrompts.clear();
   displayCards.clear();
   sessionModelOverrides.clear();
@@ -964,7 +1012,7 @@ export async function runAgentSession(
   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) return;
+    if (!prompt || prompt.stopped || prompt.abnormalExit || prompt.resourceStuck || prompt.autoEnded) return;
     prompt.resourceStuck = true;
 
     const chatId = pickDisplayChat(sessionId) ?? getLastActiveChat(sessionId) ?? getChatsForSession(sessionId)[0];
@@ -1071,9 +1119,10 @@ export async function runAgentSession(
   // 导致 finalReply 丢失、完成卡片空白。此处主动读取上一轮终端状态完成
   // 卡片终结和回复发送，不依赖 display loop 时序，保证"先发完上一个回答
   // 再开始缓存问题对应的任务"。
-  const prevState = await readStreamState(sessionId);
-  if (prevState && prevState.status !== "running") {
-    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);
@@ -1105,16 +1154,16 @@ export async function runAgentSession(
           const finalStatus = turnFinalStatus(prevState.status);
           finalizeTurnCards(sessionId, prevState.turnCount, finalStatus).catch(() => {});
 
-          if (prevState.finalReply && stillOursAfterUpdate && !isFinalReplySentForTurn(prevState)) {
-            await sendFinalReplyTextOnce(pp, displayChatId, sessionId, prevState.turnCount, prevState.finalReply);
-          }
+          if (prevTerminalReply && stillOursAfterUpdate && !isFinalReplySentForTurn(prevState)) {
+            await sendFinalReplyTextOnce(pp, displayChatId, sessionId, prevState.turnCount, prevTerminalReply);
+          }
           pp.setChatAvatar(displayChatId, prevState.tool, "idle").catch(() => {});
         }
-      } else if (pp && prevState.finalReply && !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, prevState.finalReply);
+        await sendFinalReplyTextOnce(pp, displayChatId, sessionId, prevState.turnCount, prevTerminalReply);
       }
       // else: displayCards 无记录且无 finalReply → 无需处理
     }
@@ -1188,6 +1237,69 @@ export async function runAgentSession(
   const toolCallMap = new Map<string, { name: string; input: unknown }>();
   let streamErrored = false;
 
+  const runningPrompt = activePrompts.get(sessionId);
+  if (runningPrompt) {
+    const checkResponseStall = async () => {
+      const current = activePrompts.get(sessionId);
+      if (!current || current !== runningPrompt) {
+        clearPromptResponseStallMonitor(sessionId);
+        return;
+      }
+      if (
+        current.stopped
+        || current.abnormalExit
+        || current.resourceStuck
+        || current.autoEnded
+        || activityTracker.activity.kind !== "responding"
+        || !hasResponseStalled(current.responseProgress, Date.now(), responseStallTimeoutMs)
+      ) {
+        return;
+      }
+
+      const autoEndedAt = Date.now();
+      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,
+      });
+
+      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 reply character changes`,
+      );
+    };
+
+    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) => {
@@ -1220,10 +1332,21 @@ 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(
+          prompt.responseProgress,
+          activityTracker.activity.kind === "responding",
+          totalChars,
+          Date.now(),
+        );
+      }
+
+      // 定时写入文件
       const now2 = Date.now();
       if (activityChanged || now2 - lastFileWrite >= FILE_WRITE_INTERVAL_MS) {
         lastFileWrite = now2;
@@ -1249,17 +1372,28 @@ export async function runAgentSession(
     // 标记 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;
-    clearPromptProcessMonitor(sessionId);
-    activePrompts.delete(sessionId);
-
-    // 先写最终状态（done/stopped），确保 display loop 在下一轮消费前
+    const wasStopped = prompt?.stopped ?? false;
+    const wasAbnormalExit = prompt?.abnormalExit ?? false;
+    const wasResourceStuck = prompt?.resourceStuck ?? false;
+    const wasAutoEnded = prompt?.autoEnded ?? false;
+    const autoEndedAt = prompt?.autoEndedAt;
+    clearPromptResponseStallMonitor(sessionId);
+    clearPromptProcessMonitor(sessionId);
+    markSessionFinalizing(sessionId);
+    activePrompts.delete(sessionId);
+
+    try {
+    // 先写最终状态（done/stopped），确保 display loop 在下一轮消费前
     // 读到新状态并终结旧卡片。否则 setImmediate 在 CHECK 阶段先于
     // writeFile I/O（POLL 阶段）执行，display loop 会误以为旧轮仍在
     // 运行中并更新旧卡片，而不是新建卡片。
-    const finalStatus = (streamErrored || wasAbnormalExit || wasResourceStuck) ? "error" : wasStopped ? "stopped" : "done";
+    const finalStatus = wasAutoEnded
+      ? "auto_ended"
+      : (streamErrored || wasAbnormalExit || wasResourceStuck)
+        ? "error"
+        : wasStopped
+          ? "stopped"
+          : "done";
     const finalReply = pickFinalReply(state).trim();
 
     // stop-stuck-loop 接口可能在 fire-and-forget 中已写入带 final_reply 的
@@ -1288,39 +1422,12 @@ export async function runAgentSession(
       contextTokens: existingInfo?.lastContextTokens ?? 0,
       updatedAt: Date.now(),
       cwd,
-      tool,
-      ...(preserveStuckAt ? { stuckAt: preserveStuckAt } : {}),
-    });
+      tool,
+      ...(preserveStuckAt ? { stuckAt: preserveStuckAt } : {}),
+      ...(autoEndedAt !== undefined ? { autoEndedAt } : {}),
+    });
 
-    // 消费队列中的缓存消息（异步，不阻塞后续清理）
-    // 用户 /stop 后应丢弃队列消息，避免用户停止后又自动开始新轮
-    if (wasStopped) {
-      const discarded = dequeueMessage(sessionId);
-      if (discarded) {
-        console.log(`[${ts()}] [QUEUE] Discarding queued message for stopped session ${sessionId}`);
-      }
-    } else {
-      const queued = dequeueMessage(sessionId);
-      if (queued) {
-        // 队列消息可能来自其他群，保存当前 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
-        // 足够时间读到 "done" 状态并终结旧卡片，避免新轮更新旧卡片的 bug。
-        // setImmediate 在 check 阶段触发早于下一个 timers 阶段，
-        // display loop (setInterval) 还没机会读到 "done" 就被新 "running" 覆盖。
-        setTimeout(() => {
-          consumeQueuedMessage(platform, queued);
-        }, 200);
-      }
-    }
-
-    // display loop 下一轮会读到最终状态并发送消息
+    // display loop 下一轮会读到最终状态并发送消息
 
     if (wasStopped) {
       for (const cid of getChatsForSession(sessionId)) {
@@ -1342,7 +1449,37 @@ export async function runAgentSession(
       }
       console.log(`[${ts()}] Session ${sessionId} stopped (content chunks: ${state.chunkCount})`);
       if (tid) logTrace(tid, "SESSION_END", { sessionId, outcome: "stopped", chunks: state.chunkCount });
-    } else if (wasAbnormalExit) {
+    } else if (wasAutoEnded) {
+      for (const cid of getChatsForSession(sessionId)) {
+        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) ?? getChatsForSession(sessionId)[0];
+      if (activeAutoEnded) {
+        const terminalState = await readStreamState(sessionId);
+        if (!displayCards.has(activeAutoEnded) && (!terminalState || !isFinalReplySentForTurn(terminalState))) {
+          const pp = platformForChat(activeAutoEnded) ?? platform;
+          await sendFinalReplyTextOnce(
+            pp,
+            activeAutoEnded,
+            sessionId,
+            nextTurnCount,
+            formatAutoEndedReply(finalReplyToWrite),
+          );
+        }
+        platform.setChatAvatar(activeAutoEnded, tool, "idle").catch(() => {});
+      }
+      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) {
       for (const cid of getChatsForSession(sessionId)) {
         const finfo = sessionInfoMap.get(cid);
         await recordSessionRegistry({
@@ -1381,11 +1518,43 @@ export async function runAgentSession(
         }
         platform.setChatAvatar(active2, tool, "idle").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 });
-    }
-  }
-}
+      console.log(`[${ts()}] Session ${sessionId} stream complete (content chunks: ${state.chunkCount})`);
+      if (tid) logTrace(tid, "SESSION_END", { sessionId, chunks: state.chunkCount, finalTextLen: finalReply.length });
+    }
+
+    // 必须等本轮最终卡片、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 {
+      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);
+      }, 200);
+    }
+    } finally {
+      clearSessionFinalizing(sessionId);
+    }
+  }
+}
 
 // ---------------------------------------------------------------------------
 // startUnifiedDisplayLoop — 全局统一 display 循环，遍历 displayCards 更新卡片
@@ -1459,10 +1628,14 @@ export function startUnifiedDisplayLoop(): void {
               // 还没执行，当前 stream state 可能是 stopSession fire-and-forget
               // 写入的，finalReply 滞后于内存态。跳过发送，等 finally 落盘后
               // 下一次 tick 再处理，避免发送过期内容或与后续发送重复。
-              if (activePrompts.has(sessionId)) continue;
-
-              const tail = "━━━ 回答结束 ━━━";
-              const finalMsg = 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);
               }
@@ -1511,11 +1684,12 @@ export function startUnifiedDisplayLoop(): void {
                 continue;
               }
 
-              let terminalTextDelivered = true;
-              if (state.finalReply) {
-                if (!isFinalReplySentForTurn(state)) {
-                  terminalTextDelivered = await sendFinalReplyTextOnce(p, chatId, sessionId, state.turnCount, state.finalReply);
-                }
+              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);
@@ -1739,8 +1913,9 @@ export function stopUnifiedDisplayLoop(): void {
 export function stopSession(sessionId: string): boolean {
   const prompt = activePrompts.get(sessionId);
   if (!prompt) return false;
-  prompt.stopped = true;
-  clearPromptProcessMonitor(sessionId);
+  prompt.stopped = true;
+  clearPromptResponseStallMonitor(sessionId);
+  clearPromptProcessMonitor(sessionId);
   cancelQueuedMessage(sessionId);
   try {
     prompt.closeSession?.();

package/src/stream-state.ts

@@ -13,7 +13,7 @@ export const STREAMS_DIR = join(USER_DATA_DIR, "state", "streams");
 
 export interface StreamState {
   sessionId: string;
-  status: "running" | "done" | "stopped" | "error";
+  status: "running" | "done" | "stopped" | "error" | "auto_ended";
   accumulatedContent: string;
   /** 本轮会话中 LLM 输出的全部文本内容（所有 text block 的累加）。
    *  命名含 "final" 但实为"全部累积文本"，并非仅"最终一段回复"。
@@ -32,8 +32,10 @@ export interface StreamState {
   tool: string;
   /** Set by stop-stuck-loop to prevent the session from being resumed.
    *  The orchestrator checks this before resuming and creates a new session instead. */
-  stuckAt?: number;
-}
+  stuckAt?: number;
+  /** Set when the shared response watchdog ends a turn after three minutes without new characters. */
+  autoEndedAt?: number;
+}
 
 function getStreamStatePath(sessionId: string): string {
   return join(STREAMS_DIR, `${sessionId}.json`);