chatccc 0.2.209 → 0.2.211

package/package.json

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

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

@@ -73,6 +73,7 @@ describe("createCccAdapter", () => {
     expect(messages).toEqual([
       { type: "assistant", blocks: [{ type: "text", text: "hello" }] },
       { type: "assistant", blocks: [{ type: "text", text: " world" }] },
+      { type: "assistant", blocks: [], isFinalResponse: true },
     ]);
     expect(streamTextMock).toHaveBeenCalledWith(expect.objectContaining({
       model: { modelId: "deepseek-v4-flash" },
@@ -109,6 +110,7 @@ describe("createCccAdapter", () => {
         type: "assistant",
         blocks: [{ type: "tool_result", tool_use_id: "call-1", content: { content: "hello" }, is_error: false }],
       },
+      { type: "assistant", blocks: [], isFinalResponse: true },
     ]);
   });
 });

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

@@ -269,10 +269,17 @@ describe("normalizeSdkMessage", () => {
     expect(result!.blocks[0]).toEqual({ type: "text", text: "still here" });
   });
 
-  it("returns null for non-assistant/non-user/non-system messages", () => {
+  it("marks a successful result event as an authoritative final response", () => {
     expect(
       normalizeSdkMessage({ type: "result", subtype: "success" }),
-    ).toBeNull();
+    ).toEqual({
+      type: "assistant",
+      blocks: [],
+      isFinalResponse: true,
+    });
+  });
+
+  it("returns null for other non-assistant/non-user/non-system messages", () => {
     expect(
       normalizeSdkMessage({ type: "stream_event" }),
     ).toBeNull();

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

@@ -61,10 +61,11 @@ describe("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).not.toBeNull();
+    expect(result!.type).toBe("assistant");
+    expect(result!.blocks).toEqual([{ type: "text", text: "hello" }]);
+    expect(result!.isFinalResponse).toBe(true);
+  });
 
   it("normalizes command_execution start into tool_use block", () => {
     const result = normalizeCodexMessage({

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

@@ -139,6 +139,7 @@ describe("Codex raw stream logs", () => {
     expect(events).toContainEqual({
       type: "assistant",
       blocks: [{ type: "text", text: "hello" }],
+      isFinalResponse: true,
     });
   });
 

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

@@ -490,10 +490,11 @@ describe("normalizeCursorMessage - result 消息（官方权威最终文本）",
     });
     expect(result).not.toBeNull();
     expect(result!.type).toBe("assistant");
-    expect(result!.blocks).toEqual([
-      { type: "text_final", text: "权威最终文本" },
-    ]);
-  });
+    expect(result!.blocks).toEqual([
+      { type: "text_final", text: "权威最终文本" },
+    ]);
+    expect(result!.isFinalResponse).toBe(true);
+  });
 
   it("result 消息没有 result 字段时返回 null（无可用文本）", () => {
     expect(

package/src/__tests__/orchestrator.test.ts

@@ -87,7 +87,12 @@ import {
   resetState,
   sessionInfoMap,
 } from "../session.ts";
-import { activePrompts, dequeueMessage, resetBindingState } from "../session-chat-binding.ts";
+import {
+  activePrompts,
+  dequeueMessage,
+  getChatsForSession,
+  resetBindingState,
+} from "../session-chat-binding.ts";
 import { ABD_APPEND_PROMPT } from "../shared-prefix.ts";
 import { config } from "../config.ts";
 
@@ -802,6 +807,7 @@ describe("handleCommand WeChat processing ack", () => {
     expect(platform.sendRawCard).toHaveBeenCalled();
     const card = JSON.parse(vi.mocked(platform.sendRawCard).mock.calls[0][1]);
     expect(JSON.stringify(card)).toContain("xhigh");
+    expect(getChatsForSession("sid-codex-effort")).toContain("codex-chat");
   });
 
   it("rejects /effort in Cursor sessions", async () => {

package/src/__tests__/session.test.ts

@@ -123,6 +123,8 @@ import {
   _setResponseStallCheckIntervalForTest,
   _resetResponseStallCheckIntervalForTest,
   setSessionEffortOverride,
+  RESPONSE_STALL_RECOVERY_PROMPT,
+  RESPONSE_STALL_RECOVERY_EXHAUSTED_NOTICE,
 } from "../session.ts";
 import {
   activePrompts,
@@ -670,6 +672,7 @@ describe("runAgentSession process monitor", () => {
 
 describe("runAgentSession response stall watchdog", () => {
   let tempDir = "";
+  const recoveryPrompt = RESPONSE_STALL_RECOVERY_PROMPT;
 
   beforeEach(async () => {
     vi.useFakeTimers();
@@ -766,6 +769,376 @@ describe("runAgentSession response stall watchdog", () => {
       autoEndedAt: expect.any(Number),
     });
   });
+
+  it("self-heals a missing trigger-chat binding and gives automatic recovery the normal card lifecycle", async () => {
+    vi.setSystemTime(0);
+    _setResponseStallTimeoutForTest(100);
+    _setResponseStallCheckIntervalForTest(10);
+    _setProcessAliveForTest(() => true);
+
+    const platform = mockPlatform("feishu");
+    setSessionPlatform(platform);
+
+    const receivedPrompts: string[] = [];
+    const adapter: ToolAdapter = {
+      displayName: "Any Agent",
+      sessionDescPrefix: "Agent Session:",
+      createSession: async () => ({ sessionId: "sid-binding-recovery" }),
+      getSessionInfo: async (sid) => ({ sessionId: sid, cwd: "F:\\repo" }),
+      closeSession: async () => {},
+      prompt: async function* (
+        _sid: string,
+        text: string,
+        _cwd: string,
+        signal?: AbortSignal,
+        options?: ToolPromptOptions,
+      ) {
+        receivedPrompts.push(text);
+        options?.onProcessStart?.({ pid: 5000 + receivedPrompts.length });
+        if (receivedPrompts.length === 1) {
+          yield { type: "assistant", blocks: [{ type: "text", text: "" }] };
+          await new Promise<void>((resolve) => {
+            if (signal?.aborted) {
+              resolve();
+              return;
+            }
+            signal?.addEventListener("abort", () => resolve(), { once: true });
+          });
+          return;
+        }
+        yield {
+          type: "assistant",
+          blocks: [{ type: "text", text: "recovery completed" }],
+          isFinalResponse: true,
+        };
+      },
+    };
+    _setAdapterForToolForTest("claude", adapter);
+
+    const firstRun = runAgentSession(
+      "sid-binding-recovery",
+      "first prompt",
+      platform,
+      "chat-binding-recovery",
+      0,
+      "claude",
+    );
+
+    await vi.waitFor(() => {
+      expect(activePrompts.get("sid-binding-recovery")?.responseProgress).toBeDefined();
+    });
+    const progress = activePrompts.get("sid-binding-recovery")!.responseProgress!;
+    await vi.advanceTimersByTimeAsync(progress.unchangedSince + 101 - Date.now());
+    await firstRun;
+    await vi.advanceTimersByTimeAsync(200);
+    await vi.waitFor(() => expect(receivedPrompts).toHaveLength(2));
+    await vi.waitFor(() => expect(isSessionRunning("sid-binding-recovery")).toBe(false));
+
+    expect(getChatsForSession("sid-binding-recovery")).toContain("chat-binding-recovery");
+    expect(platform.cardCreate).toHaveBeenCalledTimes(2);
+    expect(platform.cardSend).toHaveBeenCalledTimes(2);
+    expect(platform.sendText).toHaveBeenCalledWith(
+      "chat-binding-recovery",
+      expect.stringContaining(recoveryPrompt),
+    );
+
+    const registry = JSON.parse(
+      await readFile(join(tempDir, "session-registry.json"), "utf8"),
+    ) as Record<string, { running?: boolean }>;
+    expect(registry["chat-binding-recovery"]?.running).toBe(false);
+  });
+
+  it("treats an authoritative final response that races timeout cleanup as completed", async () => {
+    vi.setSystemTime(0);
+    _setResponseStallTimeoutForTest(100);
+    _setResponseStallCheckIntervalForTest(10);
+    _setProcessAliveForTest(() => true);
+
+    const platform = mockPlatform("feishu");
+    setSessionPlatform(platform);
+    bindChatToSession("sid-final-race", "chat-final-race");
+    recordLastActiveChat("sid-final-race", "chat-final-race");
+
+    const receivedPrompts: string[] = [];
+    const adapter: ToolAdapter = {
+      displayName: "Any Agent",
+      sessionDescPrefix: "Agent Session:",
+      createSession: async () => ({ sessionId: "sid-final-race" }),
+      getSessionInfo: async (sid) => ({ sessionId: sid, cwd: "F:\\repo" }),
+      closeSession: async () => {},
+      prompt: async function* (
+        _sid: string,
+        text: string,
+        _cwd: string,
+        signal?: AbortSignal,
+        options?: ToolPromptOptions,
+      ) {
+        receivedPrompts.push(text);
+        options?.onProcessStart?.({ pid: 5151 });
+        yield { type: "assistant", blocks: [{ type: "text", text: "" }] };
+        await new Promise<void>((resolve) => {
+          if (signal?.aborted) {
+            resolve();
+            return;
+          }
+          signal?.addEventListener("abort", () => resolve(), { once: true });
+        });
+        yield {
+          type: "assistant",
+          blocks: [{ type: "text", text: "completed at the timeout boundary" }],
+          isFinalResponse: true,
+        };
+      },
+    };
+    _setAdapterForToolForTest("claude", adapter);
+
+    const run = runAgentSession(
+      "sid-final-race",
+      "prompt",
+      platform,
+      "chat-final-race",
+      0,
+      "claude",
+    );
+    await vi.waitFor(() => {
+      expect(activePrompts.get("sid-final-race")?.responseProgress).toBeDefined();
+    });
+    const progress = activePrompts.get("sid-final-race")!.responseProgress!;
+    await vi.advanceTimersByTimeAsync(progress.unchangedSince + 101 - Date.now());
+    await run;
+    await vi.advanceTimersByTimeAsync(1_000);
+
+    expect(receivedPrompts).toHaveLength(1);
+    expect(mockStreamStates.get("sid-final-race")).toMatchObject({
+      status: "done",
+      finalReply: "completed at the timeout boundary",
+    });
+    expect(platform.sendText).not.toHaveBeenCalledWith(
+      "chat-final-race",
+      RESPONSE_STALL_RECOVERY_EXHAUSTED_NOTICE,
+    );
+  });
+
+  it("runs the reserved recovery prompt before an already queued user message", async () => {
+    vi.setSystemTime(0);
+    _setResponseStallTimeoutForTest(100);
+    _setResponseStallCheckIntervalForTest(10);
+    _setProcessAliveForTest(() => true);
+
+    const platform = mockPlatform("feishu");
+    setSessionPlatform(platform);
+    bindChatToSession("sid-recovery-priority", "chat-recovery-priority");
+    recordLastActiveChat("sid-recovery-priority", "chat-recovery-priority");
+
+    const receivedPrompts: string[] = [];
+    const adapter: ToolAdapter = {
+      displayName: "Any Agent",
+      sessionDescPrefix: "Agent Session:",
+      createSession: async () => ({ sessionId: "sid-recovery-priority" }),
+      getSessionInfo: async (sid) => ({ sessionId: sid, cwd: "F:\\repo" }),
+      closeSession: async () => {},
+      prompt: async function* (
+        _sid: string,
+        text: string,
+        _cwd: string,
+        signal?: AbortSignal,
+        options?: ToolPromptOptions,
+      ) {
+        receivedPrompts.push(text);
+        options?.onProcessStart?.({ pid: 5252 + receivedPrompts.length });
+        if (receivedPrompts.length === 1) {
+          yield { type: "assistant", blocks: [{ type: "text", text: "" }] };
+          await new Promise<void>((resolve) => {
+            if (signal?.aborted) {
+              resolve();
+              return;
+            }
+            signal?.addEventListener("abort", () => resolve(), { once: true });
+          });
+          return;
+        }
+        yield { type: "assistant", blocks: [{ type: "text", text: "recovery completed" }] };
+      },
+    };
+    _setAdapterForToolForTest("claude", adapter);
+
+    enqueueMessage("sid-recovery-priority", {
+      text: "queued user prompt",
+      chatId: "chat-recovery-priority",
+      openId: "open-user",
+      msgTimestamp: 1,
+      chatType: "p2p",
+    });
+    const consumeQueued = vi.fn();
+    setQueueConsumer(consumeQueued);
+
+    const firstRun = runAgentSession(
+      "sid-recovery-priority",
+      "first prompt",
+      platform,
+      "chat-recovery-priority",
+      0,
+      "claude",
+    );
+
+    await vi.waitFor(() => {
+      expect(activePrompts.get("sid-recovery-priority")?.responseProgress).toBeDefined();
+    });
+    const firstProgress = activePrompts.get("sid-recovery-priority")!.responseProgress!;
+    await vi.advanceTimersByTimeAsync(firstProgress.unchangedSince + 101 - Date.now());
+    await firstRun;
+
+    expect(receivedPrompts).toHaveLength(1);
+    expect(consumeQueued).not.toHaveBeenCalled();
+    expect(isSessionRunning("sid-recovery-priority")).toBe(true);
+    expect(platform.sendText).toHaveBeenCalledWith(
+      "chat-recovery-priority",
+      expect.stringContaining(recoveryPrompt),
+    );
+
+    await vi.advanceTimersByTimeAsync(200);
+    await vi.waitFor(() => expect(receivedPrompts).toHaveLength(2));
+    expect(receivedPrompts[1]).toContain(recoveryPrompt);
+    expect(receivedPrompts[1]).not.toContain("queued user prompt");
+    expect(consumeQueued).not.toHaveBeenCalled();
+
+    await vi.advanceTimersByTimeAsync(200);
+    expect(consumeQueued).toHaveBeenCalledTimes(1);
+    expect(consumeQueued).toHaveBeenCalledWith(
+      platform,
+      expect.objectContaining({ text: "queued user prompt" }),
+    );
+    setQueueConsumer(() => {});
+  });
+
+  it("does not auto-recover a second consecutive response stall", async () => {
+    vi.setSystemTime(0);
+    _setResponseStallTimeoutForTest(100);
+    _setResponseStallCheckIntervalForTest(10);
+    _setProcessAliveForTest(() => true);
+
+    const platform = mockPlatform("feishu");
+    setSessionPlatform(platform);
+    bindChatToSession("sid-recovery-limit", "chat-recovery-limit");
+    recordLastActiveChat("sid-recovery-limit", "chat-recovery-limit");
+
+    const receivedPrompts: string[] = [];
+    const adapter: ToolAdapter = {
+      displayName: "Any Agent",
+      sessionDescPrefix: "Agent Session:",
+      createSession: async () => ({ sessionId: "sid-recovery-limit" }),
+      getSessionInfo: async (sid) => ({ sessionId: sid, cwd: "F:\\repo" }),
+      closeSession: async () => {},
+      prompt: async function* (
+        _sid: string,
+        text: string,
+        _cwd: string,
+        signal?: AbortSignal,
+        options?: ToolPromptOptions,
+      ) {
+        receivedPrompts.push(text);
+        options?.onProcessStart?.({ pid: 6262 + receivedPrompts.length });
+        yield { type: "assistant", blocks: [{ type: "text", text: "" }] };
+        await new Promise<void>((resolve) => {
+          if (signal?.aborted) {
+            resolve();
+            return;
+          }
+          signal?.addEventListener("abort", () => resolve(), { once: true });
+        });
+      },
+    };
+    _setAdapterForToolForTest("claude", adapter);
+
+    const firstRun = runAgentSession(
+      "sid-recovery-limit",
+      "first prompt",
+      platform,
+      "chat-recovery-limit",
+      0,
+      "claude",
+    );
+    await vi.waitFor(() => {
+      expect(activePrompts.get("sid-recovery-limit")?.responseProgress).toBeDefined();
+    });
+    const firstProgress = activePrompts.get("sid-recovery-limit")!.responseProgress!;
+    await vi.advanceTimersByTimeAsync(firstProgress.unchangedSince + 101 - Date.now());
+    await firstRun;
+
+    await vi.advanceTimersByTimeAsync(200);
+    await vi.waitFor(() => expect(receivedPrompts).toHaveLength(2));
+    const recoveryProgress = activePrompts.get("sid-recovery-limit")!.responseProgress!;
+    await vi.advanceTimersByTimeAsync(recoveryProgress.unchangedSince + 101 - Date.now());
+    await vi.waitFor(() => expect(isSessionRunning("sid-recovery-limit")).toBe(false));
+
+    await vi.advanceTimersByTimeAsync(1_000);
+    expect(receivedPrompts).toHaveLength(2);
+    expect(receivedPrompts[1]).toContain(recoveryPrompt);
+    expect(platform.sendText).toHaveBeenCalledWith(
+      "chat-recovery-limit",
+      "⚠️ 自动续跑仍连续 3 分钟没有新回复，本次不再自动继续。",
+    );
+  });
+
+  it("lets /stop cancel a reserved recovery before it starts", async () => {
+    vi.setSystemTime(0);
+    _setResponseStallTimeoutForTest(100);
+    _setResponseStallCheckIntervalForTest(10);
+    _setProcessAliveForTest(() => true);
+
+    const platform = mockPlatform("feishu");
+    setSessionPlatform(platform);
+    bindChatToSession("sid-recovery-stop", "chat-recovery-stop");
+    recordLastActiveChat("sid-recovery-stop", "chat-recovery-stop");
+
+    const receivedPrompts: string[] = [];
+    const adapter: ToolAdapter = {
+      displayName: "Any Agent",
+      sessionDescPrefix: "Agent Session:",
+      createSession: async () => ({ sessionId: "sid-recovery-stop" }),
+      getSessionInfo: async (sid) => ({ sessionId: sid, cwd: "F:\\repo" }),
+      closeSession: async () => {},
+      prompt: async function* (
+        _sid: string,
+        text: string,
+        _cwd: string,
+        signal?: AbortSignal,
+      ) {
+        receivedPrompts.push(text);
+        yield { type: "assistant", blocks: [{ type: "text", text: "" }] };
+        await new Promise<void>((resolve) => {
+          if (signal?.aborted) {
+            resolve();
+            return;
+          }
+          signal?.addEventListener("abort", () => resolve(), { once: true });
+        });
+      },
+    };
+    _setAdapterForToolForTest("claude", adapter);
+
+    const firstRun = runAgentSession(
+      "sid-recovery-stop",
+      "first prompt",
+      platform,
+      "chat-recovery-stop",
+      0,
+      "claude",
+    );
+    await vi.waitFor(() => {
+      expect(activePrompts.get("sid-recovery-stop")?.responseProgress).toBeDefined();
+    });
+    const progress = activePrompts.get("sid-recovery-stop")!.responseProgress!;
+    await vi.advanceTimersByTimeAsync(progress.unchangedSince + 101 - Date.now());
+    await firstRun;
+
+    expect(isSessionRunning("sid-recovery-stop")).toBe(true);
+    expect(stopSession("sid-recovery-stop")).toBe(true);
+    await vi.advanceTimersByTimeAsync(500);
+
+    expect(receivedPrompts).toHaveLength(1);
+    expect(isSessionRunning("sid-recovery-stop")).toBe(false);
+  });
 });
 
 describe("unified display loop WeChat delta", () => {

package/src/adapters/adapter-interface.ts

@@ -87,10 +87,17 @@ export type UnifiedBlock =
 // UnifiedStreamMessage — 一次 SDK/CLI 事件对应的归一化消息
 // ---------------------------------------------------------------------------
 
-export interface UnifiedStreamMessage {
-  type: "assistant" | "user" | "system";
-  blocks: UnifiedBlock[];
-}
+export interface UnifiedStreamMessage {
+  type: "assistant" | "user" | "system";
+  blocks: UnifiedBlock[];
+  /**
+   * 适配器确认本事件代表一条完整、权威的最终回复，而不是流式文本片段。
+   *
+   * response-stall 终止与最终事件可能在同一事件循环边界竞态；只有该标记
+   * 为 true 时，上层才允许把已经触发的超时改判为正常完成。
+   */
+  isFinalResponse?: boolean;
+}
 
 // ---------------------------------------------------------------------------
 // CreateSessionResult
@@ -194,4 +201,4 @@ export function parseUserCommand(userText: string): UserCommand {
   if (original.startsWith("/plan")) return { original, mode: "plan" };
   if (original.startsWith("/ask")) return { original, mode: "ask" };
   return { original, mode: null };
-}
+}

package/src/adapters/ccc-adapter.ts

@@ -96,6 +96,12 @@ export function createCccAdapter(options: CccAdapterOptions = {}): ToolAdapter {
               is_error: event.is_error,
             }],
           };
+        } else if (event.type === "done" && !signal?.aborted) {
+          yield {
+            type: "assistant",
+            blocks: [],
+            isFinalResponse: true,
+          };
         } else if (event.type === "error") {
           throw new Error(event.message);
         }

package/src/adapters/claude-adapter.ts

@@ -57,6 +57,7 @@ interface SdkContentBlock {
 interface SdkMessageLike {
   type?: string;
   subtype?: string;
+  result?: string;
   message?: { content?: SdkContentBlock[] };
   compact_metadata?: {
     trigger?: "manual" | "auto";
@@ -202,6 +203,16 @@ function logMcpConfig(): void {
 }
 
 export function normalizeSdkMessage(msg: SdkMessageLike): UnifiedStreamMessage | null {
+  // SDK result/success 是 Claude 对本轮完整结束的权威确认。文本已经由之前的
+  // assistant 消息累计，因此这里只发送终态信号，避免重复追加 result 文本。
+  if (msg.type === "result" && msg.subtype === "success") {
+    return {
+      type: "assistant",
+      blocks: [],
+      isFinalResponse: true,
+    };
+  }
+
   if (
     (msg.type === "assistant" || msg.type === "user") &&
     msg.message?.content

package/src/adapters/codex-adapter.ts

@@ -139,6 +139,7 @@ export function normalizeCodexMessage(
     return {
       type: "assistant",
       blocks: [{ type: "text", text: msg.item.text }],
+      isFinalResponse: true,
     };
   }
 

package/src/adapters/cursor-adapter.ts

@@ -353,6 +353,7 @@ export function normalizeCursorMessage(
     return {
       type: "assistant",
       blocks: [{ type: "text_final", text: msg.result }],
+      isFinalResponse: true,
     };
   }
 

package/src/orchestrator.ts

@@ -1143,11 +1143,47 @@ export async function handleCommand(
       chatInfo = await platform.getChatInfo(chatId);
       description = chatInfo.description;
       const sessionInfo = platform.extractSessionInfo(description);
-      if (sessionInfo) {
-        sessionId = sessionInfo.sessionId;
-        descriptionTool = sessionInfo.tool;
-        toolLabel = toolDisplayName(descriptionTool);
-      }
+      if (sessionInfo) {
+        sessionId = sessionInfo.sessionId;
+        descriptionTool = sessionInfo.tool;
+        toolLabel = toolDisplayName(descriptionTool);
+
+        // 群描述是群聊会话路由的权威来源。历史群可能早于 registry 创建，
+        // 或在冷启动时没有被重建进内存映射；若只解析 sessionId 而不补绑定，
+        // prompt 虽能启动，却找不到生成卡片目标，收尾也无法清除 running。
+        const registry = await loadSessionRegistryForBinding();
+        const record = registry[chatId];
+        if (record?.sessionId && record.sessionId !== sessionId) {
+          unbindChatFromSession(record.sessionId, chatId);
+        }
+        bindChatToSession(sessionId, chatId);
+
+        const memoryInfo = sessionInfoMap.get(chatId);
+        if (!memoryInfo || memoryInfo.sessionId !== sessionId) {
+          sessionInfoMap.set(chatId, {
+            sessionId,
+            tool: descriptionTool,
+            turnCount: record?.sessionId === sessionId ? record.turnCount : 0,
+            lastContextTokens:
+              record?.sessionId === sessionId ? record.lastContextTokens : 0,
+            startTime:
+              record?.sessionId === sessionId
+                ? record.startTime
+                : Date.now(),
+          });
+        }
+
+        // 同步自愈持久化记录，使下一次重启可以直接重建绑定。running 取实际
+        // 内存状态，顺便修复旧故障遗留的 stale running=true。
+        await recordSessionRegistry({
+          chatId,
+          sessionId,
+          tool: descriptionTool,
+          chatType,
+          chatName: chatInfo.name,
+          running: isSessionRunning(sessionId),
+        });
+      }
     } catch (err) {
       logTrace(tid, "BRANCH", {
         reason: "get_chat_info_failed",

package/src/session-chat-binding.ts

@@ -57,9 +57,17 @@ export function hasChatsForSession(sessionId: string): boolean {
 // 也必须阻止下一轮提前进入，否则旧会话的落盘可能覆盖新会话绑定。
 const finalizingSessions = new Set<string>();
 
-/** 检查 sessionId 是否有活跃 prompt 或正在完成本轮异步收尾。 */
+// response-stall 自动恢复预约只存在于当前进程内：用户已明确 ChatCCC 重启后
+// 不需要补发恢复 prompt。预约从检测到第一次停滞起一直持有到恢复轮同步进入
+// runAgentSession，填补旧轮收尾和新轮 activePrompts.set 之间的空窗，保证此时
+// 到达的普通用户消息只能进入缓存队列，不能抢在恢复 prompt 前执行。
+const autoRecoveryReservations = new Set<string>();
+
+/** 检查 sessionId 是否有活跃 prompt、正在收尾或已预约自动恢复。 */
 export function isSessionRunning(sessionId: string): boolean {
-  return activePrompts.has(sessionId) || finalizingSessions.has(sessionId);
+  return activePrompts.has(sessionId)
+    || finalizingSessions.has(sessionId)
+    || autoRecoveryReservations.has(sessionId);
 }
 
 export function markSessionFinalizing(sessionId: string): void {
@@ -69,6 +77,27 @@ export function markSessionFinalizing(sessionId: string): void {
 export function clearSessionFinalizing(sessionId: string): void {
   finalizingSessions.delete(sessionId);
 }
+
+/** 为 response-stall 后的内部恢复轮预留下一次执行权。 */
+export function reserveAutoRecovery(sessionId: string): boolean {
+  if (autoRecoveryReservations.has(sessionId)) return false;
+  autoRecoveryReservations.add(sessionId);
+  return true;
+}
+
+/** 恢复轮启动前原子消费预约；返回 false 表示已被 /stop 取消。 */
+export function consumeAutoRecoveryReservation(sessionId: string): boolean {
+  return autoRecoveryReservations.delete(sessionId);
+}
+
+/** 取消尚未启动的恢复轮。 */
+export function cancelAutoRecoveryReservation(sessionId: string): boolean {
+  return autoRecoveryReservations.delete(sessionId);
+}
+
+export function hasAutoRecoveryReservation(sessionId: string): boolean {
+  return autoRecoveryReservations.has(sessionId);
+}
 
 // ---------------------------------------------------------------------------
 // activePrompts: sessionId → 活跃 prompt 控制
@@ -92,6 +121,10 @@ export interface ActivePrompt {
   abnormalExitNotified?: boolean;
   /** Set when the resource monitor detects CPU + memory unchanged for 3 minutes. */
   resourceStuck?: boolean;
+  /** True only for the single internal continuation turn after a response stall. */
+  autoRecovery?: boolean;
+  /** Adapter observed an authoritative completed final-response event. */
+  finalResponseObserved?: boolean;
   /** Adapter-provided callback to close the underlying SDK session / subprocess.
    *  Called by stop-stuck-loop before controller.abort() to terminate the CLI
    *  process immediately, rather than waiting for the async generator to unblock. */
@@ -245,6 +278,7 @@ export function resetBindingState(): void {
   }
   activePrompts.clear();
   finalizingSessions.clear();
+  autoRecoveryReservations.clear();
   queuedMessages.clear();
   displayCards.clear();
   if (unifiedDisplayLoopHandle !== null) {

package/src/session.ts

@@ -77,6 +77,10 @@ import {
   consumeQueuePreservedChat,
   markSessionFinalizing,
   clearSessionFinalizing,
+  reserveAutoRecovery,
+  consumeAutoRecoveryReservation,
+  cancelAutoRecoveryReservation,
+  hasAutoRecoveryReservation,
 } from "./session-chat-binding.ts";
 
 async function sendFinalReplyTextOnce(
@@ -161,6 +165,12 @@ 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;
+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 分钟没有新回复，本次不再自动继续。";
+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;
@@ -966,22 +976,41 @@ export async function resumeAndPrompt(
   return runAgentSession(sessionId, userText, platform, chatId, msgTimestamp, tool, traceId);
 }
 
-// ---------------------------------------------------------------------------
-// runAgentSession — session 中心的 agent prompt（文件持久化 + display 解耦）
-// ---------------------------------------------------------------------------
-
-export async function runAgentSession(
-  sessionId: string,
-  userText: string,
-  platform: PlatformAdapter,
-  _chatId: string,
-  msgTimestamp: number,
-  tool: string,
-  traceId?: string,
-): Promise<void> {
-  const tid = traceId ?? "";
-
-  // 记录用户最后发送消息的群（display loop 只推送到该群）
+// ---------------------------------------------------------------------------
+// runAgentSession — session 中心的 agent prompt（文件持久化 + display 解耦）
+// ---------------------------------------------------------------------------
+
+interface RunAgentSessionOptions {
+  /**
+   * 标记本轮是 response-stall 后的唯一一次内部续跑。若本轮再次因相同原因
+   * 停滞，不再递归创建第三轮，避免服务异常期间无限消耗 token。
+   */
+  autoRecovery?: boolean;
+}
+
+export async function runAgentSession(
+  sessionId: string,
+  userText: string,
+  platform: PlatformAdapter,
+  _chatId: string,
+  msgTimestamp: number,
+  tool: string,
+  traceId?: string,
+  options: RunAgentSessionOptions = {},
+): Promise<void> {
+  const tid = traceId ?? "";
+
+  // runAgentSession 是飞书用户消息、队列消息与内部自动恢复共同使用的唯一
+  // prompt 执行入口。即使冷启动后的历史群只靠群描述解析出 sessionId、registry
+  // 尚未重建出内存映射，也必须在任何异步操作前补齐绑定，确保三种来源都有完全
+  // 相同的卡片、状态和收尾行为。
+  const previousSessionId = sessionInfoMap.get(_chatId)?.sessionId;
+  if (previousSessionId && previousSessionId !== sessionId) {
+    unbindChatFromSession(previousSessionId, _chatId);
+  }
+  bindChatToSession(sessionId, _chatId);
+
+  // 记录用户最后发送消息的群（display loop 只推送到该群）
   // 如果是从队列消费且队列消息来自其他群，保留原来的 display chat
   recordChatPlatform(_chatId, platform);
   recordLastActiveChat(sessionId, consumeQueuePreservedChat(sessionId) ?? _chatId);
@@ -1002,11 +1031,13 @@ export async function runAgentSession(
   // 注意：下面的 try/catch 在准备失败时会清理 activePrompts。
   const controller = new AbortController();
   const now = Date.now();
-  activePrompts.set(sessionId, {
-    controller,
-    stopped: false,
-    startTime: now,
-  });
+  activePrompts.set(sessionId, {
+    controller,
+    stopped: false,
+    startTime: now,
+    autoRecovery: options.autoRecovery === true,
+    finalResponseObserved: false,
+  });
 
   // 资源监控僵死检测：CPU + 内存连续 3 分钟无变化 → 强制停止
   const onResourceStuck = (data: { pid: number; sessionId: string; idleMinutes: number }) => {
@@ -1250,6 +1281,7 @@ export async function runAgentSession(
         || current.abnormalExit
         || current.resourceStuck
         || current.autoEnded
+        || current.finalResponseObserved
         || activityTracker.activity.kind !== "responding"
         || !hasResponseStalled(current.responseProgress, Date.now(), responseStallTimeoutMs)
       ) {
@@ -1257,6 +1289,13 @@ export async function runAgentSession(
       }
 
       const autoEndedAt = Date.now();
+      // 普通轮第一次因回复停滞结束时，立即预约同 session 的内部续跑。
+      // 预约先于 abort/收尾建立，isSessionRunning 会在整个交接窗口保持 true，
+      // 因此恰好到达的用户消息只能排队，绝不可能抢在恢复 prompt 前。
+      // 若当前已经是恢复轮，则不再预约第三轮。
+      if (!current.autoRecovery) {
+        reserveAutoRecovery(sessionId);
+      }
       current.autoEnded = true;
       current.autoEndedAt = autoEndedAt;
       clearPromptResponseStallMonitor(sessionId);
@@ -1279,6 +1318,18 @@ export async function runAgentSession(
         autoEndedAt,
       });
 
+      // 最终事件可能在上面的落盘 I/O 期间到达。只有适配器明确标记的完整
+      // final response 才能赢得这场竞态；普通文本片段绝不能取消超时。
+      if (current.finalResponseObserved) {
+        current.autoEnded = false;
+        current.autoEndedAt = undefined;
+        cancelAutoRecoveryReservation(sessionId);
+        console.log(
+          `[${ts()}] [RESPONSE-STALL] Authoritative final response won timeout race for ${sessionId}`,
+        );
+        return;
+      }
+
       try {
         current.closeSession?.();
       } catch (err) {
@@ -1310,11 +1361,20 @@ export async function runAgentSession(
         clearPromptProcessMonitor(sessionId);
         if (exitInfo.pid !== undefined) unregisterProcess(exitInfo.pid);
       },
-      onSessionCreated: (closeSession) => {
-        const prompt = activePrompts.get(sessionId);
-        if (prompt) prompt.closeSession = closeSession;
-      },
-    })) {
+      onSessionCreated: (closeSession) => {
+        const prompt = activePrompts.get(sessionId);
+        if (prompt) prompt.closeSession = closeSession;
+      },
+    })) {
+      if (unifiedMsg.isFinalResponse) {
+        const prompt = activePrompts.get(sessionId);
+        if (prompt && prompt === runningPrompt) {
+          // 同步标记必须发生在任何 await 之前，让 watchdog 无法在已收到完整
+          // 最终事件后仍把本轮判为停滞。
+          prompt.finalResponseObserved = true;
+        }
+      }
+
       let activityChanged = false;
       for (const block of unifiedMsg.blocks) {
         if (updateAgentActivity(activityTracker, block)) activityChanged = true;
@@ -1375,26 +1435,46 @@ export async function runAgentSession(
     const wasStopped = prompt?.stopped ?? false;
     const wasAbnormalExit = prompt?.abnormalExit ?? false;
     const wasResourceStuck = prompt?.resourceStuck ?? false;
-    const wasAutoEnded = prompt?.autoEnded ?? false;
-    const autoEndedAt = prompt?.autoEndedAt;
+    const timeoutTriggered = prompt?.autoEnded ?? false;
+    const completedAtTimeoutBoundary =
+      timeoutTriggered && (prompt?.finalResponseObserved ?? false);
+    const wasAutoEnded = timeoutTriggered && !completedAtTimeoutBoundary;
+    const wasAutoRecovery = prompt?.autoRecovery ?? false;
+    const autoEndedAt = wasAutoEnded ? prompt?.autoEndedAt : undefined;
     clearPromptResponseStallMonitor(sessionId);
     clearPromptProcessMonitor(sessionId);
     markSessionFinalizing(sessionId);
     activePrompts.delete(sessionId);
 
     try {
-    // 先写最终状态（done/stopped），确保 display loop 在下一轮消费前
-    // 读到新状态并终结旧卡片。否则 setImmediate 在 CHECK 阶段先于
-    // writeFile I/O（POLL 阶段）执行，display loop 会误以为旧轮仍在
-    // 运行中并更新旧卡片，而不是新建卡片。
-    const finalStatus = wasAutoEnded
-      ? "auto_ended"
-      : (streamErrored || wasAbnormalExit || wasResourceStuck)
-        ? "error"
-        : wasStopped
-          ? "stopped"
-          : "done";
-    const finalReply = pickFinalReply(state).trim();
+      if (completedAtTimeoutBoundary) {
+        // reservation 可能在 watchdog 开始终止普通轮时已经建立。最终回复若在
+        // abort/kill 清理边界到达，本轮按完成处理，并原子取消尚未启动的恢复轮。
+        cancelAutoRecoveryReservation(sessionId);
+        console.log(
+          `[${ts()}] [RESPONSE-STALL] Session ${sessionId} completed with an authoritative final response during timeout cleanup`,
+        );
+      }
+      // 即使运行期间映射被异常清空，也必须更新本次实际触发 chat，避免 registry
+      // 永久残留 running=true。
+      const finalizationChatIds = [...new Set([
+        ...getChatsForSession(sessionId),
+        _chatId,
+      ])];
+      // 先写最终状态（done/stopped），确保 display loop 在下一轮消费前
+      // 读到新状态并终结旧卡片。否则 setImmediate 在 CHECK 阶段先于
+      // writeFile I/O（POLL 阶段）执行，display loop 会误以为旧轮仍在
+      // 运行中并更新旧卡片，而不是新建卡片。
+      const finalStatus = completedAtTimeoutBoundary
+        ? "done"
+        : wasAutoEnded
+          ? "auto_ended"
+          : (streamErrored || wasAbnormalExit || wasResourceStuck)
+            ? "error"
+            : wasStopped
+              ? "stopped"
+              : "done";
+      const finalReply = pickFinalReply(state).trim();
 
     // stop-stuck-loop 接口可能在 fire-and-forget 中已写入带 final_reply 的
     // stream state，finally 不应覆盖它。同时保留 stuckAt 标记，防止
@@ -1426,11 +1506,13 @@ export async function runAgentSession(
       ...(preserveStuckAt ? { stuckAt: preserveStuckAt } : {}),
       ...(autoEndedAt !== undefined ? { autoEndedAt } : {}),
     });
-
+
     // display loop 下一轮会读到最终状态并发送消息
-
-    if (wasStopped) {
-      for (const cid of getChatsForSession(sessionId)) {
+
+    let autoRecoveryTarget: { chatId: string; platform: PlatformAdapter } | undefined;
+
+    if (wasStopped) {
+      for (const cid of finalizationChatIds) {
         const finfo = sessionInfoMap.get(cid);
         await recordSessionRegistry({
           chatId: cid,
@@ -1442,7 +1524,7 @@ export async function runAgentSession(
           running: false,
         });
       }
-      const active1 = getLastActiveChat(sessionId) ?? getChatsForSession(sessionId)[0];
+      const active1 = getLastActiveChat(sessionId) ?? finalizationChatIds[0];
       if (active1) {
         await platform.sendText(active1, "会话已停止。").catch(() => {});
         platform.setChatAvatar(active1, tool, "idle").catch(() => {});
@@ -1450,7 +1532,7 @@ export async function runAgentSession(
       console.log(`[${ts()}] Session ${sessionId} stopped (content chunks: ${state.chunkCount})`);
       if (tid) logTrace(tid, "SESSION_END", { sessionId, outcome: "stopped", chunks: state.chunkCount });
     } else if (wasAutoEnded) {
-      for (const cid of getChatsForSession(sessionId)) {
+      for (const cid of finalizationChatIds) {
         const finfo = sessionInfoMap.get(cid);
         await recordSessionRegistry({
           chatId: cid,
@@ -1462,11 +1544,11 @@ export async function runAgentSession(
           running: false,
         });
       }
-      const activeAutoEnded = getLastActiveChat(sessionId) ?? getChatsForSession(sessionId)[0];
+      const activeAutoEnded = getLastActiveChat(sessionId) ?? finalizationChatIds[0];
       if (activeAutoEnded) {
+        const pp = platformForChat(activeAutoEnded) ?? platform;
         const terminalState = await readStreamState(sessionId);
         if (!displayCards.has(activeAutoEnded) && (!terminalState || !isFinalReplySentForTurn(terminalState))) {
-          const pp = platformForChat(activeAutoEnded) ?? platform;
           await sendFinalReplyTextOnce(
             pp,
             activeAutoEnded,
@@ -1475,12 +1557,29 @@ export async function runAgentSession(
             formatAutoEndedReply(finalReplyToWrite),
           );
         }
-        platform.setChatAvatar(activeAutoEnded, tool, "idle").catch(() => {});
+        pp.setChatAvatar(activeAutoEnded, tool, "idle").catch(() => {});
+
+        if (wasAutoRecovery) {
+          // 这是紧接第一次停滞而启动的恢复轮；再次发生相同停滞即终止
+          // 自动链，避免第三轮及之后的无限续跑。
+          await pp.sendText(
+            activeAutoEnded,
+            RESPONSE_STALL_RECOVERY_EXHAUSTED_NOTICE,
+          ).catch(() => {});
+        } else if (hasAutoRecoveryReservation(sessionId)) {
+          // 用户可见提示与内部恢复 prompt 分离：提示发送失败不影响恢复，
+          // 内部恢复仍由 reservation 保证先于普通缓存消息。
+          await pp.sendText(
+            activeAutoEnded,
+            RESPONSE_STALL_RECOVERY_NOTICE,
+          ).catch(() => {});
+          autoRecoveryTarget = { chatId: activeAutoEnded, platform: pp };
+        }
       }
       console.warn(`[${ts()}] Session ${sessionId} auto-ended after stalled 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 getChatsForSession(sessionId)) {
+      for (const cid of finalizationChatIds) {
         const finfo = sessionInfoMap.get(cid);
         await recordSessionRegistry({
           chatId: cid,
@@ -1492,12 +1591,12 @@ export async function runAgentSession(
           running: false,
         });
       }
-      const activeErr = getLastActiveChat(sessionId) ?? getChatsForSession(sessionId)[0];
+      const activeErr = getLastActiveChat(sessionId) ?? finalizationChatIds[0];
       if (activeErr) platform.setChatAvatar(activeErr, tool, "idle").catch(() => {});
       console.log(`[${ts()}] Session ${sessionId} process exited unexpectedly (content chunks: ${state.chunkCount})`);
       if (tid) logTrace(tid, "SESSION_END", { sessionId, outcome: "process_missing", chunks: state.chunkCount });
-    } else {
-      for (const cid of getChatsForSession(sessionId)) {
+    } else {
+      for (const cid of finalizationChatIds) {
         const finfo = sessionInfoMap.get(cid);
         await recordSessionRegistry({
           chatId: cid,
@@ -1509,7 +1608,7 @@ export async function runAgentSession(
           running: false,
         });
       }
-      const active2 = getLastActiveChat(sessionId) ?? getChatsForSession(sessionId)[0];
+      const active2 = getLastActiveChat(sessionId) ?? finalizationChatIds[0];
       if (active2) {
         const terminalState = await readStreamState(sessionId);
         if (finalReply && !displayCards.has(active2) && (!terminalState || !isFinalReplySentForTurn(terminalState))) {
@@ -1522,6 +1621,18 @@ export async function runAgentSession(
       if (tid) logTrace(tid, "SESSION_END", { sessionId, chunks: state.chunkCount, finalTextLen: finalReply.length });
     }
 
+    // 失去聊天绑定时无法安全选择恢复轮的展示目标，取消本次进程内预约。
+    if (
+      wasAutoEnded
+      && hasAutoRecoveryReservation(sessionId)
+      && !autoRecoveryTarget
+    ) {
+      cancelAutoRecoveryReservation(sessionId);
+    }
+    const shouldScheduleAutoRecovery =
+      autoRecoveryTarget !== undefined
+      && hasAutoRecoveryReservation(sessionId);
+
     // 必须等本轮最终卡片、registry 和头像全部收尾后再取出并调度队列消息。
     // 在收尾期间新到达的消息也会因 finalizingSessions 被正确排入这里。
     let queuedForConsumption: ReturnType<typeof dequeueMessage> = undefined;
@@ -1530,7 +1641,9 @@ export async function runAgentSession(
       if (discarded) {
         console.log(`[${ts()}] [QUEUE] Discarding queued message for stopped session ${sessionId}`);
       }
-    } else {
+    } else if (!shouldScheduleAutoRecovery) {
+      // 第一次 response-stall 后保留普通缓存；恢复轮结束后由恢复轮的
+      // finally 再消费，顺序固定为“自动恢复 → 用户缓存”。
       queuedForConsumption = dequeueMessage(sessionId);
     }
 
@@ -1548,7 +1661,48 @@ export async function runAgentSession(
       // 足够时间读到最终状态并终结旧卡片，避免新轮更新旧卡片。
       setTimeout(() => {
         consumeQueuedMessage(platform, queued);
-      }, 200);
+      }, RESPONSE_STALL_RECOVERY_DELAY_MS);
+    }
+
+    if (shouldScheduleAutoRecovery && autoRecoveryTarget) {
+      const target = autoRecoveryTarget;
+      console.log(
+        `[${ts()}] [RESPONSE-STALL] Reserved automatic recovery for session ${sessionId}`,
+      );
+      // 延迟与普通队列原有策略一致，让上一轮终态先完成展示。reservation
+      // 在定时器等待期间仍令 isSessionRunning=true；调用 runAgentSession
+      // 时会在首次 await 前同步写入 activePrompts，然后才消费 reservation，
+      // 因而不存在普通用户消息可插入的事件循环空窗。
+      setTimeout(() => {
+        if (!hasAutoRecoveryReservation(sessionId)) return;
+        const recoveryRun = runAgentSession(
+          sessionId,
+          RESPONSE_STALL_RECOVERY_PROMPT,
+          target.platform,
+          target.chatId,
+          Date.now(),
+          tool,
+          undefined,
+          { autoRecovery: true },
+        );
+        consumeAutoRecoveryReservation(sessionId);
+        void recoveryRun.catch((err) => {
+          console.error(
+            `[${ts()}] [RESPONSE-STALL] Automatic recovery failed for ${sessionId}: ${(err as Error).message}`,
+          );
+          target.platform.sendText(
+            target.chatId,
+            `⚠️ 自动续跑启动失败：${(err as Error).message}`,
+          ).catch(() => {});
+
+          // 若恢复轮在进入主 stream try/finally 前即准备失败，它不会自然
+          // 消费此前保留的用户缓存；在错误回调中补做一次，避免队列悬挂。
+          const queued = dequeueMessage(sessionId);
+          if (queued) {
+            consumeQueuedMessage(target.platform, queued);
+          }
+        });
+      }, RESPONSE_STALL_RECOVERY_DELAY_MS);
     }
     } finally {
       clearSessionFinalizing(sessionId);
@@ -1910,9 +2064,19 @@ export function stopUnifiedDisplayLoop(): void {
 //    虽然很快但仍是异步，期间 display loop 可能多读到 1–2 帧 "running"，
 //    用户体验上"按下停止后还要等几秒卡片才变成已停止"。先把状态标好，
 //    finally 后续再写一次也不冲突——status 最终值仍然是 stopped。
-export function stopSession(sessionId: string): boolean {
-  const prompt = activePrompts.get(sessionId);
-  if (!prompt) return false;
+export function stopSession(sessionId: string): boolean {
+  // /stop 拥有高于内部自动恢复的优先级。旧轮已经完成、恢复轮尚在 200ms
+  // 预约窗口时 activePrompts 为空，因此必须单独取消 reservation。
+  const cancelledRecovery = cancelAutoRecoveryReservation(sessionId);
+  const prompt = activePrompts.get(sessionId);
+  if (!prompt) {
+    if (cancelledRecovery) {
+      cancelQueuedMessage(sessionId);
+      console.log(`[${ts()}] [STOP] Reserved automatic recovery for ${sessionId} cancelled`);
+      return true;
+    }
+    return false;
+  }
   prompt.stopped = true;
   clearPromptResponseStallMonitor(sessionId);
   clearPromptProcessMonitor(sessionId);