chatccc 0.2.211 → 0.2.213

package/README.md

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

package/package.json

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

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

@@ -52,6 +52,7 @@ describe("normalizeSdkMessage", () => {
     expect(result).not.toBeNull();
     expect(result!.type).toBe("assistant");
     expect(result!.blocks).toEqual([{ type: "text", text: "Hello world" }]);
+    expect(result!.isFinalResponse).toBeUndefined();
   });
 
   it("normalizes assistant message with thinking block", () => {
@@ -378,6 +379,20 @@ describe("createClaudeAdapter", () => {
     await expect(adapter.closeSession("any-sid")).resolves.toBeUndefined();
   });
 
+  it("does not start SDK session creation when the startup signal is already aborted", async () => {
+    const adapter = createClaudeAdapter({
+      model: "claude-sonnet-4-6",
+      effort: "high",
+      isEmpty: () => false,
+    });
+    const controller = new AbortController();
+    controller.abort();
+
+    await expect(
+      adapter.createSession("F:\\repo", controller.signal),
+    ).rejects.toThrow("Claude session creation aborted");
+  });
+
   // -------------------------------------------------------------------------
   // getSessionInfo 行为契约
   //   - cwd 决定 /git 是否可用

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

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

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

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

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

@@ -347,19 +347,32 @@ describe("normalizeCursorMessage", () => {
 // createCursorAdapter — 工厂函数测试
 // ---------------------------------------------------------------------------
 
-describe("createCursorAdapter", () => {
+describe("createCursorAdapter", () => {
   it("returns adapter with correct displayName and sessionDescPrefix", () => {
     const adapter = createCursorAdapter();
     expect(adapter.displayName).toBe("Cursor");
     expect(adapter.sessionDescPrefix).toBe("Cursor Session:");
   });
 
-  it("closeSession does not throw", async () => {
-    const adapter = createCursorAdapter();
-    await expect(adapter.closeSession("any-id")).resolves.toBeUndefined();
-  });
-
-  // -------------------------------------------------------------------------
+  it("closeSession does not throw", async () => {
+    const adapter = createCursorAdapter();
+    await expect(adapter.closeSession("any-id")).resolves.toBeUndefined();
+  });
+
+  it("aborts a zero-output createSession stream instead of leaving Cursor Agent alive", async () => {
+    const store = createInMemoryMetaStore();
+    const spawnImpl = (() =>
+      createHangingMockCursorProcess({})) as CursorSpawnForTest;
+    const adapter = createCursorAdapter({ metaStore: store, spawn: spawnImpl });
+    const controller = new AbortController();
+
+    const pending = adapter.createSession("F:/repo", controller.signal);
+    controller.abort();
+
+    await expect(pending).rejects.toThrow("Cursor session creation aborted");
+  });
+
+  // -------------------------------------------------------------------------
   // getSessionInfo 行为契约
   //   - cwd 决定 /git 是否可用
   //   - model 决定 /state、/sessions 显示的是否是 Cursor 真实模型
@@ -445,9 +458,10 @@ describe("normalizeCursorMessage - 三类 assistant 事件区分", () => {
       type: "assistant",
       message: { role: "assistant", content: [{ type: "text", text: "你" }] },
       timestamp_ms: 1778411927583,
-    });
-    expect(result).not.toBeNull();
-    expect(result!.blocks).toEqual([{ type: "text", text: "你" }]);
+    });
+    expect(result).not.toBeNull();
+    expect(result!.blocks).toEqual([{ type: "text", text: "你" }]);
+    expect(result!.isFinalResponse).toBeUndefined();
   });
 
   it("Buffered flush（has timestamp_ms, has model_call_id）→ text_final（覆盖，避免与 delta 重复累加）", () => {
@@ -461,9 +475,10 @@ describe("normalizeCursorMessage - 三类 assistant 事件区分", () => {
       model_call_id: "mc-1",
     } as Parameters<typeof normalizeCursorMessage>[0]);
     expect(result).not.toBeNull();
-    expect(result!.blocks).toEqual([
-      { type: "text_final", text: "完整快照（与 delta 累计相同）" },
-    ]);
+    expect(result!.blocks).toEqual([
+      { type: "text_final", text: "完整快照（与 delta 累计相同）" },
+    ]);
+    expect(result!.isFinalResponse).toBeUndefined();
   });
 
   it("Final flush（no timestamp_ms）→ text_final（覆盖）", () => {
@@ -475,9 +490,10 @@ describe("normalizeCursorMessage - 三类 assistant 事件区分", () => {
       },
     });
     expect(result).not.toBeNull();
-    expect(result!.blocks).toEqual([
-      { type: "text_final", text: "你上一题问的是 1+2=?" },
-    ]);
+    expect(result!.blocks).toEqual([
+      { type: "text_final", text: "你上一题问的是 1+2=?" },
+    ]);
+    expect(result!.isFinalResponse).toBeUndefined();
   });
 });
 

package/src/__tests__/orchestrator.test.ts

@@ -427,7 +427,7 @@ describe("handleCommand WeChat processing ack", () => {
 
       await handleCommand(platform, "使用新的默认 Agent", "feishu-p2p", "ou-user", Date.now(), "p2p");
 
-      expect(createCursorSession).toHaveBeenCalledWith(homedir());
+      expect(createCursorSession).toHaveBeenCalledWith(homedir(), expect.any(AbortSignal));
       expect(oldPrompt).not.toHaveBeenCalled();
       expect(cursorPrompt).toHaveBeenCalledWith(
         "sid-new-cursor",
@@ -549,7 +549,7 @@ describe("handleCommand WeChat processing ack", () => {
 
     await handleCommand(platform, "帮我看一下日志", "feishu-p2p", "ou-user", Date.now(), "p2p");
 
-    expect(createSession).toHaveBeenCalledWith(homedir());
+    expect(createSession).toHaveBeenCalledWith(homedir(), expect.any(AbortSignal));
     expect(platform.createGroup).not.toHaveBeenCalled();
     expect(platform.updateChatInfo).not.toHaveBeenCalled();
     expect(prompt).toHaveBeenCalledWith(
@@ -596,7 +596,7 @@ describe("handleCommand WeChat processing ack", () => {
 
     await handleCommand(platform, "继续", "feishu-p2p", "ou-user", Date.now(), "p2p");
 
-    expect(createSession).toHaveBeenCalledWith(homedir());
+    expect(createSession).toHaveBeenCalledWith(homedir(), expect.any(AbortSignal));
     expect(prompt).toHaveBeenCalledWith(
       "sid-feishu-migrated",
       expect.stringContaining("继续"),
@@ -633,7 +633,7 @@ describe("handleCommand WeChat processing ack", () => {
 
     await handleCommand(platform, "/abd帮我看一下日志", "feishu-p2p", "ou-user", Date.now(), "p2p");
 
-    expect(createSession).toHaveBeenCalledWith(homedir());
+    expect(createSession).toHaveBeenCalledWith(homedir(), expect.any(AbortSignal));
     expect(platform.createGroup).not.toHaveBeenCalled();
     expect(platform.updateChatInfo).not.toHaveBeenCalled();
     const userText = prompt.mock.calls[0][1];
@@ -706,7 +706,7 @@ describe("handleCommand WeChat processing ack", () => {
 
     await handleCommand(platform, "/newh", "feishu-p2p", "ou-user", Date.now(), "p2p");
 
-    expect(createSession).toHaveBeenCalledWith(homedir());
+    expect(createSession).toHaveBeenCalledWith(homedir(), expect.any(AbortSignal));
     expect(platform.createGroup).not.toHaveBeenCalled();
     expect(platform.updateChatInfo).not.toHaveBeenCalled();
     const registry = await loadSessionRegistryForBinding();

package/src/__tests__/session.test.ts

@@ -3,7 +3,7 @@ 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 () => {}));
+const killProcessTreeMock = vi.hoisted(() => vi.fn(async (_pid?: number) => {}));
 vi.mock("../adapters/proc-tree-kill.ts", () => ({
   killProcessTree: killProcessTreeMock,
 }));
@@ -109,8 +109,9 @@ import {
   _clearAdapterCacheForTest,
   setSessionPlatform,
   recordChatPlatform,
-  _getPlatformForChatForTest,
-  runAgentSession,
+  _getPlatformForChatForTest,
+  initClaudeSession,
+  runAgentSession,
   stopSession,
   startUnifiedDisplayLoop,
   stopUnifiedDisplayLoop,
@@ -122,6 +123,8 @@ import {
   _resetResponseStallTimeoutForTest,
   _setResponseStallCheckIntervalForTest,
   _resetResponseStallCheckIntervalForTest,
+  _setFinalResponseCloseTimeoutForTest,
+  _resetFinalResponseCloseTimeoutForTest,
   setSessionEffortOverride,
   RESPONSE_STALL_RECOVERY_PROMPT,
   RESPONSE_STALL_RECOVERY_EXHAUSTED_NOTICE,
@@ -224,7 +227,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,
@@ -243,9 +246,58 @@ describe("resetState", () => {
     expect(sessionInfoMap.size).toBe(0);
     expect(processedMessages.size).toBe(0);
   });
-});
-
-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();
   });
@@ -371,6 +423,7 @@ describe("runAgentSession process monitor", () => {
     _resetProcessMonitorIntervalForTest();
     _resetResponseStallTimeoutForTest();
     _resetResponseStallCheckIntervalForTest();
+    _resetFinalResponseCloseTimeoutForTest();
     resetBindingState();
     vi.useRealTimers();
   });
@@ -692,6 +745,7 @@ describe("runAgentSession response stall watchdog", () => {
     _resetProcessAliveForTest();
     _resetResponseStallTimeoutForTest();
     _resetResponseStallCheckIntervalForTest();
+    _resetFinalResponseCloseTimeoutForTest();
     resetBindingState();
     vi.useRealTimers();
     if (tempDir) await rm(tempDir, { recursive: true, force: true });
@@ -770,6 +824,88 @@ describe("runAgentSession response stall watchdog", () => {
     });
   });
 
+  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);
@@ -919,6 +1055,141 @@ describe("runAgentSession response stall watchdog", () => {
     );
   });
 
+  it("force-closes a stream that stays open after an authoritative final event without auto-recovery", async () => {
+    vi.setSystemTime(0);
+    _setResponseStallTimeoutForTest(100);
+    _setResponseStallCheckIntervalForTest(10);
+    _setFinalResponseCloseTimeoutForTest(1_000);
+    _setProcessAliveForTest(() => true);
+
+    const platform = mockPlatform("feishu");
+    setSessionPlatform(platform);
+    bindChatToSession("sid-final-close", "chat-final-close");
+    recordLastActiveChat("sid-final-close", "chat-final-close");
+
+    const closeSession = vi.fn();
+    const adapter: ToolAdapter = {
+      displayName: "Any Agent",
+      sessionDescPrefix: "Agent Session:",
+      createSession: async () => ({ sessionId: "sid-final-close" }),
+      getSessionInfo: async (sid) => ({ sessionId: sid, cwd: "F:\\repo" }),
+      closeSession: async () => {},
+      prompt: async function* (
+        _sid: string,
+        _text: string,
+        _cwd: string,
+        signal?: AbortSignal,
+        options?: ToolPromptOptions,
+      ) {
+        options?.onSessionCreated?.(closeSession);
+        options?.onProcessStart?.({ pid: 7171 });
+        yield {
+          type: "assistant",
+          blocks: [{ type: "text", text: "authoritative answer" }],
+        };
+        yield {
+          type: "assistant",
+          blocks: [],
+          isFinalResponse: true,
+        };
+        await new Promise<void>((resolve) => {
+          if (signal?.aborted) {
+            resolve();
+            return;
+          }
+          signal?.addEventListener("abort", () => resolve(), { once: true });
+        });
+      },
+    };
+    _setAdapterForToolForTest("claude", adapter);
+
+    const run = runAgentSession(
+      "sid-final-close",
+      "prompt",
+      platform,
+      "chat-final-close",
+      0,
+      "claude",
+    );
+
+    await vi.waitFor(() => {
+      expect(activePrompts.get("sid-final-close")?.finalResponseObserved).toBe(true);
+    });
+    await vi.advanceTimersByTimeAsync(900);
+    expect(activePrompts.has("sid-final-close")).toBe(true);
+
+    await vi.advanceTimersByTimeAsync(100);
+    await run;
+
+    expect(closeSession).toHaveBeenCalledTimes(1);
+    expect(killProcessTreeMock).toHaveBeenCalledWith(7171);
+    expect(mockStreamStates.get("sid-final-close")).toMatchObject({
+      status: "done",
+      finalReply: "authoritative answer",
+    });
+    expect(platform.sendText).not.toHaveBeenCalledWith(
+      "chat-final-close",
+      expect.stringContaining(RESPONSE_STALL_RECOVERY_PROMPT),
+    );
+  });
+
+  it("cancels the final-response close guard when the stream exits normally", async () => {
+    vi.setSystemTime(0);
+    _setFinalResponseCloseTimeoutForTest(1_000);
+    _setProcessAliveForTest(() => true);
+
+    const platform = mockPlatform("feishu");
+    setSessionPlatform(platform);
+    bindChatToSession("sid-final-normal", "chat-final-normal");
+    recordLastActiveChat("sid-final-normal", "chat-final-normal");
+
+    const closeSession = vi.fn();
+    const adapter: ToolAdapter = {
+      displayName: "Any Agent",
+      sessionDescPrefix: "Agent Session:",
+      createSession: async () => ({ sessionId: "sid-final-normal" }),
+      getSessionInfo: async (sid) => ({ sessionId: sid, cwd: "F:\\repo" }),
+      closeSession: async () => {},
+      prompt: async function* (
+        _sid: string,
+        _text: string,
+        _cwd: string,
+        _signal?: AbortSignal,
+        options?: ToolPromptOptions,
+      ) {
+        options?.onSessionCreated?.(closeSession);
+        options?.onProcessStart?.({ pid: 7272 });
+        yield {
+          type: "assistant",
+          blocks: [{ type: "text", text: "normal answer" }],
+        };
+        yield {
+          type: "assistant",
+          blocks: [],
+          isFinalResponse: true,
+        };
+      },
+    };
+    _setAdapterForToolForTest("claude", adapter);
+
+    await runAgentSession(
+      "sid-final-normal",
+      "prompt",
+      platform,
+      "chat-final-normal",
+      0,
+      "claude",
+    );
+    await vi.advanceTimersByTimeAsync(2_000);
+
+    expect(closeSession).not.toHaveBeenCalled();
+    expect(killProcessTreeMock).not.toHaveBeenCalled();
+    expect(mockStreamStates.get("sid-final-normal")).toMatchObject({
+      status: "done",
+      finalReply: "normal answer",
+    });
+  });
+
   it("runs the reserved recovery prompt before an already queued user message", async () => {
     vi.setSystemTime(0);
     _setResponseStallTimeoutForTest(100);
@@ -1076,7 +1347,7 @@ describe("runAgentSession response stall watchdog", () => {
     expect(receivedPrompts[1]).toContain(recoveryPrompt);
     expect(platform.sendText).toHaveBeenCalledWith(
       "chat-recovery-limit",
-      "⚠️ 自动续跑仍连续 3 分钟没有新回复，本次不再自动继续。",
+      "⚠️ 自动续跑仍连续 3 分钟没有启动进展或新回复，本次不再自动继续。",
     );
   });
 
@@ -1335,7 +1606,7 @@ describe("unified display loop terminal card update", () => {
     expect(card.header.template).toBe("orange");
     expect(platform.sendText).toHaveBeenCalledWith(
       "chat-auto-ended",
-      "⚠️ 已自动结束：连续 3 分钟处于“正在生成回复”且回复字符总数没有变化。本轮没有可发送的回复内容。",
+      "⚠️ 已自动结束：连续 3 分钟没有启动进展或回复字符变化。本轮没有可发送的回复内容。",
     );
     expect(displayCards.has("chat-auto-ended")).toBe(false);
   });

package/src/__tests__/stop-session.test.ts

@@ -11,10 +11,15 @@ import { describe, it, expect, vi, beforeEach } from "vitest";
 import type { StreamState } from "../stream-state.ts";
 
 // mock stream-state，使用模块内可观测的 Map 记录读写
-const stateStore = new Map<string, StreamState>();
-const writeCalls: StreamState[] = [];
-
-vi.mock("../stream-state.ts", () => ({
+const stateStore = new Map<string, StreamState>();
+const writeCalls: StreamState[] = [];
+const killProcessTreeMock = vi.hoisted(() => vi.fn(async (_pid?: number) => {}));
+
+vi.mock("../adapters/proc-tree-kill.ts", () => ({
+  killProcessTree: killProcessTreeMock,
+}));
+
+vi.mock("../stream-state.ts", () => ({
   readStreamState: async (sid: string): Promise<StreamState | null> => {
     return stateStore.get(sid) ?? null;
   },
@@ -72,9 +77,10 @@ async function flush(): Promise<void> {
 }
 
 beforeEach(() => {
-  activePrompts.clear();
-  stateStore.clear();
-  writeCalls.length = 0;
+  activePrompts.clear();
+  stateStore.clear();
+  writeCalls.length = 0;
+  killProcessTreeMock.mockClear();
 });
 
 describe("stopSession 行为护栏", () => {
@@ -128,13 +134,29 @@ describe("stopSession 行为护栏", () => {
     expect(activePrompts.get("sid-C")?.stopped).toBe(true);
   });
 
-  it("调用 adapter 提供的 closeSession 以主动关闭底层 SDK session", () => {
+  it("调用 adapter 提供的 closeSession 以主动关闭底层 SDK session", () => {
     const closeSession = vi.fn();
     seedRunningSession("sid-D", "partial output", closeSession);
 
     const ok = stopSession("sid-D");
 
-    expect(ok).toBe(true);
-    expect(closeSession).toHaveBeenCalledTimes(1);
-  });
-});
+    expect(ok).toBe(true);
+    expect(closeSession).toHaveBeenCalledTimes(1);
+  });
+
+  it("按完整进程树停止 CLI，不先杀壳进程造成后代进程逃逸", async () => {
+    seedRunningSession("sid-tree");
+    activePrompts.get("sid-tree")!.processPid = 4242;
+    const processKillSpy = vi.spyOn(process, "kill").mockImplementation(() => true);
+
+    try {
+      expect(stopSession("sid-tree")).toBe(true);
+      await flush();
+
+      expect(killProcessTreeMock).toHaveBeenCalledWith(4242);
+      expect(processKillSpy).not.toHaveBeenCalled();
+    } finally {
+      processKillSpy.mockRestore();
+    }
+  });
+});

package/src/adapters/adapter-interface.ts

@@ -152,11 +152,12 @@ export interface ToolAdapter {
   /** 群描述中会话 ID 的前缀，如 "Claude Session:" */
   readonly sessionDescPrefix: string;
 
-  /**
-   * 创建新会话，返回会话 ID。
-   * 适配器内部需处理后台流消费（静默消费 stream 中除 init 外的所有事件）。
-   */
-  createSession(cwd: string): Promise<CreateSessionResult>;
+  /**
+   * 创建新会话，返回会话 ID。
+   * 适配器内部需处理后台流消费（静默消费 stream 中除 init 外的所有事件）。
+   * signal 用于上层在长期收不到 init 事件时终止底层 SDK/CLI。
+   */
+  createSession(cwd: string, signal?: AbortSignal): Promise<CreateSessionResult>;
 
   /**
    * 向已有会话发送提示文本，返回归一化消息的异步迭代器。

package/src/adapters/claude-adapter.ts

@@ -452,9 +452,14 @@ class ClaudeAdapter implements ToolAdapter {
     this.maxTurn = options.maxTurn ?? 0;
   }
 
-  async createSession(cwd: string): Promise<CreateSessionResult> {
+  async createSession(cwd: string, signal?: AbortSignal): Promise<CreateSessionResult> {
     logMcpConfig();
     const abortController = new AbortController();
+    const removeAbortListener = bridgeAbortSignal(signal, abortController);
+    if (abortController.signal.aborted) {
+      removeAbortListener?.();
+      throw new Error("Claude session creation aborted");
+    }
     let sessionId: string | undefined;
     const session = unstable_v2_createSession(
       toSdkSessionOptions(buildSdkOptions({
@@ -486,6 +491,7 @@ class ClaudeAdapter implements ToolAdapter {
         }
       }
     } finally {
+      removeAbortListener?.();
       closeSdkSession(session);
     }
 

package/src/adapters/codex-adapter.ts

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

package/src/adapters/cursor-adapter.ts

@@ -511,34 +511,40 @@ class CursorAdapter implements ToolAdapter {
     this.badJsonIdleTimeoutMs = badJsonIdleTimeoutMs;
   }
 
-  async createSession(cwd: string): Promise<CreateSessionResult> {
+  async createSession(cwd: string, signal?: AbortSignal): Promise<CreateSessionResult> {
+    if (signal?.aborted) throw new Error("Cursor session creation aborted");
     const handle = spawnAgent(["ok"], cwd, undefined, this.modelOverride, undefined, this.spawnImpl);
     const proc = handle.proc;
     const stats = createCursorStreamStats();
     this.activeProcs.add(proc);
+    const onAbort = () => { void killProcessTree(proc.pid); };
+    signal?.addEventListener("abort", onAbort, { once: true });
 
-    for await (const msg of readJsonLines(proc, undefined, "createSession", null, stats, this.badJsonIdleTimeoutMs)) {
-      if (msg.type === "system" && msg.subtype === "init" && msg.session_id) {
-        const sessionId = msg.session_id;
-        await this.metaStore
-          .set(sessionId, { cwd: msg.cwd ?? cwd, model: msg.model })
-          .catch(() => {});
-        this.activeProcs.delete(proc);
-        await killProcessTree(proc.pid);
-        return { sessionId };
+    try {
+      for await (const msg of readJsonLines(proc, signal, "createSession", null, stats, this.badJsonIdleTimeoutMs)) {
+        if (msg.type === "system" && msg.subtype === "init" && msg.session_id) {
+          const sessionId = msg.session_id;
+          await this.metaStore
+            .set(sessionId, { cwd: msg.cwd ?? cwd, model: msg.model })
+            .catch(() => {});
+          return { sessionId };
+        }
       }
-    }
 
-    await killProcessTree(proc.pid);
-    this.activeProcs.delete(proc);
-    const closeInfo = await handle.waitForClose();
-    const visibleMessage = formatCursorAgentEmptyOutputMessage({
-      exitCode: closeInfo.code,
-      stdoutLength: stats.stdoutLength,
-      stderr: closeInfo.stderr,
-    });
-    if (visibleMessage) throw new Error(visibleMessage);
-    throw new Error("No session ID in Cursor init event");
+      if (signal?.aborted) throw new Error("Cursor session creation aborted");
+      const closeInfo = await handle.waitForClose();
+      const visibleMessage = formatCursorAgentEmptyOutputMessage({
+        exitCode: closeInfo.code,
+        stdoutLength: stats.stdoutLength,
+        stderr: closeInfo.stderr,
+      });
+      if (visibleMessage) throw new Error(visibleMessage);
+      throw new Error("No session ID in Cursor init event");
+    } finally {
+      signal?.removeEventListener("abort", onAbort);
+      await killProcessTree(proc.pid);
+      this.activeProcs.delete(proc);
+    }
   }
 
   async *prompt(

package/src/response-stall.ts

@@ -1,20 +1,20 @@
-/** A snapshot of response output progress while the Agent is generating a reply. */
+/** A snapshot of visible output progress while the Agent is starting or replying. */
 export interface ResponseProgressObservation {
   totalChars: number;
   unchangedSince: number;
 }
 
 /**
- * Tracks how long the displayed response character count has remained unchanged.
- * Leaving the responding phase clears the window; returning starts a fresh one.
+ * Tracks how long the displayed output character count has remained unchanged.
+ * Leaving a monitored phase clears the window; returning starts a fresh one.
  */
 export function observeResponseProgress(
   previous: ResponseProgressObservation | undefined,
-  isResponding: boolean,
+  isMonitoredPhase: boolean,
   totalChars: number,
   now = Date.now(),
 ): ResponseProgressObservation | undefined {
-  if (!isResponding) return undefined;
+  if (!isMonitoredPhase) return undefined;
   if (previous?.totalChars === totalChars) return previous;
   return { totalChars, unchangedSince: now };
 }

package/src/session-chat-binding.ts

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

package/src/session.ts

@@ -27,6 +27,7 @@ import {
   formatAgentActivityTitle,
   updateAgentActivity,
 } from "./agent-activity.ts";
+import type { AgentActivityKind } from "./agent-activity.ts";
 import { simplifyToolUse, simplifyToolResult } from "./simplify.ts";
 import { logTrace } from "./trace.ts";
 import type { UnifiedBlock } from "./adapters/adapter-interface.ts";
@@ -165,15 +166,17 @@ function platformForChat(chatId: string): PlatformAdapter | null {
 const DEFAULT_PROCESS_MONITOR_INTERVAL_MS = 5000;
 const DEFAULT_RESPONSE_STALL_TIMEOUT_MS = 3 * 60 * 1000;
 const DEFAULT_RESPONSE_STALL_CHECK_INTERVAL_MS = 5000;
+const DEFAULT_FINAL_RESPONSE_CLOSE_TIMEOUT_MS = 10_000;
 export const RESPONSE_STALL_RECOVERY_PROMPT = "完成了吗？如果没完成继续";
 export const RESPONSE_STALL_RECOVERY_NOTICE =
   `检测到会话停滞，正在自动确认并继续。\n\n${RESPONSE_STALL_RECOVERY_PROMPT}`;
 export const RESPONSE_STALL_RECOVERY_EXHAUSTED_NOTICE =
-  "⚠️ 自动续跑仍连续 3 分钟没有新回复，本次不再自动继续。";
+  "⚠️ 自动续跑仍连续 3 分钟没有启动进展或新回复，本次不再自动继续。";
 const RESPONSE_STALL_RECOVERY_DELAY_MS = 200;
 let processMonitorIntervalMs = DEFAULT_PROCESS_MONITOR_INTERVAL_MS;
 let responseStallTimeoutMs = DEFAULT_RESPONSE_STALL_TIMEOUT_MS;
 let responseStallCheckIntervalMs = DEFAULT_RESPONSE_STALL_CHECK_INTERVAL_MS;
+let finalResponseCloseTimeoutMs = DEFAULT_FINAL_RESPONSE_CLOSE_TIMEOUT_MS;
 let isProcessAliveImpl = (pid: number): boolean => {
   try {
     process.kill(pid, 0);
@@ -221,7 +224,15 @@ export function _setResponseStallCheckIntervalForTest(ms: number): void {
 export function _resetResponseStallCheckIntervalForTest(): void {
   responseStallCheckIntervalMs = DEFAULT_RESPONSE_STALL_CHECK_INTERVAL_MS;
 }
-
+
+export function _setFinalResponseCloseTimeoutForTest(ms: number): void {
+  finalResponseCloseTimeoutMs = ms;
+}
+
+export function _resetFinalResponseCloseTimeoutForTest(): void {
+  finalResponseCloseTimeoutMs = DEFAULT_FINAL_RESPONSE_CLOSE_TIMEOUT_MS;
+}
+
 function clearPromptProcessMonitor(sessionId: string): void {
   const prompt = activePrompts.get(sessionId);
   if (!prompt?.processMonitor) return;
@@ -236,6 +247,59 @@ function clearPromptResponseStallMonitor(sessionId: string): void {
   prompt.responseStallMonitor = undefined;
 }
 
+function clearPromptFinalResponseCloseTimer(sessionId: string): void {
+  const prompt = activePrompts.get(sessionId);
+  if (!prompt?.finalResponseCloseTimer) return;
+  clearTimeout(prompt.finalResponseCloseTimer);
+  prompt.finalResponseCloseTimer = undefined;
+}
+
+/**
+ * 权威终态只说明 Agent 已完成本轮，不保证 CLI/SDK 的输出流会及时关闭。
+ * 给正常清理保留 10 秒；若流仍悬挂，则关闭底层 session 并杀掉当前 CLI 树，
+ * 让 runAgentSession 以 done 收尾。这里绝不触发自动续跑，因为答案已完整到达。
+ */
+function scheduleFinalResponseCloseGuard(
+  sessionId: string,
+  runningPrompt: NonNullable<ReturnType<typeof activePrompts.get>>,
+): void {
+  if (runningPrompt.finalResponseCloseTimer) return;
+
+  const timeoutMs = finalResponseCloseTimeoutMs;
+  const handle = setTimeout(() => {
+    const current = activePrompts.get(sessionId);
+    if (
+      !current
+      || current !== runningPrompt
+      || !current.finalResponseObserved
+      || current.stopped
+      || current.abnormalExit
+      || current.resourceStuck
+      || current.autoEnded
+    ) {
+      return;
+    }
+
+    current.finalResponseCloseTimer = undefined;
+    clearPromptProcessMonitor(sessionId);
+    clearPromptResponseStallMonitor(sessionId);
+    try {
+      current.closeSession?.();
+    } catch (err) {
+      console.warn(
+        `[${ts()}] [FINAL-RESPONSE] closeSession failed for ${sessionId}: ${(err as Error).message}`,
+      );
+    }
+    current.controller.abort();
+    void killProcessTree(current.processPid);
+    console.warn(
+      `[${ts()}] [FINAL-RESPONSE] Session ${sessionId} stream stayed open for ${timeoutMs}ms after its authoritative final event; forced clean shutdown`,
+    );
+  }, timeoutMs);
+  handle.unref?.();
+  runningPrompt.finalResponseCloseTimer = handle;
+}
+
 function formatTerminalHeader(status: "running" | "done" | "stopped" | "error" | "auto_ended"): {
   title: string;
   template?: string;
@@ -251,12 +315,20 @@ function turnFinalStatus(status: "running" | "done" | "stopped" | "error" | "aut
 }
 
 function formatAutoEndedReply(finalReply: string): string {
-  const reason = "⚠️ 已自动结束：连续 3 分钟处于“正在生成回复”且回复字符总数没有变化。";
+  const reason = "⚠️ 已自动结束：连续 3 分钟没有启动进展或回复字符变化。";
   return finalReply
     ? `${reason}以下回复可能不完整。\n\n${finalReply}`
     : `${reason}本轮没有可发送的回复内容。`;
 }
 
+/**
+ * 只监控用户无法判断是否仍有进展的两个阶段。思考、工具调用和搜索可能合法地
+ * 长时间不产生回复字符，由资源监控负责识别真正僵死，不能在这里误杀。
+ */
+function monitorsOutputProgress(kind: AgentActivityKind): boolean {
+  return kind === "starting" || kind === "responding";
+}
+
 function formatTerminalReply(
   status: "running" | "done" | "stopped" | "error" | "auto_ended",
   finalReply: string,
@@ -397,6 +469,7 @@ export function resetState(): void {
   for (const prompt of activePrompts.values()) {
     if (prompt.processMonitor) clearInterval(prompt.processMonitor);
     if (prompt.responseStallMonitor) clearInterval(prompt.responseStallMonitor);
+    if (prompt.finalResponseCloseTimer) clearTimeout(prompt.finalResponseCloseTimer);
   }
   activePrompts.clear();
   displayCards.clear();
@@ -946,15 +1019,40 @@ function formatToolConfigForLog(tool: string, sessionModel?: string, sessionId?:
   return `model=${anthropicConfigDisplay(getModelForSession(sessionId))}, subagentModel=${anthropicConfigDisplay(CLAUDE_SUBAGENT_MODEL)}, effort=${anthropicConfigDisplay(getEffectiveEffortForTool(tool, sessionId))}`;
 }
 
-export async function initClaudeSession(tool: string, overrideCwd?: string, chatId?: string): Promise<{ sessionId: string; cwd: string }> {
-  const cwd = overrideCwd ?? (await getDefaultCwd(chatId));
-  const adapter = getAdapterForTool(tool);
+export async function initClaudeSession(tool: string, overrideCwd?: string, chatId?: string): Promise<{ sessionId: string; cwd: string }> {
+  const cwd = overrideCwd ?? (await getDefaultCwd(chatId));
+  const adapter = getAdapterForTool(tool);
   console.log(
-    `[${ts()}] [STEP 1/5] Creating ${adapter.displayName} session (${formatToolConfigForLog(tool)}, cwd=${cwd})`
-  );
-
-  const result = await adapter.createSession(cwd);
-  const sessionId = result.sessionId;
+    `[${ts()}] [STEP 1/5] Creating ${adapter.displayName} session (${formatToolConfigForLog(tool)}, cwd=${cwd})`
+  );
+
+  // Claude/Cursor 创建会话时需要先等待 SDK/CLI 的 init 事件。它们若在首个
+  // 事件前卡死，正式 turn 尚未建立，runAgentSession 的看门狗无法介入。
+  // 因此创建入口也使用相同的三分钟阈值，并通过 AbortSignal 释放底层资源。
+  const createController = new AbortController();
+  let createTimeout: ReturnType<typeof setTimeout> | undefined;
+  const timeoutError = new Error(
+    `${adapter.displayName} session creation timed out after 3 minutes without an init event`,
+  );
+  const timeoutPromise = new Promise<never>((_resolve, reject) => {
+    createTimeout = setTimeout(() => {
+      // 先固定对外错误，再 abort 适配器，避免适配器自己的 abort 错误赢得竞态。
+      reject(timeoutError);
+      createController.abort();
+    }, responseStallTimeoutMs);
+    createTimeout.unref?.();
+  });
+
+  let result: Awaited<ReturnType<ToolAdapter["createSession"]>>;
+  try {
+    result = await Promise.race([
+      adapter.createSession(cwd, createController.signal),
+      timeoutPromise,
+    ]);
+  } finally {
+    if (createTimeout) clearTimeout(createTimeout);
+  }
+  const sessionId = result.sessionId;
   console.log(`[${ts()}]   → sessionId: ${sessionId}`);
 
   await saveSessionTool(sessionId, tool);
@@ -1270,6 +1368,16 @@ export async function runAgentSession(
 
   const runningPrompt = activePrompts.get(sessionId);
   if (runningPrompt) {
+    // 必须在消费第一个事件前建立零字符基线。部分 CLI 卡死时只启动了进程，
+    // 甚至一个事件都不会 yield；若等循环体更新进度，这种会话会永久停在
+    // “正在启动 Agent”，也永远触发不了三分钟保护。
+    runningPrompt.responseProgress = observeResponseProgress(
+      undefined,
+      true,
+      0,
+      activityTracker.activity.startedAt,
+    );
+
     const checkResponseStall = async () => {
       const current = activePrompts.get(sessionId);
       if (!current || current !== runningPrompt) {
@@ -1282,7 +1390,7 @@ export async function runAgentSession(
         || current.resourceStuck
         || current.autoEnded
         || current.finalResponseObserved
-        || activityTracker.activity.kind !== "responding"
+        || !monitorsOutputProgress(activityTracker.activity.kind)
         || !hasResponseStalled(current.responseProgress, Date.now(), responseStallTimeoutMs)
       ) {
         return;
@@ -1338,7 +1446,7 @@ export async function runAgentSession(
       current.controller.abort();
       await killProcessTree(current.processPid);
       console.warn(
-        `[${ts()}] [RESPONSE-STALL] Session ${sessionId} auto-ended after 3 minutes without reply character changes`,
+        `[${ts()}] [RESPONSE-STALL] Session ${sessionId} auto-ended after 3 minutes without startup or reply progress`,
       );
     };
 
@@ -1371,7 +1479,10 @@ export async function runAgentSession(
         if (prompt && prompt === runningPrompt) {
           // 同步标记必须发生在任何 await 之前，让 watchdog 无法在已收到完整
           // 最终事件后仍把本轮判为停滞。
-          prompt.finalResponseObserved = true;
+          if (!prompt.finalResponseObserved) {
+            prompt.finalResponseObserved = true;
+            scheduleFinalResponseCloseGuard(sessionId, prompt);
+          }
         }
       }
 
@@ -1399,8 +1510,10 @@ export async function runAgentSession(
       if (prompt && !prompt.autoEnded) {
         const totalChars = state.accumulatedContent.length + pickFinalReply(state).length;
         prompt.responseProgress = observeResponseProgress(
-          prompt.responseProgress,
-          activityTracker.activity.kind === "responding",
+          // starting → responding 本身是一次有效进展，即便首个文本块仍为空也应
+          // 重新计时；其它活动阶段会清空观察窗口。
+          activityChanged ? undefined : prompt.responseProgress,
+          monitorsOutputProgress(activityTracker.activity.kind),
           totalChars,
           Date.now(),
         );
@@ -1443,6 +1556,7 @@ export async function runAgentSession(
     const autoEndedAt = wasAutoEnded ? prompt?.autoEndedAt : undefined;
     clearPromptResponseStallMonitor(sessionId);
     clearPromptProcessMonitor(sessionId);
+    clearPromptFinalResponseCloseTimer(sessionId);
     markSessionFinalizing(sessionId);
     activePrompts.delete(sessionId);
 
@@ -1576,7 +1690,7 @@ export async function runAgentSession(
           autoRecoveryTarget = { chatId: activeAutoEnded, platform: pp };
         }
       }
-      console.warn(`[${ts()}] Session ${sessionId} auto-ended after stalled response output (content chunks: ${state.chunkCount})`);
+      console.warn(`[${ts()}] Session ${sessionId} auto-ended after stalled startup or response output (content chunks: ${state.chunkCount})`);
       if (tid) logTrace(tid, "SESSION_END", { sessionId, outcome: "response_stall", chunks: state.chunkCount });
     } else if (wasAbnormalExit) {
       for (const cid of finalizationChatIds) {
@@ -2080,21 +2194,21 @@ export function stopSession(sessionId: string): boolean {
   prompt.stopped = true;
   clearPromptResponseStallMonitor(sessionId);
   clearPromptProcessMonitor(sessionId);
-  cancelQueuedMessage(sessionId);
-  try {
-    prompt.closeSession?.();
-  } catch (err) {
+  clearPromptFinalResponseCloseTimer(sessionId);
+  cancelQueuedMessage(sessionId);
+
+  // 先发起整棵进程树清理，再触发 close/abort。Windows 上 CLI 由
+  // cmd.exe → node → 实际二进制组成；若先 process.kill(cmd.exe)，taskkill
+  // 随后便无法从已消失的根 PID 找到后代，正是幽灵 Codex/Cursor 的来源。
+  // killProcessTree 在返回 Promise 前已启动 taskkill，因此这里无需阻塞。
+  void killProcessTree(prompt.processPid);
+  try {
+    prompt.closeSession?.();
+  } catch (err) {
     console.warn(`[${ts()}] [STOP] closeSession failed for ${sessionId}: ${(err as Error).message}`);
-  }
-  prompt.controller.abort();
-
-  // 强制杀死 CLI 子进程。controller.abort() 只在 for-await 收到下一条
-  // stream 消息时才被检测到——如果 agent 陷入无输出的计算循环，abort 信号
-  // 永远不会生效。直接 process.kill 让 stdout/stderr 管道关闭，stream 立即结束。
-  if (prompt.processPid !== undefined) {
-    try { process.kill(prompt.processPid); } catch { /* 进程可能已退出 */ }
-  }
-  console.log(`[${ts()}] [STOP] Session ${sessionId} aborted`);
+  }
+  prompt.controller.abort();
+  console.log(`[${ts()}] [STOP] Session ${sessionId} aborted`);
 
   // fire-and-forget：立刻把 stream-state.status 改成 stopped，
   // 让 display loop 下一次扫到立刻渲染"已停止"卡片，不必再等几秒。