chatccc 0.2.205 → 0.2.207

package/README.md

@@ -318,7 +318,7 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
 | `gitTimeoutSeconds` | `/git` 命令超时时间，默认 180 秒 |
 | `allowInterrupt` | 是否允许新消息中断正在运行的任务；默认 false |
 | `*.enabled` | 是否启用对应 AI Agent |
-| `*.defaultAgent` | `/new` 未指定 Agent 时使用哪个工具 |
+| `*.defaultAgent` | `/new` 未指定 Agent 时使用哪个工具；飞书私聊会在下一条普通消息到达时跟随变化并创建新的空会话 |
 | `cursor.path` / `codex.path` | CLI 可执行文件路径；留空时自动探测或使用 PATH |
 | `cursor.avatarBatteryMode` | Cursor 头像电量显示来源：`apiPercent` 或 `onDemandUse` |
 | `cursor.onDemandMonthlyBudget` | `avatarBatteryMode=onDemandUse` 时用于计算电量的月预算 |
@@ -330,7 +330,7 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
 
 ### 5. 开始使用
 
-**飞书：** 找到机器人后直接发送普通消息，即可在当前私聊中创建并持续使用专属 AI 会话；私聊工作目录固定为运行 ChatCCC 的系统账号用户目录。需要独立任务时，发送 `/new`、`/new claude`、`/new cursor` 或 `/new codex`，机器人会另外创建会话群，原私聊会话不受影响。
+**飞书：** 找到机器人后直接发送普通消息，即可在当前私聊中创建并持续使用专属 AI 会话；私聊工作目录固定为运行 ChatCCC 的系统账号用户目录。默认 Agent 发生变化后，下一条私聊普通消息会触发切换并创建新的空会话；若旧 Agent 正在生成，该消息会先排队，待当前回复完成后再切换。命令不会触发自动切换。需要独立任务时，发送 `/new`、`/new claude`、`/new cursor` 或 `/new codex`，机器人会另外创建会话群。
 
 **微信：** 扫码登录后，在机器人私聊里发送 `/new` 或指定 Agent 的 `/new ...` 命令即可开始。功能与飞书基本一致，但展示为纯文本。
 

package/package.json

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

package/src/__tests__/cards.test.ts

@@ -435,12 +435,13 @@ describe("buildSessionsCard", () => {
     expect(parsed.elements[2].text.content).toContain("/session 数字");
   });
 
-  it("explains fixed Feishu private-session behavior without advertising switching", () => {
+  it("explains Feishu private-session default Agent following without advertising /session switching", () => {
     const card = buildSessionsCard([
       { sessionId: "abc123", chatName: "飞书私聊", chatId: "ou_private", active: false, turnCount: 2, elapsedSeconds: null, model: "Claude Opus 4.7", tool: "claude" },
     ], { fixedPrivateSession: true });
     const parsed = JSON.parse(card);
-    expect(parsed.elements[2].text.content).toContain("固定的专属会话");
+    expect(parsed.elements[2].text.content).toContain("下一条普通消息");
+    expect(parsed.elements[2].text.content).toContain("新空会话");
     expect(parsed.elements[2].text.content).toContain("不支持 **/session** 切换");
     expect(parsed.elements[2].text.content).not.toContain("/session 数字");
   });

package/src/__tests__/orchestrator.test.ts

@@ -87,7 +87,7 @@ import {
   resetState,
   sessionInfoMap,
 } from "../session.ts";
-import { activePrompts, resetBindingState } from "../session-chat-binding.ts";
+import { activePrompts, dequeueMessage, resetBindingState } from "../session-chat-binding.ts";
 import { ABD_APPEND_PROMPT } from "../shared-prefix.ts";
 import { config } from "../config.ts";
 
@@ -342,6 +342,148 @@ describe("handleCommand WeChat processing ack", () => {
     expect(registry["feishu-p2p"]?.sessionId).toBe("sid-feishu-private");
   });
 
+  it("switches an idle Feishu p2p chat to a fresh session when the default Agent changes", async () => {
+    const platform = mockPlatform("feishu");
+    const oldPrompt = vi.fn(async function* () {
+      yield { type: "assistant" as const, blocks: [{ type: "text" as const, text: "old" }] };
+    });
+    _setAdapterForToolForTest("claude", {
+      ...mockAdapter("sid-old-claude"),
+      prompt: oldPrompt,
+    });
+
+    const createCursorSession = vi.fn(async () => ({ sessionId: "sid-new-cursor" }));
+    const cursorPrompt = vi.fn(async function* () {
+      yield { type: "assistant" as const, blocks: [{ type: "text" as const, text: "new" }] };
+    });
+    _setAdapterForToolForTest("cursor", {
+      ...mockAdapter("sid-new-cursor"),
+      displayName: "Cursor",
+      sessionDescPrefix: "Cursor Session:",
+      createSession: createCursorSession,
+      prompt: cursorPrompt,
+      getSessionInfo: async (sessionId: string): Promise<SessionInfo> => ({ sessionId, cwd: homedir() }),
+    });
+    await recordSessionRegistry({
+      chatId: "feishu-p2p",
+      sessionId: "sid-old-claude",
+      tool: "claude",
+      chatType: "p2p",
+      chatName: "飞书私聊",
+      running: false,
+    });
+
+    const originalCursorEnabled = config.cursor.enabled;
+    try {
+      config.cursor.enabled = true;
+      config.claude.defaultAgent = false;
+      config.cursor.defaultAgent = true;
+
+      await handleCommand(platform, "/state", "feishu-p2p", "ou-user", Date.now(), "p2p");
+      expect(createCursorSession).not.toHaveBeenCalled();
+      expect((await loadSessionRegistryForBinding())["feishu-p2p"]?.sessionId).toBe("sid-old-claude");
+
+      await handleCommand(platform, "使用新的默认 Agent", "feishu-p2p", "ou-user", Date.now(), "p2p");
+
+      expect(createCursorSession).toHaveBeenCalledWith(homedir());
+      expect(oldPrompt).not.toHaveBeenCalled();
+      expect(cursorPrompt).toHaveBeenCalledWith(
+        "sid-new-cursor",
+        expect.stringContaining("使用新的默认 Agent"),
+        homedir(),
+        expect.any(AbortSignal),
+        expect.any(Object),
+      );
+      expect(platform.updateChatInfo).not.toHaveBeenCalled();
+      expect(platform.sendCard).toHaveBeenCalledWith(
+        "feishu-p2p",
+        "默认 Agent 已切换",
+        expect.stringContaining("Claude Code → Cursor"),
+        "green",
+      );
+
+      const registry = await loadSessionRegistryForBinding();
+      expect(registry["feishu-p2p"]).toMatchObject({
+        sessionId: "sid-new-cursor",
+        tool: "cursor",
+        chatType: "p2p",
+        turnCount: 1,
+      });
+    } finally {
+      config.cursor.enabled = originalCursorEnabled;
+    }
+  });
+
+  it("waits for a running Feishu p2p Agent before switching the queued message to the new default", async () => {
+    const platform = mockPlatform("feishu");
+    const createCursorSession = vi.fn(async () => ({ sessionId: "sid-cursor-after-wait" }));
+    const cursorPrompt = vi.fn(async function* () {
+      yield { type: "assistant" as const, blocks: [{ type: "text" as const, text: "new" }] };
+    });
+    _setAdapterForToolForTest("cursor", {
+      ...mockAdapter("sid-cursor-after-wait"),
+      displayName: "Cursor",
+      sessionDescPrefix: "Cursor Session:",
+      createSession: createCursorSession,
+      prompt: cursorPrompt,
+      getSessionInfo: async (sessionId: string): Promise<SessionInfo> => ({ sessionId, cwd: homedir() }),
+    });
+    await recordSessionRegistry({
+      chatId: "feishu-p2p-wait",
+      sessionId: "sid-running-claude",
+      tool: "claude",
+      chatType: "p2p",
+      chatName: "飞书私聊",
+      running: true,
+    });
+    activePrompts.set("sid-running-claude", {
+      controller: new AbortController(),
+      stopped: false,
+      startTime: Date.now(),
+    });
+
+    const originalCursorEnabled = config.cursor.enabled;
+    try {
+      config.cursor.enabled = true;
+      config.claude.defaultAgent = false;
+      config.cursor.defaultAgent = true;
+
+      await handleCommand(platform, "等当前回复完成后处理", "feishu-p2p-wait", "ou-user", Date.now(), "p2p");
+
+      expect(createCursorSession).not.toHaveBeenCalled();
+      const queued = dequeueMessage("sid-running-claude");
+      expect(queued?.text).toContain("等当前回复完成后处理");
+      expect(platform.sendCard).toHaveBeenCalledWith(
+        "feishu-p2p-wait",
+        "Agent 切换等待中",
+        expect.stringContaining("完成后会切换到 Cursor"),
+        "blue",
+      );
+
+      activePrompts.delete("sid-running-claude");
+      await handleCommand(
+        platform,
+        queued!.text,
+        queued!.chatId,
+        queued!.openId,
+        queued!.msgTimestamp,
+        queued!.chatType,
+        queued!.traceId,
+      );
+
+      expect(createCursorSession).toHaveBeenCalledTimes(1);
+      expect(cursorPrompt).toHaveBeenCalledWith(
+        "sid-cursor-after-wait",
+        expect.stringContaining("等当前回复完成后处理"),
+        homedir(),
+        expect.any(AbortSignal),
+        expect.any(Object),
+      );
+    } finally {
+      config.cursor.enabled = originalCursorEnabled;
+    }
+  });
+
   it("creates the first Feishu p2p session in the OS user directory and sends the first prompt in place", async () => {
     const platform = mockPlatform("feishu");
     const createSession = vi.fn(async () => ({ sessionId: "sid-feishu-private" }));
@@ -551,7 +693,7 @@ describe("handleCommand WeChat processing ack", () => {
     expect(platform.sendCard).toHaveBeenCalledWith(
       "feishu-p2p",
       "/session",
-      expect.stringContaining("飞书私聊使用固定的专属会话"),
+      expect.stringContaining("下一条普通消息时跟随默认 Agent"),
       "yellow",
     );
     expect(platform.updateChatInfo).not.toHaveBeenCalled();

package/src/__tests__/response-stall.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  hasResponseStalled,
+  observeResponseProgress,
+} from "../response-stall.ts";
+
+describe("response stall detection", () => {
+  it("starts tracking while responding even when the total character count is zero", () => {
+    const observation = observeResponseProgress(undefined, true, 0, 1_000);
+
+    expect(observation).toEqual({
+      totalChars: 0,
+      unchangedSince: 1_000,
+    });
+  });
+
+  it("auto-ends only after the same character count has lasted three minutes", () => {
+    const first = observeResponseProgress(undefined, true, 12, 1_000);
+    const unchanged = observeResponseProgress(first, true, 12, 90_000);
+
+    expect(unchanged).toBe(first);
+    expect(hasResponseStalled(unchanged, 180_999, 180_000)).toBe(false);
+    expect(hasResponseStalled(unchanged, 181_000, 180_000)).toBe(true);
+  });
+
+  it("restarts the timer whenever the total character count changes", () => {
+    const first = observeResponseProgress(undefined, true, 12, 1_000);
+    const changed = observeResponseProgress(first, true, 13, 150_000);
+
+    expect(changed).toEqual({
+      totalChars: 13,
+      unchangedSince: 150_000,
+    });
+    expect(hasResponseStalled(changed, 181_000, 180_000)).toBe(false);
+  });
+
+  it("clears tracking outside responding and starts a fresh window after returning", () => {
+    const first = observeResponseProgress(undefined, true, 0, 1_000);
+    const cleared = observeResponseProgress(first, false, 0, 100_000);
+    const resumed = observeResponseProgress(cleared, true, 0, 200_000);
+
+    expect(cleared).toBeUndefined();
+    expect(resumed).toEqual({
+      totalChars: 0,
+      unchangedSince: 200_000,
+    });
+  });
+});

package/src/__tests__/session.test.ts

@@ -1,19 +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";
-
-// mock stream-state 以支持在测试中控制累积长度
+import { dirname, join } from "node:path";
+
+const killProcessTreeMock = vi.hoisted(() => vi.fn(async () => {}));
+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" | "compacting";
+    kind: "starting" | "thinking" | "tool" | "processing" | "responding" | "searching" | "compacting";
     startedAt: number;
     toolName?: string;
     toolCount?: number;
   };
-  status?: "running" | "done" | "stopped" | "error";
+  status?: "running" | "done" | "stopped" | "error" | "auto_ended";
+  autoEndedAt?: number;
   turnCount?: number;
   finalReplySentTurn?: number;
   finalReplySentAt?: number;
@@ -27,8 +33,9 @@ vi.mock("../stream-state.ts", () => ({
       accumulatedContent: state.accumulatedContent,
       finalReply: state.finalReply,
       activity: state.activity,
-      finalReplySentTurn: state.finalReplySentTurn,
-      finalReplySentAt: state.finalReplySentAt,
+      finalReplySentTurn: state.finalReplySentTurn,
+      finalReplySentAt: state.finalReplySentAt,
+      autoEndedAt: state.autoEndedAt,
       status: state.status ?? "running",
       chunkCount: 0,
       turnCount: state.turnCount ?? 0,
@@ -43,12 +50,13 @@ vi.mock("../stream-state.ts", () => ({
     accumulatedContent: string;
     finalReply: string;
     activity?: {
-      kind: "starting" | "thinking" | "tool" | "processing" | "responding" | "compacting";
+      kind: "starting" | "thinking" | "tool" | "processing" | "responding" | "searching" | "compacting";
       startedAt: number;
       toolName?: string;
       toolCount?: number;
     };
-    status?: "running" | "done" | "stopped" | "error";
+    status?: "running" | "done" | "stopped" | "error" | "auto_ended";
+    autoEndedAt?: number;
     turnCount?: number;
     finalReplySentTurn?: number;
     finalReplySentAt?: number;
@@ -57,7 +65,8 @@ vi.mock("../stream-state.ts", () => ({
       accumulatedContent: state.accumulatedContent,
       finalReply: state.finalReply,
       activity: state.activity,
-      status: state.status,
+      status: state.status,
+      autoEndedAt: state.autoEndedAt,
       turnCount: state.turnCount,
       finalReplySentTurn: state.finalReplySentTurn,
       finalReplySentAt: state.finalReplySentAt,
@@ -109,6 +118,10 @@ import {
   _resetProcessAliveForTest,
   _setProcessMonitorIntervalForTest,
   _resetProcessMonitorIntervalForTest,
+  _setResponseStallTimeoutForTest,
+  _resetResponseStallTimeoutForTest,
+  _setResponseStallCheckIntervalForTest,
+  _resetResponseStallCheckIntervalForTest,
   setSessionEffortOverride,
 } from "../session.ts";
 import {
@@ -119,9 +132,12 @@ import {
   getLastActiveChat,
   pickDisplayChat,
   resetBindingState,
-  getChatsForSession,
-  displayCards,
-} 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";
@@ -349,13 +365,15 @@ describe("runAgentSession process monitor", () => {
     _resetSessionRegistryFileForTest();
     _resetSessionToolsFileForTest();
     _clearAdapterCacheForTest();
-    _resetProcessAliveForTest();
-    _resetProcessMonitorIntervalForTest();
+    _resetProcessAliveForTest();
+    _resetProcessMonitorIntervalForTest();
+    _resetResponseStallTimeoutForTest();
+    _resetResponseStallCheckIntervalForTest();
     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");
@@ -450,7 +468,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()
@@ -483,10 +501,77 @@ describe("runAgentSession process monitor", () => {
       "生成中卡片发送失败，结果将以文本形式发送。",
     );
     expect(platform.sendText).toHaveBeenCalledWith("chat-card-fallback", "final answer");
-    expect(mockStreamStates.get("sid-card-fallback")?.finalReplySentTurn).toBe(1);
-  });
-
-  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");
@@ -583,8 +668,108 @@ describe("runAgentSession process monitor", () => {
   });
 });
 
+describe("runAgentSession response stall watchdog", () => {
+  let tempDir = "";
+
+  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();
+    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),
+    });
+  });
+});
+
 describe("unified display loop WeChat delta", () => {
-  beforeEach(() => {
+  beforeEach(() => {
     vi.useFakeTimers();
     resetState();
     resetBindingState();
@@ -651,6 +836,7 @@ describe("unified display loop WeChat delta", () => {
       "tool output",
     );
   });
+
 });
 
 describe("unified display loop activity status", () => {
@@ -727,13 +913,61 @@ describe("unified display loop terminal card update", () => {
     mockStreamStates.clear();
   });
 
-  afterEach(() => {
+  afterEach(() => {
     stopUnifiedDisplayLoop();
     resetBindingState();
-    vi.useRealTimers();
-  });
-
-  it("does not repeat the same terminal CardKit sequence while the prompt is still active", async () => {
+    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; ");

package/src/cards.ts

@@ -344,7 +344,7 @@ export function buildSessionsCard(sessions: Array<{
       header: { template: "blue", title: { content: "所有会话", tag: "plain_text" } },
       elements: [
         { tag: "div", text: { tag: "lark_md", content: fixedPrivateSession
-          ? `当前没有会话记录。\n\n直接发送普通消息即可创建飞书私聊专属 ${defaultToolLabel} 会话；发送 **/new**、**/new claude**、**/new cursor** 或 **/new codex** 会另外创建会话群。`
+          ? `当前没有会话记录。\n\n直接发送普通消息即可创建飞书私聊专属 ${defaultToolLabel} 会话；默认 Agent 变化后，下一条普通消息会创建对应 Agent 的新空会话。发送 **/new**、**/new claude**、**/new cursor** 或 **/new codex** 会另外创建会话群。`
           : `当前没有会话记录。\n\n使用 **/new**（默认 ${defaultToolLabel}）、**/new claude**、**/new cursor** 或 **/new codex** 创建新会话。\n创建后可在任意会话群内发送 **/sessions** 查看列表，用 **/session 数字** 切换会话。` } },
         { tag: "hr" },
         { tag: "action", actions: [{ tag: "button", text: { tag: "plain_text", content: "收起" }, type: "default", value: { action: "close" } }] },
@@ -387,7 +387,7 @@ export function buildSessionsCard(sessions: Array<{
       { tag: "div", text: { tag: "lark_md", content: lines.join("\n") } },
       { tag: "hr" },
       { tag: "div", text: { tag: "lark_md", content: fixedPrivateSession
-        ? "当前飞书私聊使用固定的专属会话；发送 **/newh** 可在私聊中原地重置。群聊会话请回到对应群聊继续，私聊不支持 **/session** 切换。"
+        ? "当前飞书私聊使用专属会话；默认 Agent 变化后，下一条普通消息会自动创建对应 Agent 的新空会话。发送 **/newh** 可在私聊中原地重置。群聊会话请回到对应群聊继续，私聊不支持 **/session** 切换。"
         : "在会话群内发送 **/newh** 可重置当前会话（创建新 Session，保留工作目录和群聊）。\n发送 **/session 数字**（如 `/session 1`）可将当前群聊切换到列表中对应编号的会话。" } },
       { tag: "hr" },
       {