chatccc 0.2.222 → 0.2.224

package/src/__tests__/session.test.ts

@@ -1,25 +1,25 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
 import { mkdtemp, rm, readFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
-
-const killProcessTreeMock = vi.hoisted(() => vi.fn(async (_pid?: number) => {}));
-vi.mock("../adapters/proc-tree-kill.ts", () => ({
-  killProcessTree: killProcessTreeMock,
-}));
-
-// mock stream-state 以支持在测试中控制累积长度
-const mockStreamStates = new Map<string, {
-  accumulatedContent: string;
-  finalReply: string;
-  activity?: {
-    kind: "starting" | "thinking" | "tool" | "processing" | "responding" | "searching" | "compacting";
-    startedAt: number;
-    toolName?: string;
-    toolCount?: number;
-  };
-  status?: "running" | "done" | "stopped" | "error" | "auto_ended";
-  autoEndedAt?: number;
+import { dirname, join } from "node:path";
+
+const killProcessTreeMock = vi.hoisted(() => vi.fn(async (_pid?: number) => {}));
+vi.mock("../adapters/proc-tree-kill.ts", () => ({
+  killProcessTree: killProcessTreeMock,
+}));
+
+// mock stream-state 以支持在测试中控制累积长度
+const mockStreamStates = new Map<string, {
+  accumulatedContent: string;
+  finalReply: string;
+  activity?: {
+    kind: "starting" | "thinking" | "tool" | "processing" | "responding" | "searching" | "compacting";
+    startedAt: number;
+    toolName?: string;
+    toolCount?: number;
+  };
+  status?: "running" | "done" | "stopped" | "error" | "auto_ended";
+  autoEndedAt?: number;
   turnCount?: number;
   finalReplySentTurn?: number;
   finalReplySentAt?: number;
@@ -30,12 +30,12 @@ vi.mock("../stream-state.ts", () => ({
     if (!state) return null;
     return {
       sessionId: sid,
-      accumulatedContent: state.accumulatedContent,
-      finalReply: state.finalReply,
-      activity: state.activity,
-      finalReplySentTurn: state.finalReplySentTurn,
-      finalReplySentAt: state.finalReplySentAt,
-      autoEndedAt: state.autoEndedAt,
+      accumulatedContent: state.accumulatedContent,
+      finalReply: state.finalReply,
+      activity: state.activity,
+      finalReplySentTurn: state.finalReplySentTurn,
+      finalReplySentAt: state.finalReplySentAt,
+      autoEndedAt: state.autoEndedAt,
       status: state.status ?? "running",
       chunkCount: 0,
       turnCount: state.turnCount ?? 0,
@@ -48,33 +48,33 @@ vi.mock("../stream-state.ts", () => ({
   writeStreamState: async (state: {
     sessionId: string;
     accumulatedContent: string;
-    finalReply: string;
-    activity?: {
-      kind: "starting" | "thinking" | "tool" | "processing" | "responding" | "searching" | "compacting";
-      startedAt: number;
-      toolName?: string;
-      toolCount?: number;
-    };
-    status?: "running" | "done" | "stopped" | "error" | "auto_ended";
-    autoEndedAt?: number;
+    finalReply: string;
+    activity?: {
+      kind: "starting" | "thinking" | "tool" | "processing" | "responding" | "searching" | "compacting";
+      startedAt: number;
+      toolName?: string;
+      toolCount?: number;
+    };
+    status?: "running" | "done" | "stopped" | "error" | "auto_ended";
+    autoEndedAt?: number;
     turnCount?: number;
     finalReplySentTurn?: number;
     finalReplySentAt?: number;
   }) => {
     mockStreamStates.set(state.sessionId, {
-      accumulatedContent: state.accumulatedContent,
-      finalReply: state.finalReply,
-      activity: state.activity,
-      status: state.status,
-      autoEndedAt: state.autoEndedAt,
+      accumulatedContent: state.accumulatedContent,
+      finalReply: state.finalReply,
+      activity: state.activity,
+      status: state.status,
+      autoEndedAt: state.autoEndedAt,
       turnCount: state.turnCount,
       finalReplySentTurn: state.finalReplySentTurn,
       finalReplySentAt: state.finalReplySentAt,
     });
   },
-  createEmptyStreamState: (sid: string, cwd: string, tool: string, turnCount: number) => ({
-    sessionId: sid, status: "running" as const, accumulatedContent: "", finalReply: "", activity: { kind: "starting" as const, startedAt: Date.now() }, chunkCount: 0, turnCount, contextTokens: 0, updatedAt: Date.now(), cwd, tool,
-  }),
+  createEmptyStreamState: (sid: string, cwd: string, tool: string, turnCount: number) => ({
+    sessionId: sid, status: "running" as const, accumulatedContent: "", finalReply: "", activity: { kind: "starting" as const, startedAt: Date.now() }, chunkCount: 0, turnCount, contextTokens: 0, updatedAt: Date.now(), cwd, tool,
+  }),
   isFinalReplySentForTurn: (state: { turnCount: number; finalReplySentTurn?: number }) => state.finalReplySentTurn === state.turnCount,
   markFinalReplySent: async (sid: string, turnCount: number, sentAt = Date.now()) => {
     const state = mockStreamStates.get(sid);
@@ -109,29 +109,31 @@ import {
   _clearAdapterCacheForTest,
   setSessionPlatform,
   recordChatPlatform,
-  _getPlatformForChatForTest,
-  initClaudeSession,
-  runAgentSession,
+  _getPlatformForChatForTest,
+  initClaudeSession,
+  runAgentSession,
   stopSession,
   startUnifiedDisplayLoop,
   stopUnifiedDisplayLoop,
-  _setProcessAliveForTest,
-  _resetProcessAliveForTest,
-  _setProcessMonitorIntervalForTest,
-  _resetProcessMonitorIntervalForTest,
-  _setResponseStallTimeoutForTest,
-  _resetResponseStallTimeoutForTest,
-  _setResponseStallCheckIntervalForTest,
-  _resetResponseStallCheckIntervalForTest,
-  _setFinalResponseCloseTimeoutForTest,
-  _resetFinalResponseCloseTimeoutForTest,
-  setSessionEffortOverride,
-  getEffectiveFastModeForTool,
-  setSessionFastModeOverride,
-  RESPONSE_STALL_RECOVERY_PROMPT,
-  RESPONSE_STALL_RECOVERY_EXHAUSTED_NOTICE,
-} from "../session.ts";
-import { config } from "../config.ts";
+  _setProcessAliveForTest,
+  _resetProcessAliveForTest,
+  _setProcessMonitorIntervalForTest,
+  _resetProcessMonitorIntervalForTest,
+  _setResponseStallTimeoutForTest,
+  _resetResponseStallTimeoutForTest,
+  _setResponseStallCheckIntervalForTest,
+  _resetResponseStallCheckIntervalForTest,
+  _setFinalResponseCloseTimeoutForTest,
+  _resetFinalResponseCloseTimeoutForTest,
+  setSessionEffortOverride,
+  clearSessionEffortOverride,
+  getEffectiveEffortForTool,
+  getEffectiveFastModeForTool,
+  setSessionFastModeOverride,
+  RESPONSE_STALL_RECOVERY_PROMPT,
+  RESPONSE_STALL_RECOVERY_EXHAUSTED_NOTICE,
+} from "../session.ts";
+import { config } from "../config.ts";
 import {
   activePrompts,
   bindChatToSession,
@@ -140,34 +142,34 @@ import {
   getLastActiveChat,
   pickDisplayChat,
   resetBindingState,
-  getChatsForSession,
-  displayCards,
-  enqueueMessage,
-  setQueueConsumer,
-  isSessionRunning,
-} from "../session-chat-binding.ts";
+  getChatsForSession,
+  displayCards,
+  enqueueMessage,
+  setQueueConsumer,
+  isSessionRunning,
+} from "../session-chat-binding.ts";
 import type { AccumulatorState } from "../session.ts";
 import type { ToolAdapter, ToolPromptOptions, UnifiedBlock, SessionInfo } from "../adapters/adapter-interface.ts";
-import type { PlatformAdapter } from "../platform-adapter.ts";
-
-describe("Codex Fast mode overrides", () => {
-  it("uses the global default until the current session overrides it", () => {
-    const previousFastMode = config.codex.fastMode;
-    config.codex.fastMode = false;
-    resetState();
-
-    expect(getEffectiveFastModeForTool("codex", "sid-fast")).toBe(false);
-    setSessionFastModeOverride("sid-fast", true);
-    expect(getEffectiveFastModeForTool("codex", "sid-fast")).toBe(true);
-    setSessionFastModeOverride("sid-fast", false);
-    expect(getEffectiveFastModeForTool("codex", "sid-fast")).toBe(false);
-    expect(getEffectiveFastModeForTool("claude", "sid-fast")).toBe(false);
-
-    resetState();
-    expect(getEffectiveFastModeForTool("codex", "sid-fast")).toBe(false);
-    config.codex.fastMode = previousFastMode;
-  });
-});
+import type { PlatformAdapter } from "../platform-adapter.ts";
+
+describe("Codex Fast mode overrides", () => {
+  it("uses the global default until the current session overrides it", () => {
+    const previousFastMode = config.codex.fastMode;
+    config.codex.fastMode = false;
+    resetState();
+
+    expect(getEffectiveFastModeForTool("codex", "sid-fast")).toBe(false);
+    setSessionFastModeOverride("sid-fast", true);
+    expect(getEffectiveFastModeForTool("codex", "sid-fast")).toBe(true);
+    setSessionFastModeOverride("sid-fast", false);
+    expect(getEffectiveFastModeForTool("codex", "sid-fast")).toBe(false);
+    expect(getEffectiveFastModeForTool("claude", "sid-fast")).toBe(false);
+
+    resetState();
+    expect(getEffectiveFastModeForTool("codex", "sid-fast")).toBe(false);
+    config.codex.fastMode = previousFastMode;
+  });
+});
 
 // Helper to create a mock active session entry
 function mockActiveSession(chatId: string, overrides: Partial<{
@@ -249,7 +251,7 @@ function mockPlatform(name: string): PlatformAdapter {
   };
 }
 
-describe("resetState", () => {
+describe("resetState", () => {
   it("clears all maps and sets", () => {
     chatSessionMap.set("chat1", {
       gen: 1, close: () => {}, cardId: null, stopped: false,
@@ -268,58 +270,58 @@ describe("resetState", () => {
     expect(sessionInfoMap.size).toBe(0);
     expect(processedMessages.size).toBe(0);
   });
-});
-
-describe("initClaudeSession startup watchdog", () => {
-  afterEach(() => {
-    _clearAdapterCacheForTest();
-    _resetResponseStallTimeoutForTest();
-    vi.useRealTimers();
-  });
-
-  it("aborts session creation when an Agent never emits its init event", async () => {
-    vi.useFakeTimers();
-    _setResponseStallTimeoutForTest(100);
-
-    let aborted = false;
-    const adapter: ToolAdapter = {
-      displayName: "Silent Cursor",
-      sessionDescPrefix: "Cursor Session:",
-      createSession: async (_cwd: string, signal?: AbortSignal) => {
-        await new Promise<void>((resolve) => {
-          if (signal?.aborted) {
-            aborted = true;
-            resolve();
-            return;
-          }
-          signal?.addEventListener("abort", () => {
-            aborted = true;
-            resolve();
-          }, { once: true });
-        });
-        throw new Error("adapter aborted");
-      },
-      prompt: async function* () {},
-      getSessionInfo: async () => undefined,
-      closeSession: async () => {},
-    };
-    _setAdapterForToolForTest("cursor", adapter);
-
-    let outcome: unknown;
-    void initClaudeSession("cursor", "F:\\repo").then(
-      (value) => { outcome = value; },
-      (err) => { outcome = err; },
-    );
-
-    await vi.advanceTimersByTimeAsync(101);
-
-    expect(aborted).toBe(true);
-    expect(outcome).toBeInstanceOf(Error);
-    expect((outcome as Error).message).toContain("3 minutes");
-  });
-});
-
-describe("chat platform routing", () => {
+});
+
+describe("initClaudeSession startup watchdog", () => {
+  afterEach(() => {
+    _clearAdapterCacheForTest();
+    _resetResponseStallTimeoutForTest();
+    vi.useRealTimers();
+  });
+
+  it("aborts session creation when an Agent never emits its init event", async () => {
+    vi.useFakeTimers();
+    _setResponseStallTimeoutForTest(100);
+
+    let aborted = false;
+    const adapter: ToolAdapter = {
+      displayName: "Silent Cursor",
+      sessionDescPrefix: "Cursor Session:",
+      createSession: async (_cwd: string, signal?: AbortSignal) => {
+        await new Promise<void>((resolve) => {
+          if (signal?.aborted) {
+            aborted = true;
+            resolve();
+            return;
+          }
+          signal?.addEventListener("abort", () => {
+            aborted = true;
+            resolve();
+          }, { once: true });
+        });
+        throw new Error("adapter aborted");
+      },
+      prompt: async function* () {},
+      getSessionInfo: async () => undefined,
+      closeSession: async () => {},
+    };
+    _setAdapterForToolForTest("cursor", adapter);
+
+    let outcome: unknown;
+    void initClaudeSession("cursor", "F:\\repo").then(
+      (value) => { outcome = value; },
+      (err) => { outcome = err; },
+    );
+
+    await vi.advanceTimersByTimeAsync(101);
+
+    expect(aborted).toBe(true);
+    expect(outcome).toBeInstanceOf(Error);
+    expect((outcome as Error).message).toContain("3 minutes");
+  });
+});
+
+describe("chat platform routing", () => {
   beforeEach(() => {
     resetState();
   });
@@ -441,16 +443,16 @@ describe("runAgentSession process monitor", () => {
     _resetSessionRegistryFileForTest();
     _resetSessionToolsFileForTest();
     _clearAdapterCacheForTest();
-    _resetProcessAliveForTest();
-    _resetProcessMonitorIntervalForTest();
-    _resetResponseStallTimeoutForTest();
-    _resetResponseStallCheckIntervalForTest();
-    _resetFinalResponseCloseTimeoutForTest();
+    _resetProcessAliveForTest();
+    _resetProcessMonitorIntervalForTest();
+    _resetResponseStallTimeoutForTest();
+    _resetResponseStallCheckIntervalForTest();
+    _resetFinalResponseCloseTimeoutForTest();
     resetBindingState();
     vi.useRealTimers();
   });
 
-  it("marks the turn as error and sends a separate notice when the CLI process disappears", async () => {
+  it("marks the turn as error and sends a separate notice when the CLI process disappears", async () => {
     const platform = mockPlatform("feishu");
     setSessionPlatform(platform);
     bindChatToSession("sid-process", "chat-process");
@@ -545,7 +547,7 @@ describe("runAgentSession process monitor", () => {
     );
   });
 
-  it("does not register an invisible progress card and sends the final text fallback", async () => {
+  it("does not register an invisible progress card and sends the final text fallback", async () => {
     vi.spyOn(console, "error").mockImplementation(() => {});
     const platform = mockPlatform("feishu");
     platform.cardCreate = vi.fn()
@@ -578,77 +580,77 @@ describe("runAgentSession process monitor", () => {
       "生成中卡片发送失败，结果将以文本形式发送。",
     );
     expect(platform.sendText).toHaveBeenCalledWith("chat-card-fallback", "final answer");
-    expect(mockStreamStates.get("sid-card-fallback")?.finalReplySentTurn).toBe(1);
-  });
-
-  it("consumes a queued message only after the previous turn finishes final delivery", async () => {
-    const platform = mockPlatform("feishu");
-    setSessionPlatform(platform);
-    bindChatToSession("sid-queue-finalize", "chat-queue-finalize");
-    recordLastActiveChat("sid-queue-finalize", "chat-queue-finalize");
-
-    let releaseFinalDelivery: (() => void) | undefined;
-    const finalDeliveryGate = new Promise<void>((resolve) => {
-      releaseFinalDelivery = resolve;
-    });
-    platform.sendText = vi.fn(async (_chatId, content) => {
-      if (content === "final answer") await finalDeliveryGate;
-      return true;
-    });
-
-    const adapter: ToolAdapter = {
-      displayName: "Claude Code",
-      sessionDescPrefix: "Claude Code Session:",
-      createSession: async () => ({ sessionId: "sid-queue-finalize" }),
-      getSessionInfo: async (sid) => ({ sessionId: sid, cwd: "F:\\repo" }),
-      closeSession: async () => {},
-      prompt: async function* () {
-        // 强制走最终文本发送路径，并用 gate 模拟该收尾步骤仍在进行。
-        displayCards.delete("chat-queue-finalize");
-        yield { type: "assistant", blocks: [{ type: "text", text: "final answer" }] };
-      },
-    };
-    _setAdapterForToolForTest("claude", adapter);
-
-    enqueueMessage("sid-queue-finalize", {
-      text: "queued prompt",
-      chatId: "chat-queue-finalize",
-      openId: "open-user",
-      msgTimestamp: Date.now(),
-      chatType: "p2p",
-    });
-    const consumeQueued = vi.fn();
-    setQueueConsumer(consumeQueued);
-
-    const runPromise = runAgentSession(
-      "sid-queue-finalize",
-      "first prompt",
-      platform,
-      "chat-queue-finalize",
-      Date.now(),
-      "claude",
-    );
-    await vi.waitFor(() => {
-      expect(platform.sendText).toHaveBeenCalledWith("chat-queue-finalize", "final answer");
-    });
-    expect(isSessionRunning("sid-queue-finalize")).toBe(true);
-
-    await vi.advanceTimersByTimeAsync(250);
-    expect(consumeQueued).not.toHaveBeenCalled();
-
-    releaseFinalDelivery?.();
-    await runPromise;
-    expect(isSessionRunning("sid-queue-finalize")).toBe(false);
-    await vi.advanceTimersByTimeAsync(200);
-    expect(consumeQueued).toHaveBeenCalledTimes(1);
-    expect(consumeQueued).toHaveBeenCalledWith(
-      platform,
-      expect.objectContaining({ text: "queued prompt", chatId: "chat-queue-finalize" }),
-    );
-    setQueueConsumer(() => {});
-  });
-
-  it("sends the stopped notice only after the prompt generator exits", async () => {
+    expect(mockStreamStates.get("sid-card-fallback")?.finalReplySentTurn).toBe(1);
+  });
+
+  it("consumes a queued message only after the previous turn finishes final delivery", async () => {
+    const platform = mockPlatform("feishu");
+    setSessionPlatform(platform);
+    bindChatToSession("sid-queue-finalize", "chat-queue-finalize");
+    recordLastActiveChat("sid-queue-finalize", "chat-queue-finalize");
+
+    let releaseFinalDelivery: (() => void) | undefined;
+    const finalDeliveryGate = new Promise<void>((resolve) => {
+      releaseFinalDelivery = resolve;
+    });
+    platform.sendText = vi.fn(async (_chatId, content) => {
+      if (content === "final answer") await finalDeliveryGate;
+      return true;
+    });
+
+    const adapter: ToolAdapter = {
+      displayName: "Claude Code",
+      sessionDescPrefix: "Claude Code Session:",
+      createSession: async () => ({ sessionId: "sid-queue-finalize" }),
+      getSessionInfo: async (sid) => ({ sessionId: sid, cwd: "F:\\repo" }),
+      closeSession: async () => {},
+      prompt: async function* () {
+        // 强制走最终文本发送路径，并用 gate 模拟该收尾步骤仍在进行。
+        displayCards.delete("chat-queue-finalize");
+        yield { type: "assistant", blocks: [{ type: "text", text: "final answer" }] };
+      },
+    };
+    _setAdapterForToolForTest("claude", adapter);
+
+    enqueueMessage("sid-queue-finalize", {
+      text: "queued prompt",
+      chatId: "chat-queue-finalize",
+      openId: "open-user",
+      msgTimestamp: Date.now(),
+      chatType: "p2p",
+    });
+    const consumeQueued = vi.fn();
+    setQueueConsumer(consumeQueued);
+
+    const runPromise = runAgentSession(
+      "sid-queue-finalize",
+      "first prompt",
+      platform,
+      "chat-queue-finalize",
+      Date.now(),
+      "claude",
+    );
+    await vi.waitFor(() => {
+      expect(platform.sendText).toHaveBeenCalledWith("chat-queue-finalize", "final answer");
+    });
+    expect(isSessionRunning("sid-queue-finalize")).toBe(true);
+
+    await vi.advanceTimersByTimeAsync(250);
+    expect(consumeQueued).not.toHaveBeenCalled();
+
+    releaseFinalDelivery?.();
+    await runPromise;
+    expect(isSessionRunning("sid-queue-finalize")).toBe(false);
+    await vi.advanceTimersByTimeAsync(200);
+    expect(consumeQueued).toHaveBeenCalledTimes(1);
+    expect(consumeQueued).toHaveBeenCalledWith(
+      platform,
+      expect.objectContaining({ text: "queued prompt", chatId: "chat-queue-finalize" }),
+    );
+    setQueueConsumer(() => {});
+  });
+
+  it("sends the stopped notice only after the prompt generator exits", async () => {
     const platform = mockPlatform("feishu");
     setSessionPlatform(platform);
     bindChatToSession("sid-stop-notice", "chat-stop-notice");
@@ -745,947 +747,947 @@ describe("runAgentSession process monitor", () => {
   });
 });
 
-describe("runAgentSession response stall watchdog", () => {
-  let tempDir = "";
-  const recoveryPrompt = RESPONSE_STALL_RECOVERY_PROMPT;
-
-  beforeEach(async () => {
-    vi.useFakeTimers();
-    resetState();
-    resetBindingState();
-    mockStreamStates.clear();
-    killProcessTreeMock.mockClear();
-    tempDir = await mkdtemp(join(tmpdir(), "chatccc-response-stall-"));
-    _setSessionRegistryFileForTest(join(tempDir, "session-registry.json"));
-    _setSessionToolsFileForTest(join(tempDir, "session-tools.json"));
-  });
-
-  afterEach(async () => {
-    _resetSessionRegistryFileForTest();
-    _resetSessionToolsFileForTest();
-    _clearAdapterCacheForTest();
-    _resetProcessAliveForTest();
-    _resetResponseStallTimeoutForTest();
-    _resetResponseStallCheckIntervalForTest();
-    _resetFinalResponseCloseTimeoutForTest();
-    resetBindingState();
-    vi.useRealTimers();
-    if (tempDir) await rm(tempDir, { recursive: true, force: true });
-  });
-
-  it("auto-ends every Agent after three minutes of unchanged reply characters, including zero", async () => {
-    vi.setSystemTime(0);
-    _setResponseStallTimeoutForTest(180_000);
-    _setResponseStallCheckIntervalForTest(1_000);
-    _setProcessAliveForTest(() => true);
-
-    const platform = mockPlatform("feishu");
-    setSessionPlatform(platform);
-    bindChatToSession("sid-response-stall", "chat-response-stall");
-    recordLastActiveChat("sid-response-stall", "chat-response-stall");
-
-    const closeSession = vi.fn();
-    const adapter: ToolAdapter = {
-      displayName: "Any Agent",
-      sessionDescPrefix: "Agent Session:",
-      createSession: async () => ({ sessionId: "sid-response-stall" }),
-      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: 4242 });
-        yield { type: "assistant", blocks: [{ type: "text", text: "" }] };
-        await new Promise<void>((resolve) => {
-          if (signal?.aborted) {
-            resolve();
-            return;
-          }
-          signal?.addEventListener("abort", () => resolve(), { once: true });
-        });
-      },
-    };
-    _setAdapterForToolForTest("claude", adapter);
-
-    const runPromise = runAgentSession(
-      "sid-response-stall",
-      "prompt",
-      platform,
-      "chat-response-stall",
-      Date.now(),
-      "claude",
-    );
-
-    await vi.waitFor(() => {
-      expect(activePrompts.get("sid-response-stall")?.responseProgress).toEqual({
-        totalChars: 0,
-        unchangedSince: expect.any(Number),
-      });
-    });
-
-    const progress = activePrompts.get("sid-response-stall")!.responseProgress!;
-    const remainingBeforeBoundary = progress.unchangedSince + 180_000 - Date.now() - 1;
-    await vi.advanceTimersByTimeAsync(remainingBeforeBoundary);
-    expect(activePrompts.has("sid-response-stall")).toBe(true);
-
-    await vi.advanceTimersByTimeAsync(1_001);
-    await runPromise;
-
-    expect(closeSession).toHaveBeenCalledTimes(1);
-    expect(killProcessTreeMock).toHaveBeenCalledWith(4242);
-    expect(activePrompts.has("sid-response-stall")).toBe(false);
-    expect(mockStreamStates.get("sid-response-stall")).toMatchObject({
-      status: "auto_ended",
-      finalReply: "",
-      autoEndedAt: expect.any(Number),
-    });
-  });
-
-  it("auto-ends an Agent that stays in starting state without emitting any event", async () => {
-    vi.setSystemTime(0);
-    _setResponseStallTimeoutForTest(180_000);
-    _setResponseStallCheckIntervalForTest(1_000);
-    _setProcessAliveForTest(() => true);
-
-    const platform = mockPlatform("feishu");
-    setSessionPlatform(platform);
-    bindChatToSession("sid-starting-stall", "chat-starting-stall");
-    recordLastActiveChat("sid-starting-stall", "chat-starting-stall");
-
-    const closeSession = vi.fn();
-    const adapter: ToolAdapter = {
-      displayName: "Silent Agent",
-      sessionDescPrefix: "Agent Session:",
-      createSession: async () => ({ sessionId: "sid-starting-stall" }),
-      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: 4343 });
-        await new Promise<void>((resolve) => {
-          if (signal?.aborted) {
-            resolve();
-            return;
-          }
-          signal?.addEventListener("abort", () => resolve(), { once: true });
-        });
-        if (false) yield { type: "assistant", blocks: [] };
-      },
-    };
-    _setAdapterForToolForTest("codex", adapter);
-
-    const runPromise = runAgentSession(
-      "sid-starting-stall",
-      "prompt",
-      platform,
-      "chat-starting-stall",
-      Date.now(),
-      "codex",
-    );
-
-    await vi.waitFor(() => {
-      expect(activePrompts.get("sid-starting-stall")).toMatchObject({
-        processPid: 4343,
-        responseProgress: {
-          totalChars: 0,
-          unchangedSince: expect.any(Number),
-        },
-      });
-      expect(closeSession).toHaveBeenCalledTimes(0);
-    });
-
-    await vi.advanceTimersByTimeAsync(181_001);
-    const stateAfterDeadline = mockStreamStates.get("sid-starting-stall");
-    const closeCountAfterDeadline = closeSession.mock.calls.length;
-    const treeKillCountAfterDeadline = killProcessTreeMock.mock.calls
-      .filter(([pid]) => pid === 4343)
-      .length;
-
-    // 旧实现不会结束真正的零事件启动；先清理测试会话，避免失败用例悬挂。
-    if (stateAfterDeadline?.status !== "auto_ended") {
-      stopSession("sid-starting-stall");
-      await vi.advanceTimersByTimeAsync(1_000);
-    }
-    await runPromise;
-
-    expect(stateAfterDeadline).toMatchObject({
-      status: "auto_ended",
-      finalReply: "",
-      autoEndedAt: expect.any(Number),
-    });
-    expect(closeCountAfterDeadline).toBe(1);
-    expect(treeKillCountAfterDeadline).toBeGreaterThanOrEqual(1);
-  });
-
-  it("self-heals a missing trigger-chat binding and gives automatic recovery the normal card lifecycle", async () => {
-    vi.setSystemTime(0);
-    _setResponseStallTimeoutForTest(100);
-    _setResponseStallCheckIntervalForTest(10);
-    _setProcessAliveForTest(() => true);
-
-    const platform = mockPlatform("feishu");
-    setSessionPlatform(platform);
-
-    const receivedPrompts: string[] = [];
-    const adapter: ToolAdapter = {
-      displayName: "Any Agent",
-      sessionDescPrefix: "Agent Session:",
-      createSession: async () => ({ sessionId: "sid-binding-recovery" }),
-      getSessionInfo: async (sid) => ({ sessionId: sid, cwd: "F:\\repo" }),
-      closeSession: async () => {},
-      prompt: async function* (
-        _sid: string,
-        text: string,
-        _cwd: string,
-        signal?: AbortSignal,
-        options?: ToolPromptOptions,
-      ) {
-        receivedPrompts.push(text);
-        options?.onProcessStart?.({ pid: 5000 + receivedPrompts.length });
-        if (receivedPrompts.length === 1) {
-          yield { type: "assistant", blocks: [{ type: "text", text: "" }] };
-          await new Promise<void>((resolve) => {
-            if (signal?.aborted) {
-              resolve();
-              return;
-            }
-            signal?.addEventListener("abort", () => resolve(), { once: true });
-          });
-          return;
-        }
-        yield {
-          type: "assistant",
-          blocks: [{ type: "text", text: "recovery completed" }],
-          isFinalResponse: true,
-        };
-      },
-    };
-    _setAdapterForToolForTest("claude", adapter);
-
-    const firstRun = runAgentSession(
-      "sid-binding-recovery",
-      "first prompt",
-      platform,
-      "chat-binding-recovery",
-      0,
-      "claude",
-    );
-
-    await vi.waitFor(() => {
-      expect(activePrompts.get("sid-binding-recovery")?.responseProgress).toBeDefined();
-    });
-    const progress = activePrompts.get("sid-binding-recovery")!.responseProgress!;
-    await vi.advanceTimersByTimeAsync(progress.unchangedSince + 101 - Date.now());
-    await firstRun;
-    await vi.advanceTimersByTimeAsync(200);
-    await vi.waitFor(() => expect(receivedPrompts).toHaveLength(2));
-    await vi.waitFor(() => expect(isSessionRunning("sid-binding-recovery")).toBe(false));
-
-    expect(getChatsForSession("sid-binding-recovery")).toContain("chat-binding-recovery");
-    expect(platform.cardCreate).toHaveBeenCalledTimes(2);
-    expect(platform.cardSend).toHaveBeenCalledTimes(2);
-    expect(platform.sendText).toHaveBeenCalledWith(
-      "chat-binding-recovery",
-      expect.stringContaining(recoveryPrompt),
-    );
-
-    const registry = JSON.parse(
-      await readFile(join(tempDir, "session-registry.json"), "utf8"),
-    ) as Record<string, { running?: boolean }>;
-    expect(registry["chat-binding-recovery"]?.running).toBe(false);
-  });
-
-  it("treats an authoritative final response that races timeout cleanup as completed", async () => {
-    vi.setSystemTime(0);
-    _setResponseStallTimeoutForTest(100);
-    _setResponseStallCheckIntervalForTest(10);
-    _setProcessAliveForTest(() => true);
-
-    const platform = mockPlatform("feishu");
-    setSessionPlatform(platform);
-    bindChatToSession("sid-final-race", "chat-final-race");
-    recordLastActiveChat("sid-final-race", "chat-final-race");
-
-    const receivedPrompts: string[] = [];
-    const adapter: ToolAdapter = {
-      displayName: "Any Agent",
-      sessionDescPrefix: "Agent Session:",
-      createSession: async () => ({ sessionId: "sid-final-race" }),
-      getSessionInfo: async (sid) => ({ sessionId: sid, cwd: "F:\\repo" }),
-      closeSession: async () => {},
-      prompt: async function* (
-        _sid: string,
-        text: string,
-        _cwd: string,
-        signal?: AbortSignal,
-        options?: ToolPromptOptions,
-      ) {
-        receivedPrompts.push(text);
-        options?.onProcessStart?.({ pid: 5151 });
-        yield { type: "assistant", blocks: [{ type: "text", text: "" }] };
-        await new Promise<void>((resolve) => {
-          if (signal?.aborted) {
-            resolve();
-            return;
-          }
-          signal?.addEventListener("abort", () => resolve(), { once: true });
-        });
-        yield {
-          type: "assistant",
-          blocks: [{ type: "text", text: "completed at the timeout boundary" }],
-          isFinalResponse: true,
-        };
-      },
-    };
-    _setAdapterForToolForTest("claude", adapter);
-
-    const run = runAgentSession(
-      "sid-final-race",
-      "prompt",
-      platform,
-      "chat-final-race",
-      0,
-      "claude",
-    );
-    await vi.waitFor(() => {
-      expect(activePrompts.get("sid-final-race")?.responseProgress).toBeDefined();
-    });
-    const progress = activePrompts.get("sid-final-race")!.responseProgress!;
-    await vi.advanceTimersByTimeAsync(progress.unchangedSince + 101 - Date.now());
-    await run;
-    await vi.advanceTimersByTimeAsync(1_000);
-
-    expect(receivedPrompts).toHaveLength(1);
-    expect(mockStreamStates.get("sid-final-race")).toMatchObject({
-      status: "done",
-      finalReply: "completed at the timeout boundary",
-    });
-    expect(platform.sendText).not.toHaveBeenCalledWith(
-      "chat-final-race",
-      RESPONSE_STALL_RECOVERY_EXHAUSTED_NOTICE,
-    );
-  });
-
-  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);
-    _setResponseStallCheckIntervalForTest(10);
-    _setProcessAliveForTest(() => true);
-
-    const platform = mockPlatform("feishu");
-    setSessionPlatform(platform);
-    bindChatToSession("sid-recovery-priority", "chat-recovery-priority");
-    recordLastActiveChat("sid-recovery-priority", "chat-recovery-priority");
-
-    const receivedPrompts: string[] = [];
-    const adapter: ToolAdapter = {
-      displayName: "Any Agent",
-      sessionDescPrefix: "Agent Session:",
-      createSession: async () => ({ sessionId: "sid-recovery-priority" }),
-      getSessionInfo: async (sid) => ({ sessionId: sid, cwd: "F:\\repo" }),
-      closeSession: async () => {},
-      prompt: async function* (
-        _sid: string,
-        text: string,
-        _cwd: string,
-        signal?: AbortSignal,
-        options?: ToolPromptOptions,
-      ) {
-        receivedPrompts.push(text);
-        options?.onProcessStart?.({ pid: 5252 + receivedPrompts.length });
-        if (receivedPrompts.length === 1) {
-          yield { type: "assistant", blocks: [{ type: "text", text: "" }] };
-          await new Promise<void>((resolve) => {
-            if (signal?.aborted) {
-              resolve();
-              return;
-            }
-            signal?.addEventListener("abort", () => resolve(), { once: true });
-          });
-          return;
-        }
-        yield { type: "assistant", blocks: [{ type: "text", text: "recovery completed" }] };
-      },
-    };
-    _setAdapterForToolForTest("claude", adapter);
-
-    enqueueMessage("sid-recovery-priority", {
-      text: "queued user prompt",
-      chatId: "chat-recovery-priority",
-      openId: "open-user",
-      msgTimestamp: 1,
-      chatType: "p2p",
-    });
-    const consumeQueued = vi.fn();
-    setQueueConsumer(consumeQueued);
-
-    const firstRun = runAgentSession(
-      "sid-recovery-priority",
-      "first prompt",
-      platform,
-      "chat-recovery-priority",
-      0,
-      "claude",
-    );
-
-    await vi.waitFor(() => {
-      expect(activePrompts.get("sid-recovery-priority")?.responseProgress).toBeDefined();
-    });
-    const firstProgress = activePrompts.get("sid-recovery-priority")!.responseProgress!;
-    await vi.advanceTimersByTimeAsync(firstProgress.unchangedSince + 101 - Date.now());
-    await firstRun;
-
-    expect(receivedPrompts).toHaveLength(1);
-    expect(consumeQueued).not.toHaveBeenCalled();
-    expect(isSessionRunning("sid-recovery-priority")).toBe(true);
-    expect(platform.sendText).toHaveBeenCalledWith(
-      "chat-recovery-priority",
-      expect.stringContaining(recoveryPrompt),
-    );
-
-    await vi.advanceTimersByTimeAsync(200);
-    await vi.waitFor(() => expect(receivedPrompts).toHaveLength(2));
-    expect(receivedPrompts[1]).toContain(recoveryPrompt);
-    expect(receivedPrompts[1]).not.toContain("queued user prompt");
-    expect(consumeQueued).not.toHaveBeenCalled();
-
-    await vi.advanceTimersByTimeAsync(200);
-    await vi.waitFor(() => expect(consumeQueued).toHaveBeenCalledTimes(1));
-    expect(consumeQueued).toHaveBeenCalledWith(
-      platform,
-      expect.objectContaining({ text: "queued user prompt" }),
-    );
-    setQueueConsumer(() => {});
-  });
-
-  it("does not auto-recover a second consecutive response stall", async () => {
-    vi.setSystemTime(0);
-    _setResponseStallTimeoutForTest(100);
-    _setResponseStallCheckIntervalForTest(10);
-    _setProcessAliveForTest(() => true);
-
-    const platform = mockPlatform("feishu");
-    setSessionPlatform(platform);
-    bindChatToSession("sid-recovery-limit", "chat-recovery-limit");
-    recordLastActiveChat("sid-recovery-limit", "chat-recovery-limit");
-
-    const receivedPrompts: string[] = [];
-    const adapter: ToolAdapter = {
-      displayName: "Any Agent",
-      sessionDescPrefix: "Agent Session:",
-      createSession: async () => ({ sessionId: "sid-recovery-limit" }),
-      getSessionInfo: async (sid) => ({ sessionId: sid, cwd: "F:\\repo" }),
-      closeSession: async () => {},
-      prompt: async function* (
-        _sid: string,
-        text: string,
-        _cwd: string,
-        signal?: AbortSignal,
-        options?: ToolPromptOptions,
-      ) {
-        receivedPrompts.push(text);
-        options?.onProcessStart?.({ pid: 6262 + receivedPrompts.length });
-        yield { type: "assistant", blocks: [{ type: "text", text: "" }] };
-        await new Promise<void>((resolve) => {
-          if (signal?.aborted) {
-            resolve();
-            return;
-          }
-          signal?.addEventListener("abort", () => resolve(), { once: true });
-        });
-      },
-    };
-    _setAdapterForToolForTest("claude", adapter);
-
-    const firstRun = runAgentSession(
-      "sid-recovery-limit",
-      "first prompt",
-      platform,
-      "chat-recovery-limit",
-      0,
-      "claude",
-    );
-    await vi.waitFor(() => {
-      expect(activePrompts.get("sid-recovery-limit")?.responseProgress).toBeDefined();
-    });
-    const firstProgress = activePrompts.get("sid-recovery-limit")!.responseProgress!;
-    await vi.advanceTimersByTimeAsync(firstProgress.unchangedSince + 101 - Date.now());
-    await firstRun;
-
-    await vi.advanceTimersByTimeAsync(200);
-    await vi.waitFor(() => expect(receivedPrompts).toHaveLength(2));
-    const recoveryProgress = activePrompts.get("sid-recovery-limit")!.responseProgress!;
-    await vi.advanceTimersByTimeAsync(recoveryProgress.unchangedSince + 101 - Date.now());
-    await vi.waitFor(() => expect(isSessionRunning("sid-recovery-limit")).toBe(false));
-
-    await vi.advanceTimersByTimeAsync(1_000);
-    expect(receivedPrompts).toHaveLength(2);
-    expect(receivedPrompts[1]).toContain(recoveryPrompt);
-    expect(platform.sendText).toHaveBeenCalledWith(
-      "chat-recovery-limit",
-      "⚠️ 自动续跑仍连续 3 分钟没有启动进展或新回复，本次不再自动继续。",
-    );
-  });
-
-  it("lets /stop cancel a reserved recovery before it starts", async () => {
-    vi.setSystemTime(0);
-    _setResponseStallTimeoutForTest(100);
-    _setResponseStallCheckIntervalForTest(10);
-    _setProcessAliveForTest(() => true);
-
-    const platform = mockPlatform("feishu");
-    setSessionPlatform(platform);
-    bindChatToSession("sid-recovery-stop", "chat-recovery-stop");
-    recordLastActiveChat("sid-recovery-stop", "chat-recovery-stop");
-
-    const receivedPrompts: string[] = [];
-    const adapter: ToolAdapter = {
-      displayName: "Any Agent",
-      sessionDescPrefix: "Agent Session:",
-      createSession: async () => ({ sessionId: "sid-recovery-stop" }),
-      getSessionInfo: async (sid) => ({ sessionId: sid, cwd: "F:\\repo" }),
-      closeSession: async () => {},
-      prompt: async function* (
-        _sid: string,
-        text: string,
-        _cwd: string,
-        signal?: AbortSignal,
-      ) {
-        receivedPrompts.push(text);
-        yield { type: "assistant", blocks: [{ type: "text", text: "" }] };
-        await new Promise<void>((resolve) => {
-          if (signal?.aborted) {
-            resolve();
-            return;
-          }
-          signal?.addEventListener("abort", () => resolve(), { once: true });
-        });
-      },
-    };
-    _setAdapterForToolForTest("claude", adapter);
-
-    const firstRun = runAgentSession(
-      "sid-recovery-stop",
-      "first prompt",
-      platform,
-      "chat-recovery-stop",
-      0,
-      "claude",
-    );
-    await vi.waitFor(() => {
-      expect(activePrompts.get("sid-recovery-stop")?.responseProgress).toBeDefined();
-    });
-    const progress = activePrompts.get("sid-recovery-stop")!.responseProgress!;
-    await vi.advanceTimersByTimeAsync(progress.unchangedSince + 101 - Date.now());
-    await firstRun;
-
-    expect(isSessionRunning("sid-recovery-stop")).toBe(true);
-    expect(stopSession("sid-recovery-stop")).toBe(true);
-    await vi.advanceTimersByTimeAsync(500);
-
-    expect(receivedPrompts).toHaveLength(1);
-    expect(isSessionRunning("sid-recovery-stop")).toBe(false);
-  });
-});
-
-describe("unified display loop WeChat delta", () => {
-  beforeEach(() => {
+describe("runAgentSession response stall watchdog", () => {
+  let tempDir = "";
+  const recoveryPrompt = RESPONSE_STALL_RECOVERY_PROMPT;
+
+  beforeEach(async () => {
     vi.useFakeTimers();
     resetState();
     resetBindingState();
     mockStreamStates.clear();
+    killProcessTreeMock.mockClear();
+    tempDir = await mkdtemp(join(tmpdir(), "chatccc-response-stall-"));
+    _setSessionRegistryFileForTest(join(tempDir, "session-registry.json"));
+    _setSessionToolsFileForTest(join(tempDir, "session-tools.json"));
   });
 
-  afterEach(() => {
-    stopUnifiedDisplayLoop();
+  afterEach(async () => {
+    _resetSessionRegistryFileForTest();
+    _resetSessionToolsFileForTest();
+    _clearAdapterCacheForTest();
+    _resetProcessAliveForTest();
+    _resetResponseStallTimeoutForTest();
+    _resetResponseStallCheckIntervalForTest();
+    _resetFinalResponseCloseTimeoutForTest();
     resetBindingState();
     vi.useRealTimers();
+    if (tempDir) await rm(tempDir, { recursive: true, force: true });
   });
 
-  it("sends only new accumulated content when tool output arrives before an already-sent final reply", async () => {
-    const platform = mockPlatform("wechat");
-    platform.kind = "wechat";
+  it("auto-ends every Agent after three minutes of unchanged reply characters, including zero", async () => {
+    vi.setSystemTime(0);
+    _setResponseStallTimeoutForTest(180_000);
+    _setResponseStallCheckIntervalForTest(1_000);
+    _setProcessAliveForTest(() => true);
+
+    const platform = mockPlatform("feishu");
     setSessionPlatform(platform);
+    bindChatToSession("sid-response-stall", "chat-response-stall");
+    recordLastActiveChat("sid-response-stall", "chat-response-stall");
 
-    bindChatToSession("sid-wechat", "chat-wechat");
-    recordLastActiveChat("sid-wechat", "chat-wechat");
-    sessionInfoMap.set("chat-wechat", {
-      sessionId: "sid-wechat",
-      turnCount: 1,
-      lastContextTokens: 0,
-      startTime: 0,
-      tool: "claude",
-    });
+    const closeSession = vi.fn();
+    const adapter: ToolAdapter = {
+      displayName: "Any Agent",
+      sessionDescPrefix: "Agent Session:",
+      createSession: async () => ({ sessionId: "sid-response-stall" }),
+      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: 4242 });
+        yield { type: "assistant", blocks: [{ type: "text", text: "" }] };
+        await new Promise<void>((resolve) => {
+          if (signal?.aborted) {
+            resolve();
+            return;
+          }
+          signal?.addEventListener("abort", () => resolve(), { once: true });
+        });
+      },
+    };
+    _setAdapterForToolForTest("claude", adapter);
 
-    // 模拟 runAgentSession 创建的 WeChat display 条目
-    displayCards.set("chat-wechat", {
-      cardId: "",
-      sequence: 0,
-      cardBusy: false,
-      cardCreatedAt: Date.now(),
-      lastSentContent: "",
-      streamErrorNotified: false,
-      sessionId: "sid-wechat",
-      turnCount: 1,
-      dotCount: 0,
-    });
+    const runPromise = runAgentSession(
+      "sid-response-stall",
+      "prompt",
+      platform,
+      "chat-response-stall",
+      Date.now(),
+      "claude",
+    );
 
-    mockStreamStates.set("sid-wechat", {
-      accumulatedContent: "",
-      finalReply: "partial reply",
-      status: "running",
+    await vi.waitFor(() => {
+      expect(activePrompts.get("sid-response-stall")?.responseProgress).toEqual({
+        totalChars: 0,
+        unchangedSince: expect.any(Number),
+      });
     });
-    startUnifiedDisplayLoop();
-    await vi.advanceTimersByTimeAsync(3000);
 
-    mockStreamStates.set("sid-wechat", {
-      accumulatedContent: "tool output\n",
-      finalReply: "partial reply",
-      status: "running",
-    });
-    await vi.advanceTimersByTimeAsync(3000);
+    const progress = activePrompts.get("sid-response-stall")!.responseProgress!;
+    const remainingBeforeBoundary = progress.unchangedSince + 180_000 - Date.now() - 1;
+    await vi.advanceTimersByTimeAsync(remainingBeforeBoundary);
+    expect(activePrompts.has("sid-response-stall")).toBe(true);
 
-    expect(platform.sendText).toHaveBeenNthCalledWith(
-      1,
-      "chat-wechat",
-      "partial reply",
-    );
-    expect(platform.sendText).toHaveBeenNthCalledWith(
-      2,
-      "chat-wechat",
-      "tool output",
-    );
-  });
-
-});
-
-describe("unified display loop activity status", () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-    vi.setSystemTime(new Date("2026-07-16T08:00:00.000Z"));
-    resetState();
-    resetBindingState();
-    mockStreamStates.clear();
-  });
-
-  afterEach(() => {
-    stopUnifiedDisplayLoop();
-    resetBindingState();
-    vi.useRealTimers();
-  });
-
-  it("renders explicit activity and elapsed time alongside the liveness dots", async () => {
-    const platform = mockPlatform("feishu");
-    setSessionPlatform(platform);
-
-    bindChatToSession("sid-activity", "chat-activity");
-    recordLastActiveChat("sid-activity", "chat-activity");
-    sessionInfoMap.set("chat-activity", {
-      sessionId: "sid-activity",
-      turnCount: 1,
-      lastContextTokens: 0,
-      startTime: Date.now() - 12_000,
-      tool: "codex",
-    });
-    displayCards.set("chat-activity", {
-      cardId: "card-activity",
-      sequence: 1,
-      cardBusy: false,
-      cardCreatedAt: Date.now(),
-      lastSentContent: "",
-      streamErrorNotified: false,
-      sessionId: "sid-activity",
-      turnCount: 1,
-      dotCount: 0,
-    });
-    mockStreamStates.set("sid-activity", {
-      accumulatedContent: "正在检查日志",
-      finalReply: "",
-      activity: {
-        kind: "tool",
-        startedAt: Date.now() - 12_000,
-        toolName: "Shell",
-        toolCount: 1,
-      },
-      status: "running",
-      turnCount: 1,
-    });
-
-    startUnifiedDisplayLoop();
-    await vi.advanceTimersByTimeAsync(3_000);
-
-    const payload = vi.mocked(platform.cardUpdate).mock.calls[0]?.[1];
-    expect(payload).toBeTypeOf("string");
-    const card = JSON.parse(payload as string) as {
-      header: { title: { content: string } };
-      body: { elements: Array<{ tag: string; content?: string }> };
-    };
-    expect(card.header.title.content).toBe("正在执行 Shell · 15秒");
-    expect(card.body.elements[0]?.content).toBe("正在检查日志\n。");
-  });
-});
-
-describe("unified display loop terminal card update", () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-    resetState();
-    resetBindingState();
-    mockStreamStates.clear();
+    await vi.advanceTimersByTimeAsync(1_001);
+    await runPromise;
+
+    expect(closeSession).toHaveBeenCalledTimes(1);
+    expect(killProcessTreeMock).toHaveBeenCalledWith(4242);
+    expect(activePrompts.has("sid-response-stall")).toBe(false);
+    expect(mockStreamStates.get("sid-response-stall")).toMatchObject({
+      status: "auto_ended",
+      finalReply: "",
+      autoEndedAt: expect.any(Number),
+    });
   });
 
-  afterEach(() => {
-    stopUnifiedDisplayLoop();
-    resetBindingState();
-    vi.useRealTimers();
-  });
-
-  it("shows a distinct auto-ended state and sends a warning even with an empty reply", async () => {
-    const platform = mockPlatform("feishu");
-    setSessionPlatform(platform);
-
-    bindChatToSession("sid-auto-ended", "chat-auto-ended");
-    recordLastActiveChat("sid-auto-ended", "chat-auto-ended");
-    sessionInfoMap.set("chat-auto-ended", {
-      sessionId: "sid-auto-ended",
-      turnCount: 1,
-      lastContextTokens: 0,
-      startTime: 0,
-      tool: "cursor",
-    });
-    displayCards.set("chat-auto-ended", {
-      cardId: "card-auto-ended",
-      sequence: 1,
-      cardBusy: false,
-      cardCreatedAt: Date.now(),
-      lastSentContent: "",
-      streamErrorNotified: false,
-      sessionId: "sid-auto-ended",
-      turnCount: 1,
-      dotCount: 0,
-    });
-    mockStreamStates.set("sid-auto-ended", {
-      accumulatedContent: "",
-      finalReply: "",
-      status: "auto_ended",
-      turnCount: 1,
-      autoEndedAt: Date.now(),
-    });
-
-    startUnifiedDisplayLoop();
-    await vi.advanceTimersByTimeAsync(3_000);
-
-    const payload = vi.mocked(platform.cardUpdate).mock.calls[0]?.[1];
-    const card = JSON.parse(payload as string) as {
-      header: { title: { content: string }; template?: string };
-    };
-    expect(card.header.title.content).toBe("已自动结束 · 3分钟无新内容");
-    expect(card.header.template).toBe("orange");
-    expect(platform.sendText).toHaveBeenCalledWith(
-      "chat-auto-ended",
-      "⚠️ 已自动结束：连续 3 分钟没有启动进展或回复字符变化。本轮没有可发送的回复内容。",
-    );
-    expect(displayCards.has("chat-auto-ended")).toBe(false);
-  });
-
-  it("does not repeat the same terminal CardKit sequence while the prompt is still active", async () => {
+  it("auto-ends an Agent that stays in starting state without emitting any event", async () => {
+    vi.setSystemTime(0);
+    _setResponseStallTimeoutForTest(180_000);
+    _setResponseStallCheckIntervalForTest(1_000);
+    _setProcessAliveForTest(() => true);
+
     const platform = mockPlatform("feishu");
-    platform.cardUpdate = vi.fn(async () => {
-      throw new Error("CardKit update: [300317] ErrMsg: sequence number compare failed; ");
-    });
     setSessionPlatform(platform);
+    bindChatToSession("sid-starting-stall", "chat-starting-stall");
+    recordLastActiveChat("sid-starting-stall", "chat-starting-stall");
 
-    bindChatToSession("sid-terminal", "chat-terminal");
-    recordLastActiveChat("sid-terminal", "chat-terminal");
-    sessionInfoMap.set("chat-terminal", {
-      sessionId: "sid-terminal",
-      turnCount: 1,
-      lastContextTokens: 0,
-      startTime: 0,
-      tool: "claude",
-    });
-    activePrompts.set("sid-terminal", {
-      controller: new AbortController(),
-      stopped: false,
-      startTime: Date.now(),
-    });
-    displayCards.set("chat-terminal", {
-      cardId: "card-terminal",
-      sequence: 109,
-      cardBusy: false,
-      cardCreatedAt: Date.now(),
-      lastSentContent: "",
-      streamErrorNotified: false,
-      sessionId: "sid-terminal",
-      turnCount: 1,
-      dotCount: 0,
-    });
-    mockStreamStates.set("sid-terminal", {
-      accumulatedContent: "partial tool output",
-      finalReply: "",
-      status: "stopped",
-      turnCount: 1,
+    const closeSession = vi.fn();
+    const adapter: ToolAdapter = {
+      displayName: "Silent Agent",
+      sessionDescPrefix: "Agent Session:",
+      createSession: async () => ({ sessionId: "sid-starting-stall" }),
+      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: 4343 });
+        await new Promise<void>((resolve) => {
+          if (signal?.aborted) {
+            resolve();
+            return;
+          }
+          signal?.addEventListener("abort", () => resolve(), { once: true });
+        });
+        if (false) yield { type: "assistant", blocks: [] };
+      },
+    };
+    _setAdapterForToolForTest("codex", adapter);
+
+    const runPromise = runAgentSession(
+      "sid-starting-stall",
+      "prompt",
+      platform,
+      "chat-starting-stall",
+      Date.now(),
+      "codex",
+    );
+
+    await vi.waitFor(() => {
+      expect(activePrompts.get("sid-starting-stall")).toMatchObject({
+        processPid: 4343,
+        responseProgress: {
+          totalChars: 0,
+          unchangedSince: expect.any(Number),
+        },
+      });
+      expect(closeSession).toHaveBeenCalledTimes(0);
     });
 
-    startUnifiedDisplayLoop();
-    await vi.advanceTimersByTimeAsync(3000);
-    await vi.advanceTimersByTimeAsync(3000);
+    await vi.advanceTimersByTimeAsync(181_001);
+    const stateAfterDeadline = mockStreamStates.get("sid-starting-stall");
+    const closeCountAfterDeadline = closeSession.mock.calls.length;
+    const treeKillCountAfterDeadline = killProcessTreeMock.mock.calls
+      .filter(([pid]) => pid === 4343)
+      .length;
+
+    // 旧实现不会结束真正的零事件启动；先清理测试会话，避免失败用例悬挂。
+    if (stateAfterDeadline?.status !== "auto_ended") {
+      stopSession("sid-starting-stall");
+      await vi.advanceTimersByTimeAsync(1_000);
+    }
+    await runPromise;
 
-    expect(platform.cardUpdate).toHaveBeenCalledTimes(1);
-    expect(platform.cardUpdate).toHaveBeenCalledWith(
-      "card-terminal",
-      expect.any(String),
-      110,
-    );
-    expect(displayCards.get("chat-terminal")?.sequence).toBe(110);
+    expect(stateAfterDeadline).toMatchObject({
+      status: "auto_ended",
+      finalReply: "",
+      autoEndedAt: expect.any(Number),
+    });
+    expect(closeCountAfterDeadline).toBe(1);
+    expect(treeKillCountAfterDeadline).toBeGreaterThanOrEqual(1);
   });
 
-  it("keeps terminal display and retries final text when sending fails", async () => {
+  it("self-heals a missing trigger-chat binding and gives automatic recovery the normal card lifecycle", async () => {
+    vi.setSystemTime(0);
+    _setResponseStallTimeoutForTest(100);
+    _setResponseStallCheckIntervalForTest(10);
+    _setProcessAliveForTest(() => true);
+
+    const platform = mockPlatform("feishu");
+    setSessionPlatform(platform);
+
+    const receivedPrompts: string[] = [];
+    const adapter: ToolAdapter = {
+      displayName: "Any Agent",
+      sessionDescPrefix: "Agent Session:",
+      createSession: async () => ({ sessionId: "sid-binding-recovery" }),
+      getSessionInfo: async (sid) => ({ sessionId: sid, cwd: "F:\\repo" }),
+      closeSession: async () => {},
+      prompt: async function* (
+        _sid: string,
+        text: string,
+        _cwd: string,
+        signal?: AbortSignal,
+        options?: ToolPromptOptions,
+      ) {
+        receivedPrompts.push(text);
+        options?.onProcessStart?.({ pid: 5000 + receivedPrompts.length });
+        if (receivedPrompts.length === 1) {
+          yield { type: "assistant", blocks: [{ type: "text", text: "" }] };
+          await new Promise<void>((resolve) => {
+            if (signal?.aborted) {
+              resolve();
+              return;
+            }
+            signal?.addEventListener("abort", () => resolve(), { once: true });
+          });
+          return;
+        }
+        yield {
+          type: "assistant",
+          blocks: [{ type: "text", text: "recovery completed" }],
+          isFinalResponse: true,
+        };
+      },
+    };
+    _setAdapterForToolForTest("claude", adapter);
+
+    const firstRun = runAgentSession(
+      "sid-binding-recovery",
+      "first prompt",
+      platform,
+      "chat-binding-recovery",
+      0,
+      "claude",
+    );
+
+    await vi.waitFor(() => {
+      expect(activePrompts.get("sid-binding-recovery")?.responseProgress).toBeDefined();
+    });
+    const progress = activePrompts.get("sid-binding-recovery")!.responseProgress!;
+    await vi.advanceTimersByTimeAsync(progress.unchangedSince + 101 - Date.now());
+    await firstRun;
+    await vi.advanceTimersByTimeAsync(200);
+    await vi.waitFor(() => expect(receivedPrompts).toHaveLength(2));
+    await vi.waitFor(() => expect(isSessionRunning("sid-binding-recovery")).toBe(false));
+
+    expect(getChatsForSession("sid-binding-recovery")).toContain("chat-binding-recovery");
+    expect(platform.cardCreate).toHaveBeenCalledTimes(2);
+    expect(platform.cardSend).toHaveBeenCalledTimes(2);
+    expect(platform.sendText).toHaveBeenCalledWith(
+      "chat-binding-recovery",
+      expect.stringContaining(recoveryPrompt),
+    );
+
+    const registry = JSON.parse(
+      await readFile(join(tempDir, "session-registry.json"), "utf8"),
+    ) as Record<string, { running?: boolean }>;
+    expect(registry["chat-binding-recovery"]?.running).toBe(false);
+  });
+
+  it("treats an authoritative final response that races timeout cleanup as completed", async () => {
+    vi.setSystemTime(0);
+    _setResponseStallTimeoutForTest(100);
+    _setResponseStallCheckIntervalForTest(10);
+    _setProcessAliveForTest(() => true);
+
+    const platform = mockPlatform("feishu");
+    setSessionPlatform(platform);
+    bindChatToSession("sid-final-race", "chat-final-race");
+    recordLastActiveChat("sid-final-race", "chat-final-race");
+
+    const receivedPrompts: string[] = [];
+    const adapter: ToolAdapter = {
+      displayName: "Any Agent",
+      sessionDescPrefix: "Agent Session:",
+      createSession: async () => ({ sessionId: "sid-final-race" }),
+      getSessionInfo: async (sid) => ({ sessionId: sid, cwd: "F:\\repo" }),
+      closeSession: async () => {},
+      prompt: async function* (
+        _sid: string,
+        text: string,
+        _cwd: string,
+        signal?: AbortSignal,
+        options?: ToolPromptOptions,
+      ) {
+        receivedPrompts.push(text);
+        options?.onProcessStart?.({ pid: 5151 });
+        yield { type: "assistant", blocks: [{ type: "text", text: "" }] };
+        await new Promise<void>((resolve) => {
+          if (signal?.aborted) {
+            resolve();
+            return;
+          }
+          signal?.addEventListener("abort", () => resolve(), { once: true });
+        });
+        yield {
+          type: "assistant",
+          blocks: [{ type: "text", text: "completed at the timeout boundary" }],
+          isFinalResponse: true,
+        };
+      },
+    };
+    _setAdapterForToolForTest("claude", adapter);
+
+    const run = runAgentSession(
+      "sid-final-race",
+      "prompt",
+      platform,
+      "chat-final-race",
+      0,
+      "claude",
+    );
+    await vi.waitFor(() => {
+      expect(activePrompts.get("sid-final-race")?.responseProgress).toBeDefined();
+    });
+    const progress = activePrompts.get("sid-final-race")!.responseProgress!;
+    await vi.advanceTimersByTimeAsync(progress.unchangedSince + 101 - Date.now());
+    await run;
+    await vi.advanceTimersByTimeAsync(1_000);
+
+    expect(receivedPrompts).toHaveLength(1);
+    expect(mockStreamStates.get("sid-final-race")).toMatchObject({
+      status: "done",
+      finalReply: "completed at the timeout boundary",
+    });
+    expect(platform.sendText).not.toHaveBeenCalledWith(
+      "chat-final-race",
+      RESPONSE_STALL_RECOVERY_EXHAUSTED_NOTICE,
+    );
+  });
+
+  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);
+    _setResponseStallCheckIntervalForTest(10);
+    _setProcessAliveForTest(() => true);
+
+    const platform = mockPlatform("feishu");
+    setSessionPlatform(platform);
+    bindChatToSession("sid-recovery-priority", "chat-recovery-priority");
+    recordLastActiveChat("sid-recovery-priority", "chat-recovery-priority");
+
+    const receivedPrompts: string[] = [];
+    const adapter: ToolAdapter = {
+      displayName: "Any Agent",
+      sessionDescPrefix: "Agent Session:",
+      createSession: async () => ({ sessionId: "sid-recovery-priority" }),
+      getSessionInfo: async (sid) => ({ sessionId: sid, cwd: "F:\\repo" }),
+      closeSession: async () => {},
+      prompt: async function* (
+        _sid: string,
+        text: string,
+        _cwd: string,
+        signal?: AbortSignal,
+        options?: ToolPromptOptions,
+      ) {
+        receivedPrompts.push(text);
+        options?.onProcessStart?.({ pid: 5252 + receivedPrompts.length });
+        if (receivedPrompts.length === 1) {
+          yield { type: "assistant", blocks: [{ type: "text", text: "" }] };
+          await new Promise<void>((resolve) => {
+            if (signal?.aborted) {
+              resolve();
+              return;
+            }
+            signal?.addEventListener("abort", () => resolve(), { once: true });
+          });
+          return;
+        }
+        yield { type: "assistant", blocks: [{ type: "text", text: "recovery completed" }] };
+      },
+    };
+    _setAdapterForToolForTest("claude", adapter);
+
+    enqueueMessage("sid-recovery-priority", {
+      text: "queued user prompt",
+      chatId: "chat-recovery-priority",
+      openId: "open-user",
+      msgTimestamp: 1,
+      chatType: "p2p",
+    });
+    const consumeQueued = vi.fn();
+    setQueueConsumer(consumeQueued);
+
+    const firstRun = runAgentSession(
+      "sid-recovery-priority",
+      "first prompt",
+      platform,
+      "chat-recovery-priority",
+      0,
+      "claude",
+    );
+
+    await vi.waitFor(() => {
+      expect(activePrompts.get("sid-recovery-priority")?.responseProgress).toBeDefined();
+    });
+    const firstProgress = activePrompts.get("sid-recovery-priority")!.responseProgress!;
+    await vi.advanceTimersByTimeAsync(firstProgress.unchangedSince + 101 - Date.now());
+    await firstRun;
+
+    expect(receivedPrompts).toHaveLength(1);
+    expect(consumeQueued).not.toHaveBeenCalled();
+    expect(isSessionRunning("sid-recovery-priority")).toBe(true);
+    expect(platform.sendText).toHaveBeenCalledWith(
+      "chat-recovery-priority",
+      expect.stringContaining(recoveryPrompt),
+    );
+
+    await vi.advanceTimersByTimeAsync(200);
+    await vi.waitFor(() => expect(receivedPrompts).toHaveLength(2));
+    expect(receivedPrompts[1]).toContain(recoveryPrompt);
+    expect(receivedPrompts[1]).not.toContain("queued user prompt");
+    expect(consumeQueued).not.toHaveBeenCalled();
+
+    await vi.advanceTimersByTimeAsync(200);
+    await vi.waitFor(() => expect(consumeQueued).toHaveBeenCalledTimes(1));
+    expect(consumeQueued).toHaveBeenCalledWith(
+      platform,
+      expect.objectContaining({ text: "queued user prompt" }),
+    );
+    setQueueConsumer(() => {});
+  });
+
+  it("does not auto-recover a second consecutive response stall", async () => {
+    vi.setSystemTime(0);
+    _setResponseStallTimeoutForTest(100);
+    _setResponseStallCheckIntervalForTest(10);
+    _setProcessAliveForTest(() => true);
+
+    const platform = mockPlatform("feishu");
+    setSessionPlatform(platform);
+    bindChatToSession("sid-recovery-limit", "chat-recovery-limit");
+    recordLastActiveChat("sid-recovery-limit", "chat-recovery-limit");
+
+    const receivedPrompts: string[] = [];
+    const adapter: ToolAdapter = {
+      displayName: "Any Agent",
+      sessionDescPrefix: "Agent Session:",
+      createSession: async () => ({ sessionId: "sid-recovery-limit" }),
+      getSessionInfo: async (sid) => ({ sessionId: sid, cwd: "F:\\repo" }),
+      closeSession: async () => {},
+      prompt: async function* (
+        _sid: string,
+        text: string,
+        _cwd: string,
+        signal?: AbortSignal,
+        options?: ToolPromptOptions,
+      ) {
+        receivedPrompts.push(text);
+        options?.onProcessStart?.({ pid: 6262 + receivedPrompts.length });
+        yield { type: "assistant", blocks: [{ type: "text", text: "" }] };
+        await new Promise<void>((resolve) => {
+          if (signal?.aborted) {
+            resolve();
+            return;
+          }
+          signal?.addEventListener("abort", () => resolve(), { once: true });
+        });
+      },
+    };
+    _setAdapterForToolForTest("claude", adapter);
+
+    const firstRun = runAgentSession(
+      "sid-recovery-limit",
+      "first prompt",
+      platform,
+      "chat-recovery-limit",
+      0,
+      "claude",
+    );
+    await vi.waitFor(() => {
+      expect(activePrompts.get("sid-recovery-limit")?.responseProgress).toBeDefined();
+    });
+    const firstProgress = activePrompts.get("sid-recovery-limit")!.responseProgress!;
+    await vi.advanceTimersByTimeAsync(firstProgress.unchangedSince + 101 - Date.now());
+    await firstRun;
+
+    await vi.advanceTimersByTimeAsync(200);
+    await vi.waitFor(() => expect(receivedPrompts).toHaveLength(2));
+    const recoveryProgress = activePrompts.get("sid-recovery-limit")!.responseProgress!;
+    await vi.advanceTimersByTimeAsync(recoveryProgress.unchangedSince + 101 - Date.now());
+    await vi.waitFor(() => expect(isSessionRunning("sid-recovery-limit")).toBe(false));
+
+    await vi.advanceTimersByTimeAsync(1_000);
+    expect(receivedPrompts).toHaveLength(2);
+    expect(receivedPrompts[1]).toContain(recoveryPrompt);
+    expect(platform.sendText).toHaveBeenCalledWith(
+      "chat-recovery-limit",
+      "⚠️ 自动续跑仍连续 3 分钟没有启动进展或新回复，本次不再自动继续。",
+    );
+  });
+
+  it("lets /stop cancel a reserved recovery before it starts", async () => {
+    vi.setSystemTime(0);
+    _setResponseStallTimeoutForTest(100);
+    _setResponseStallCheckIntervalForTest(10);
+    _setProcessAliveForTest(() => true);
+
+    const platform = mockPlatform("feishu");
+    setSessionPlatform(platform);
+    bindChatToSession("sid-recovery-stop", "chat-recovery-stop");
+    recordLastActiveChat("sid-recovery-stop", "chat-recovery-stop");
+
+    const receivedPrompts: string[] = [];
+    const adapter: ToolAdapter = {
+      displayName: "Any Agent",
+      sessionDescPrefix: "Agent Session:",
+      createSession: async () => ({ sessionId: "sid-recovery-stop" }),
+      getSessionInfo: async (sid) => ({ sessionId: sid, cwd: "F:\\repo" }),
+      closeSession: async () => {},
+      prompt: async function* (
+        _sid: string,
+        text: string,
+        _cwd: string,
+        signal?: AbortSignal,
+      ) {
+        receivedPrompts.push(text);
+        yield { type: "assistant", blocks: [{ type: "text", text: "" }] };
+        await new Promise<void>((resolve) => {
+          if (signal?.aborted) {
+            resolve();
+            return;
+          }
+          signal?.addEventListener("abort", () => resolve(), { once: true });
+        });
+      },
+    };
+    _setAdapterForToolForTest("claude", adapter);
+
+    const firstRun = runAgentSession(
+      "sid-recovery-stop",
+      "first prompt",
+      platform,
+      "chat-recovery-stop",
+      0,
+      "claude",
+    );
+    await vi.waitFor(() => {
+      expect(activePrompts.get("sid-recovery-stop")?.responseProgress).toBeDefined();
+    });
+    const progress = activePrompts.get("sid-recovery-stop")!.responseProgress!;
+    await vi.advanceTimersByTimeAsync(progress.unchangedSince + 101 - Date.now());
+    await firstRun;
+
+    expect(isSessionRunning("sid-recovery-stop")).toBe(true);
+    expect(stopSession("sid-recovery-stop")).toBe(true);
+    await vi.advanceTimersByTimeAsync(500);
+
+    expect(receivedPrompts).toHaveLength(1);
+    expect(isSessionRunning("sid-recovery-stop")).toBe(false);
+  });
+});
+
+describe("unified display loop WeChat delta", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    resetState();
+    resetBindingState();
+    mockStreamStates.clear();
+  });
+
+  afterEach(() => {
+    stopUnifiedDisplayLoop();
+    resetBindingState();
+    vi.useRealTimers();
+  });
+
+  it("sends only new accumulated content when tool output arrives before an already-sent final reply", async () => {
+    const platform = mockPlatform("wechat");
+    platform.kind = "wechat";
+    setSessionPlatform(platform);
+
+    bindChatToSession("sid-wechat", "chat-wechat");
+    recordLastActiveChat("sid-wechat", "chat-wechat");
+    sessionInfoMap.set("chat-wechat", {
+      sessionId: "sid-wechat",
+      turnCount: 1,
+      lastContextTokens: 0,
+      startTime: 0,
+      tool: "claude",
+    });
+
+    // 模拟 runAgentSession 创建的 WeChat display 条目
+    displayCards.set("chat-wechat", {
+      cardId: "",
+      sequence: 0,
+      cardBusy: false,
+      cardCreatedAt: Date.now(),
+      lastSentContent: "",
+      streamErrorNotified: false,
+      sessionId: "sid-wechat",
+      turnCount: 1,
+      dotCount: 0,
+    });
+
+    mockStreamStates.set("sid-wechat", {
+      accumulatedContent: "",
+      finalReply: "partial reply",
+      status: "running",
+    });
+    startUnifiedDisplayLoop();
+    await vi.advanceTimersByTimeAsync(3000);
+
+    mockStreamStates.set("sid-wechat", {
+      accumulatedContent: "tool output\n",
+      finalReply: "partial reply",
+      status: "running",
+    });
+    await vi.advanceTimersByTimeAsync(3000);
+
+    expect(platform.sendText).toHaveBeenNthCalledWith(
+      1,
+      "chat-wechat",
+      "partial reply",
+    );
+    expect(platform.sendText).toHaveBeenNthCalledWith(
+      2,
+      "chat-wechat",
+      "tool output",
+    );
+  });
+
+});
+
+describe("unified display loop activity status", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-07-16T08:00:00.000Z"));
+    resetState();
+    resetBindingState();
+    mockStreamStates.clear();
+  });
+
+  afterEach(() => {
+    stopUnifiedDisplayLoop();
+    resetBindingState();
+    vi.useRealTimers();
+  });
+
+  it("renders explicit activity and elapsed time alongside the liveness dots", async () => {
+    const platform = mockPlatform("feishu");
+    setSessionPlatform(platform);
+
+    bindChatToSession("sid-activity", "chat-activity");
+    recordLastActiveChat("sid-activity", "chat-activity");
+    sessionInfoMap.set("chat-activity", {
+      sessionId: "sid-activity",
+      turnCount: 1,
+      lastContextTokens: 0,
+      startTime: Date.now() - 12_000,
+      tool: "codex",
+    });
+    displayCards.set("chat-activity", {
+      cardId: "card-activity",
+      sequence: 1,
+      cardBusy: false,
+      cardCreatedAt: Date.now(),
+      lastSentContent: "",
+      streamErrorNotified: false,
+      sessionId: "sid-activity",
+      turnCount: 1,
+      dotCount: 0,
+    });
+    mockStreamStates.set("sid-activity", {
+      accumulatedContent: "正在检查日志",
+      finalReply: "",
+      activity: {
+        kind: "tool",
+        startedAt: Date.now() - 12_000,
+        toolName: "Shell",
+        toolCount: 1,
+      },
+      status: "running",
+      turnCount: 1,
+    });
+
+    startUnifiedDisplayLoop();
+    await vi.advanceTimersByTimeAsync(3_000);
+
+    const payload = vi.mocked(platform.cardUpdate).mock.calls[0]?.[1];
+    expect(payload).toBeTypeOf("string");
+    const card = JSON.parse(payload as string) as {
+      header: { title: { content: string } };
+      body: { elements: Array<{ tag: string; content?: string }> };
+    };
+    expect(card.header.title.content).toBe("正在执行 Shell · 15秒");
+    expect(card.body.elements[0]?.content).toBe("正在检查日志\n。");
+  });
+});
+
+describe("unified display loop terminal card update", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    resetState();
+    resetBindingState();
+    mockStreamStates.clear();
+  });
+
+  afterEach(() => {
+    stopUnifiedDisplayLoop();
+    resetBindingState();
+    vi.useRealTimers();
+  });
+
+  it("shows a distinct auto-ended state and sends a warning even with an empty reply", async () => {
+    const platform = mockPlatform("feishu");
+    setSessionPlatform(platform);
+
+    bindChatToSession("sid-auto-ended", "chat-auto-ended");
+    recordLastActiveChat("sid-auto-ended", "chat-auto-ended");
+    sessionInfoMap.set("chat-auto-ended", {
+      sessionId: "sid-auto-ended",
+      turnCount: 1,
+      lastContextTokens: 0,
+      startTime: 0,
+      tool: "cursor",
+    });
+    displayCards.set("chat-auto-ended", {
+      cardId: "card-auto-ended",
+      sequence: 1,
+      cardBusy: false,
+      cardCreatedAt: Date.now(),
+      lastSentContent: "",
+      streamErrorNotified: false,
+      sessionId: "sid-auto-ended",
+      turnCount: 1,
+      dotCount: 0,
+    });
+    mockStreamStates.set("sid-auto-ended", {
+      accumulatedContent: "",
+      finalReply: "",
+      status: "auto_ended",
+      turnCount: 1,
+      autoEndedAt: Date.now(),
+    });
+
+    startUnifiedDisplayLoop();
+    await vi.advanceTimersByTimeAsync(3_000);
+
+    const payload = vi.mocked(platform.cardUpdate).mock.calls[0]?.[1];
+    const card = JSON.parse(payload as string) as {
+      header: { title: { content: string }; template?: string };
+    };
+    expect(card.header.title.content).toBe("已自动结束 · 3分钟无新内容");
+    expect(card.header.template).toBe("orange");
+    expect(platform.sendText).toHaveBeenCalledWith(
+      "chat-auto-ended",
+      "⚠️ 已自动结束：连续 3 分钟没有启动进展或回复字符变化。本轮没有可发送的回复内容。",
+    );
+    expect(displayCards.has("chat-auto-ended")).toBe(false);
+  });
+
+  it("does not repeat the same terminal CardKit sequence while the prompt is still active", async () => {
+    const platform = mockPlatform("feishu");
+    platform.cardUpdate = vi.fn(async () => {
+      throw new Error("CardKit update: [300317] ErrMsg: sequence number compare failed; ");
+    });
+    setSessionPlatform(platform);
+
+    bindChatToSession("sid-terminal", "chat-terminal");
+    recordLastActiveChat("sid-terminal", "chat-terminal");
+    sessionInfoMap.set("chat-terminal", {
+      sessionId: "sid-terminal",
+      turnCount: 1,
+      lastContextTokens: 0,
+      startTime: 0,
+      tool: "claude",
+    });
+    activePrompts.set("sid-terminal", {
+      controller: new AbortController(),
+      stopped: false,
+      startTime: Date.now(),
+    });
+    displayCards.set("chat-terminal", {
+      cardId: "card-terminal",
+      sequence: 109,
+      cardBusy: false,
+      cardCreatedAt: Date.now(),
+      lastSentContent: "",
+      streamErrorNotified: false,
+      sessionId: "sid-terminal",
+      turnCount: 1,
+      dotCount: 0,
+    });
+    mockStreamStates.set("sid-terminal", {
+      accumulatedContent: "partial tool output",
+      finalReply: "",
+      status: "stopped",
+      turnCount: 1,
+    });
+
+    startUnifiedDisplayLoop();
+    await vi.advanceTimersByTimeAsync(3000);
+    await vi.advanceTimersByTimeAsync(3000);
+
+    expect(platform.cardUpdate).toHaveBeenCalledTimes(1);
+    expect(platform.cardUpdate).toHaveBeenCalledWith(
+      "card-terminal",
+      expect.any(String),
+      110,
+    );
+    expect(displayCards.get("chat-terminal")?.sequence).toBe(110);
+  });
+
+  it("keeps terminal display and retries final text when sending fails", async () => {
     vi.spyOn(console, "error").mockImplementation(() => {});
     const platform = mockPlatform("feishu");
     platform.cardUpdate = vi.fn(async () => {});
@@ -1876,17 +1878,25 @@ describe("getSessionStatus", () => {
     expect(status!.effort).not.toBeNull();
     // model 必为字符串（留空时显示 '(留空)'，否则为环境变量值）；不应是占位符
     expect(typeof status!.model).toBe("string");
-    expect(status!.model.length).toBeGreaterThan(0);
-  });
-
-  it("Codex session status uses the per-session effort override", async () => {
-    mockSessionInfo("chat-codex", { sessionId: "sid-codex-effort", tool: "codex" });
-    setSessionEffortOverride("sid-codex-effort", "xhigh");
-
-    const status = await getSessionStatus("chat-codex");
-
-    expect(status!.effort).toBe("xhigh");
-  });
+    expect(status!.model.length).toBeGreaterThan(0);
+  });
+
+  it("Codex session status uses the per-session effort override", async () => {
+    mockSessionInfo("chat-codex", { sessionId: "sid-codex-effort", tool: "codex" });
+    setSessionEffortOverride("sid-codex-effort", "xhigh");
+
+    const status = await getSessionStatus("chat-codex");
+
+    expect(status!.effort).toBe("xhigh");
+  });
+
+  it("CCC 会话：effort 默认取 config.ccc.effort，session override 优先", async () => {
+    expect(getEffectiveEffortForTool("ccc")).toBe(config.ccc.effort);
+    setSessionEffortOverride("sid-ccc-effort-default", "low");
+    expect(getEffectiveEffortForTool("ccc", "sid-ccc-effort-default")).toBe("low");
+    clearSessionEffortOverride("sid-ccc-effort-default");
+    expect(getEffectiveEffortForTool("ccc", "sid-ccc-effort-default")).toBe(config.ccc.effort);
+  });
 
   it("Cursor 会话：effort 恒为 null（卡片渲染时隐藏该行，避免显示无意义的 effort）", async () => {
     mockSessionInfo("chat-cursor", { sessionId: "sid-cur", tool: "cursor" });
@@ -1922,29 +1932,29 @@ describe("getSessionStatus", () => {
     expect(status!.model).toBe(UNKNOWN_MODEL_PLACEHOLDER);
   });
 
-  it("Cursor 会话：adapter.getSessionInfo 抛错时降级为占位符（不阻塞 /state）", async () => {
-    mockSessionInfo("chat-cursor", { sessionId: "sid-cur", tool: "cursor" });
-    _setAdapterForToolForTest(
-      "cursor",
-      mockAdapter(() => {
-        throw new Error("simulated adapter failure");
-      }),
-    );
-    const status = await getSessionStatus("chat-cursor");
-    expect(status!.model).toBe(UNKNOWN_MODEL_PLACEHOLDER);
-    expect(status!.effort).toBeNull();
-  });
-
-  it("CCC Agent 会话：model 来自 ccc 配置且 effort 恒为 null", async () => {
-    mockSessionInfo("chat-ccc", { sessionId: "session-ccc", tool: "ccc" });
-
-    const status = await getSessionStatus("chat-ccc");
-
-    expect(status!.model).toBeTruthy();
-    expect(status!.model).not.toBe(UNKNOWN_MODEL_PLACEHOLDER);
-    expect(status!.effort).toBeNull();
-  });
-});
+  it("Cursor 会话：adapter.getSessionInfo 抛错时降级为占位符（不阻塞 /state）", async () => {
+    mockSessionInfo("chat-cursor", { sessionId: "sid-cur", tool: "cursor" });
+    _setAdapterForToolForTest(
+      "cursor",
+      mockAdapter(() => {
+        throw new Error("simulated adapter failure");
+      }),
+    );
+    const status = await getSessionStatus("chat-cursor");
+    expect(status!.model).toBe(UNKNOWN_MODEL_PLACEHOLDER);
+    expect(status!.effort).toBeNull();
+  });
+
+  it("CCC Agent 会话：model 来自 ccc 配置且 effort 恒为 null", async () => {
+    mockSessionInfo("chat-ccc", { sessionId: "session-ccc", tool: "ccc" });
+
+    const status = await getSessionStatus("chat-ccc");
+
+    expect(status!.model).toBeTruthy();
+    expect(status!.model).not.toBe(UNKNOWN_MODEL_PLACEHOLDER);
+    expect(status!.effort).toBeNull();
+  });
+});
 
 describe("getAllSessionsStatus", () => {
   let registryFile = "";
@@ -1985,10 +1995,10 @@ describe("getAllSessionsStatus", () => {
 
   it("returns statuses from disk registry", async () => {
     await recordSessionRegistry({
-      chatId: "chat1",
-      sessionId: "s1",
-      tool: "claude",
-      chatType: "p2p",
+      chatId: "chat1",
+      sessionId: "s1",
+      tool: "claude",
+      chatType: "p2p",
       chatName: "test-chat-1",
       turnCount: 2,
       startTime: 1000,
@@ -2008,8 +2018,8 @@ describe("getAllSessionsStatus", () => {
 
     const result = await getAllSessionsStatus();
     expect(result).toHaveLength(2);
-    expect(result[0].chatId).toBe("chat1");
-    expect(result[0].chatType).toBe("p2p");
+    expect(result[0].chatId).toBe("chat1");
+    expect(result[0].chatType).toBe("p2p");
     // running=true in registry doesn't make it active — must be in activePrompts
     expect(result[0].active).toBe(false);
     expect(result[0].turnCount).toBe(2);