chatccc 0.2.212 → 0.2.213

package/README.md

@@ -334,7 +334,7 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
 
 **微信：** 扫码登录后，在机器人私聊里发送 `/new` 或指定 Agent 的 `/new ...` 命令即可开始。功能与飞书基本一致，但展示为纯文本。
 
-**会话停滞保护：** 当 Agent 连续 3 分钟处于“正在生成回复”且回复字符数没有变化、同时尚未报告权威终态时，ChatCCC 会结束旧 CLI，并优先补发一次“完成了吗？如果没完成继续”；恢复轮再次发生相同停滞时不再递归续跑。Codex 只有 `turn.completed` 才算权威终态，阶段性的 `agent_message` 不算；任一 Agent 报告权威终态后若输出流仍超过 10 秒未关闭，ChatCCC 会强制清理该 CLI 并按正常完成收尾，不会重复询问 Agent。
+**会话停滞保护：** 当 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.212",
+  "version": "0.2.213",
   "description": "Feishu bot bridge for Claude Code",
   "license": "Apache-2.0",
   "type": "module",

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

@@ -379,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__/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 真实模型

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,
@@ -226,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,
@@ -245,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();
   });
@@ -774,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);
@@ -1215,7 +1347,7 @@ describe("runAgentSession response stall watchdog", () => {
     expect(receivedPrompts[1]).toContain(recoveryPrompt);
     expect(platform.sendText).toHaveBeenCalledWith(
       "chat-recovery-limit",
-      "⚠️ 自动续跑仍连续 3 分钟没有新回复，本次不再自动继续。",
+      "⚠️ 自动续跑仍连续 3 分钟没有启动进展或新回复，本次不再自动继续。",
     );
   });
 
@@ -1474,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/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.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";
@@ -170,7 +171,7 @@ 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;
@@ -314,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,
@@ -1010,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);
@@ -1334,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) {
@@ -1346,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;
@@ -1402,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`,
       );
     };
 
@@ -1466,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(),
         );
@@ -1644,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) {
@@ -2149,21 +2195,20 @@ export function stopSession(sessionId: string): boolean {
   clearPromptResponseStallMonitor(sessionId);
   clearPromptProcessMonitor(sessionId);
   clearPromptFinalResponseCloseTimer(sessionId);
-  cancelQueuedMessage(sessionId);
-  try {
-    prompt.closeSession?.();
-  } catch (err) {
+  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 下一次扫到立刻渲染"已停止"卡片，不必再等几秒。