chatccc 0.2.211 → 0.2.212

package/README.md

@@ -332,9 +332,11 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
 
 **飞书：** 找到机器人后直接发送普通消息，即可在当前私聊中创建并持续使用专属 AI 会话；私聊工作目录固定为运行 ChatCCC 的系统账号用户目录。默认 Agent 发生变化后，下一条私聊普通消息会触发切换并创建新的空会话；若旧 Agent 正在生成，该消息会先排队，待当前回复完成后再切换。命令不会触发自动切换。需要独立任务时，发送 `/new`、`/new claude`、`/new cursor` 或 `/new codex`，机器人会另外创建会话群。
 
-**微信：** 扫码登录后，在机器人私聊里发送 `/new` 或指定 Agent 的 `/new ...` 命令即可开始。功能与飞书基本一致，但展示为纯文本。
-
-## 可用指令
+**微信：** 扫码登录后，在机器人私聊里发送 `/new` 或指定 Agent 的 `/new ...` 命令即可开始。功能与飞书基本一致，但展示为纯文本。
+
+**会话停滞保护：** 当 Agent 连续 3 分钟处于“正在生成回复”且回复字符数没有变化、同时尚未报告权威终态时，ChatCCC 会结束旧 CLI，并优先补发一次“完成了吗？如果没完成继续”；恢复轮再次发生相同停滞时不再递归续跑。Codex 只有 `turn.completed` 才算权威终态，阶段性的 `agent_message` 不算；任一 Agent 报告权威终态后若输出流仍超过 10 秒未关闭，ChatCCC 会强制清理该 CLI 并按正常完成收尾，不会重复询问 Agent。
+
+## 可用指令
 
 | 指令 | 作用 |
 | --- | --- |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chatccc",
-  "version": "0.2.211",
+  "version": "0.2.212",
   "description": "Feishu bot bridge for Claude Code",
   "license": "Apache-2.0",
   "type": "module",

package/src/__tests__/claude-adapter.test.ts

@@ -52,6 +52,7 @@ describe("normalizeSdkMessage", () => {
     expect(result).not.toBeNull();
     expect(result!.type).toBe("assistant");
     expect(result!.blocks).toEqual([{ type: "text", text: "Hello world" }]);
+    expect(result!.isFinalResponse).toBeUndefined();
   });
 
   it("normalizes assistant message with thinking block", () => {

package/src/__tests__/codex-adapter.test.ts

@@ -56,15 +56,15 @@ function createInMemoryMetaStore(
 // ---------------------------------------------------------------------------
 
 describe("normalizeCodexMessage", () => {
-  it("normalizes agent_message into assistant text block", () => {
-    const result = normalizeCodexMessage({
-      type: "item.completed",
-      item: { id: "item_0", type: "agent_message", text: "hello" },
+  it("normalizes agent_message into assistant text block", () => {
+    const result = normalizeCodexMessage({
+      type: "item.completed",
+      item: { id: "item_0", type: "agent_message", text: "hello" },
     });
     expect(result).not.toBeNull();
     expect(result!.type).toBe("assistant");
     expect(result!.blocks).toEqual([{ type: "text", text: "hello" }]);
-    expect(result!.isFinalResponse).toBe(true);
+    expect(result!.isFinalResponse).toBeUndefined();
   });
 
   it("normalizes command_execution start into tool_use block", () => {
@@ -143,13 +143,17 @@ describe("normalizeCodexMessage", () => {
     expect(normalizeCodexMessage({ type: "turn.started" })).toBeNull();
   });
 
-  it("returns null for turn.completed events", () => {
-    expect(
-      normalizeCodexMessage({
-        type: "turn.completed",
-        usage: { input_tokens: 100, output_tokens: 50 },
-      }),
-    ).toBeNull();
+  it("marks turn.completed as the authoritative final response", () => {
+    expect(
+      normalizeCodexMessage({
+        type: "turn.completed",
+        usage: { input_tokens: 100, output_tokens: 50 },
+      }),
+    ).toEqual({
+      type: "assistant",
+      blocks: [],
+      isFinalResponse: true,
+    });
   });
 
   it("returns null for unknown event types", () => {
@@ -225,7 +229,7 @@ describe("Codex stream fixtures", () => {
     expect(state.accumulatedContent).toContain("tool_test");
   });
 
-  it("with tool: 只映射 agent_message 和 command_execution，不映射元事件", () => {
+  it("with tool: 普通输出不标终态，只有 turn.completed 标记终态", () => {
     const lines = readFixture("codex_with_tool.jsonl");
     const messages: UnifiedStreamMessage[] = [];
     for (const raw of lines) {
@@ -235,12 +239,18 @@ describe("Codex stream fixtures", () => {
       if (normalized) messages.push(normalized);
     }
 
-    // 应有: tool_use + tool_result + text = 3 条消息
-    expect(messages.length).toBe(3);
-    expect(messages[0].blocks[0].type).toBe("tool_use");
-    expect(messages[1].blocks[0].type).toBe("tool_result");
-    expect(messages[2].blocks[0].type).toBe("text");
-  });
+    // 应有: tool_use + tool_result + text + turn.completed = 4 条消息
+    expect(messages.length).toBe(4);
+    expect(messages[0].blocks[0].type).toBe("tool_use");
+    expect(messages[1].blocks[0].type).toBe("tool_result");
+    expect(messages[2].blocks[0].type).toBe("text");
+    expect(messages[2].isFinalResponse).toBeUndefined();
+    expect(messages[3]).toEqual({
+      type: "assistant",
+      blocks: [],
+      isFinalResponse: true,
+    });
+  });
 });
 
 // ---------------------------------------------------------------------------

package/src/__tests__/codex-raw-stream-log.test.ts

@@ -136,11 +136,17 @@ describe("Codex raw stream logs", () => {
     expect(rawLogWriteLineMock).toHaveBeenNthCalledWith(2, lines[1]);
     expect(rawLogWriteLineMock).toHaveBeenNthCalledWith(3, lines[2]);
     expect(rawLogCloseMock).toHaveBeenCalledWith({ keep: false });
-    expect(events).toContainEqual({
-      type: "assistant",
-      blocks: [{ type: "text", text: "hello" }],
-      isFinalResponse: true,
-    });
+    expect(events).toEqual([
+      {
+        type: "assistant",
+        blocks: [{ type: "text", text: "hello" }],
+      },
+      {
+        type: "assistant",
+        blocks: [],
+        isFinalResponse: true,
+      },
+    ]);
   });
 
   it("fails the turn and kills the process tree when bad JSON is followed by idle stdout", async () => {

package/src/__tests__/cursor-adapter.test.ts

@@ -445,9 +445,10 @@ describe("normalizeCursorMessage - 三类 assistant 事件区分", () => {
       type: "assistant",
       message: { role: "assistant", content: [{ type: "text", text: "你" }] },
       timestamp_ms: 1778411927583,
-    });
-    expect(result).not.toBeNull();
-    expect(result!.blocks).toEqual([{ type: "text", text: "你" }]);
+    });
+    expect(result).not.toBeNull();
+    expect(result!.blocks).toEqual([{ type: "text", text: "你" }]);
+    expect(result!.isFinalResponse).toBeUndefined();
   });
 
   it("Buffered flush（has timestamp_ms, has model_call_id）→ text_final（覆盖，避免与 delta 重复累加）", () => {
@@ -461,9 +462,10 @@ describe("normalizeCursorMessage - 三类 assistant 事件区分", () => {
       model_call_id: "mc-1",
     } as Parameters<typeof normalizeCursorMessage>[0]);
     expect(result).not.toBeNull();
-    expect(result!.blocks).toEqual([
-      { type: "text_final", text: "完整快照（与 delta 累计相同）" },
-    ]);
+    expect(result!.blocks).toEqual([
+      { type: "text_final", text: "完整快照（与 delta 累计相同）" },
+    ]);
+    expect(result!.isFinalResponse).toBeUndefined();
   });
 
   it("Final flush（no timestamp_ms）→ text_final（覆盖）", () => {
@@ -475,9 +477,10 @@ describe("normalizeCursorMessage - 三类 assistant 事件区分", () => {
       },
     });
     expect(result).not.toBeNull();
-    expect(result!.blocks).toEqual([
-      { type: "text_final", text: "你上一题问的是 1+2=?" },
-    ]);
+    expect(result!.blocks).toEqual([
+      { type: "text_final", text: "你上一题问的是 1+2=?" },
+    ]);
+    expect(result!.isFinalResponse).toBeUndefined();
   });
 });
 

package/src/__tests__/session.test.ts

@@ -122,6 +122,8 @@ import {
   _resetResponseStallTimeoutForTest,
   _setResponseStallCheckIntervalForTest,
   _resetResponseStallCheckIntervalForTest,
+  _setFinalResponseCloseTimeoutForTest,
+  _resetFinalResponseCloseTimeoutForTest,
   setSessionEffortOverride,
   RESPONSE_STALL_RECOVERY_PROMPT,
   RESPONSE_STALL_RECOVERY_EXHAUSTED_NOTICE,
@@ -371,6 +373,7 @@ describe("runAgentSession process monitor", () => {
     _resetProcessMonitorIntervalForTest();
     _resetResponseStallTimeoutForTest();
     _resetResponseStallCheckIntervalForTest();
+    _resetFinalResponseCloseTimeoutForTest();
     resetBindingState();
     vi.useRealTimers();
   });
@@ -692,6 +695,7 @@ describe("runAgentSession response stall watchdog", () => {
     _resetProcessAliveForTest();
     _resetResponseStallTimeoutForTest();
     _resetResponseStallCheckIntervalForTest();
+    _resetFinalResponseCloseTimeoutForTest();
     resetBindingState();
     vi.useRealTimers();
     if (tempDir) await rm(tempDir, { recursive: true, force: true });
@@ -919,6 +923,141 @@ describe("runAgentSession response stall watchdog", () => {
     );
   });
 
+  it("force-closes a stream that stays open after an authoritative final event without auto-recovery", async () => {
+    vi.setSystemTime(0);
+    _setResponseStallTimeoutForTest(100);
+    _setResponseStallCheckIntervalForTest(10);
+    _setFinalResponseCloseTimeoutForTest(1_000);
+    _setProcessAliveForTest(() => true);
+
+    const platform = mockPlatform("feishu");
+    setSessionPlatform(platform);
+    bindChatToSession("sid-final-close", "chat-final-close");
+    recordLastActiveChat("sid-final-close", "chat-final-close");
+
+    const closeSession = vi.fn();
+    const adapter: ToolAdapter = {
+      displayName: "Any Agent",
+      sessionDescPrefix: "Agent Session:",
+      createSession: async () => ({ sessionId: "sid-final-close" }),
+      getSessionInfo: async (sid) => ({ sessionId: sid, cwd: "F:\\repo" }),
+      closeSession: async () => {},
+      prompt: async function* (
+        _sid: string,
+        _text: string,
+        _cwd: string,
+        signal?: AbortSignal,
+        options?: ToolPromptOptions,
+      ) {
+        options?.onSessionCreated?.(closeSession);
+        options?.onProcessStart?.({ pid: 7171 });
+        yield {
+          type: "assistant",
+          blocks: [{ type: "text", text: "authoritative answer" }],
+        };
+        yield {
+          type: "assistant",
+          blocks: [],
+          isFinalResponse: true,
+        };
+        await new Promise<void>((resolve) => {
+          if (signal?.aborted) {
+            resolve();
+            return;
+          }
+          signal?.addEventListener("abort", () => resolve(), { once: true });
+        });
+      },
+    };
+    _setAdapterForToolForTest("claude", adapter);
+
+    const run = runAgentSession(
+      "sid-final-close",
+      "prompt",
+      platform,
+      "chat-final-close",
+      0,
+      "claude",
+    );
+
+    await vi.waitFor(() => {
+      expect(activePrompts.get("sid-final-close")?.finalResponseObserved).toBe(true);
+    });
+    await vi.advanceTimersByTimeAsync(900);
+    expect(activePrompts.has("sid-final-close")).toBe(true);
+
+    await vi.advanceTimersByTimeAsync(100);
+    await run;
+
+    expect(closeSession).toHaveBeenCalledTimes(1);
+    expect(killProcessTreeMock).toHaveBeenCalledWith(7171);
+    expect(mockStreamStates.get("sid-final-close")).toMatchObject({
+      status: "done",
+      finalReply: "authoritative answer",
+    });
+    expect(platform.sendText).not.toHaveBeenCalledWith(
+      "chat-final-close",
+      expect.stringContaining(RESPONSE_STALL_RECOVERY_PROMPT),
+    );
+  });
+
+  it("cancels the final-response close guard when the stream exits normally", async () => {
+    vi.setSystemTime(0);
+    _setFinalResponseCloseTimeoutForTest(1_000);
+    _setProcessAliveForTest(() => true);
+
+    const platform = mockPlatform("feishu");
+    setSessionPlatform(platform);
+    bindChatToSession("sid-final-normal", "chat-final-normal");
+    recordLastActiveChat("sid-final-normal", "chat-final-normal");
+
+    const closeSession = vi.fn();
+    const adapter: ToolAdapter = {
+      displayName: "Any Agent",
+      sessionDescPrefix: "Agent Session:",
+      createSession: async () => ({ sessionId: "sid-final-normal" }),
+      getSessionInfo: async (sid) => ({ sessionId: sid, cwd: "F:\\repo" }),
+      closeSession: async () => {},
+      prompt: async function* (
+        _sid: string,
+        _text: string,
+        _cwd: string,
+        _signal?: AbortSignal,
+        options?: ToolPromptOptions,
+      ) {
+        options?.onSessionCreated?.(closeSession);
+        options?.onProcessStart?.({ pid: 7272 });
+        yield {
+          type: "assistant",
+          blocks: [{ type: "text", text: "normal answer" }],
+        };
+        yield {
+          type: "assistant",
+          blocks: [],
+          isFinalResponse: true,
+        };
+      },
+    };
+    _setAdapterForToolForTest("claude", adapter);
+
+    await runAgentSession(
+      "sid-final-normal",
+      "prompt",
+      platform,
+      "chat-final-normal",
+      0,
+      "claude",
+    );
+    await vi.advanceTimersByTimeAsync(2_000);
+
+    expect(closeSession).not.toHaveBeenCalled();
+    expect(killProcessTreeMock).not.toHaveBeenCalled();
+    expect(mockStreamStates.get("sid-final-normal")).toMatchObject({
+      status: "done",
+      finalReply: "normal answer",
+    });
+  });
+
   it("runs the reserved recovery prompt before an already queued user message", async () => {
     vi.setSystemTime(0);
     _setResponseStallTimeoutForTest(100);

package/src/adapters/codex-adapter.ts

@@ -130,7 +130,8 @@ interface CodexEvent {
 export function normalizeCodexMessage(
   msg: CodexEvent,
 ): UnifiedStreamMessage | null {
-  // agent_message 文本回复
+  // agent_message 只是 Codex 的一条阶段性文本 item。即使内容看起来像完整答复，
+  // 后面仍可能继续发出工具调用，因此不能用它关闭 response-stall watchdog。
   if (
     msg.type === "item.completed" &&
     msg.item?.type === "agent_message" &&
@@ -139,6 +140,15 @@ export function normalizeCodexMessage(
     return {
       type: "assistant",
       blocks: [{ type: "text", text: msg.item.text }],
+    };
+  }
+
+  // turn.completed 是 Codex 对整轮完成的权威确认。正文已经由之前的
+  // agent_message 累计，这里只发送空终态信号，避免重复追加最终文本。
+  if (msg.type === "turn.completed") {
+    return {
+      type: "assistant",
+      blocks: [],
       isFinalResponse: true,
     };
   }
@@ -181,7 +191,7 @@ export function normalizeCodexMessage(
     };
   }
 
-  // thread.started / turn.started / turn.completed → 不映射为用户可见消息
+  // thread.started / turn.started → 不映射为用户可见消息
   return null;
 }
 

package/src/session-chat-binding.ts

@@ -111,6 +111,8 @@ export interface ActivePrompt {
   processPid?: number;
   processMonitor?: ReturnType<typeof setInterval>;
   responseStallMonitor?: ReturnType<typeof setInterval>;
+  /** Grace timer that force-closes a stream which stays open after its authoritative final event. */
+  finalResponseCloseTimer?: ReturnType<typeof setTimeout>;
   /** Character-count progress observed only while the activity is "responding". */
   responseProgress?: ResponseProgressObservation;
   /** Set before a response-stall auto-end begins so competing monitors cannot win the race. */
@@ -275,6 +277,7 @@ export function resetBindingState(): void {
   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();
   finalizingSessions.clear();

package/src/session.ts

@@ -165,6 +165,7 @@ function platformForChat(chatId: string): PlatformAdapter | null {
 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}`;
@@ -174,6 +175,7 @@ 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);
@@ -221,7 +223,15 @@ export function _setResponseStallCheckIntervalForTest(ms: number): void {
 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;
@@ -236,6 +246,59 @@ function clearPromptResponseStallMonitor(sessionId: string): void {
   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;
@@ -397,6 +460,7 @@ export function resetState(): void {
   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();
@@ -1371,7 +1435,10 @@ export async function runAgentSession(
         if (prompt && prompt === runningPrompt) {
           // 同步标记必须发生在任何 await 之前，让 watchdog 无法在已收到完整
           // 最终事件后仍把本轮判为停滞。
-          prompt.finalResponseObserved = true;
+          if (!prompt.finalResponseObserved) {
+            prompt.finalResponseObserved = true;
+            scheduleFinalResponseCloseGuard(sessionId, prompt);
+          }
         }
       }
 
@@ -1443,6 +1510,7 @@ export async function runAgentSession(
     const autoEndedAt = wasAutoEnded ? prompt?.autoEndedAt : undefined;
     clearPromptResponseStallMonitor(sessionId);
     clearPromptProcessMonitor(sessionId);
+    clearPromptFinalResponseCloseTimer(sessionId);
     markSessionFinalizing(sessionId);
     activePrompts.delete(sessionId);
 
@@ -2080,6 +2148,7 @@ export function stopSession(sessionId: string): boolean {
   prompt.stopped = true;
   clearPromptResponseStallMonitor(sessionId);
   clearPromptProcessMonitor(sessionId);
+  clearPromptFinalResponseCloseTimer(sessionId);
   cancelQueuedMessage(sessionId);
   try {
     prompt.closeSession?.();