chatccc 0.2.93 → 0.2.95

package/package.json

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

package/src/__tests__/session.test.ts

@@ -4,17 +4,63 @@ import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 
 // mock stream-state 以支持在测试中控制累积长度
-const mockStreamStates = new Map<string, { accumulatedContent: string; finalReply: string; status?: "running" | "done" | "stopped" }>();
+const mockStreamStates = new Map<string, {
+  accumulatedContent: string;
+  finalReply: string;
+  status?: "running" | "done" | "stopped" | "error";
+  turnCount?: number;
+  finalReplySentTurn?: number;
+  finalReplySentAt?: number;
+}>();
 vi.mock("../stream-state.ts", () => ({
   readStreamState: async (sid: string) => {
     const state = mockStreamStates.get(sid);
     if (!state) return null;
-    return { sessionId: sid, accumulatedContent: state.accumulatedContent, finalReply: state.finalReply, status: state.status ?? "running", chunkCount: 0, turnCount: 0, contextTokens: 0, updatedAt: Date.now(), cwd: "", tool: "claude" };
+    return {
+      sessionId: sid,
+      accumulatedContent: state.accumulatedContent,
+      finalReply: state.finalReply,
+      finalReplySentTurn: state.finalReplySentTurn,
+      finalReplySentAt: state.finalReplySentAt,
+      status: state.status ?? "running",
+      chunkCount: 0,
+      turnCount: state.turnCount ?? 0,
+      contextTokens: 0,
+      updatedAt: Date.now(),
+      cwd: "",
+      tool: "claude",
+    };
+  },
+  writeStreamState: async (state: {
+    sessionId: string;
+    accumulatedContent: string;
+    finalReply: string;
+    status?: "running" | "done" | "stopped" | "error";
+    turnCount?: number;
+    finalReplySentTurn?: number;
+    finalReplySentAt?: number;
+  }) => {
+    mockStreamStates.set(state.sessionId, {
+      accumulatedContent: state.accumulatedContent,
+      finalReply: state.finalReply,
+      status: state.status,
+      turnCount: state.turnCount,
+      finalReplySentTurn: state.finalReplySentTurn,
+      finalReplySentAt: state.finalReplySentAt,
+    });
   },
-  writeStreamState: async () => {},
   createEmptyStreamState: (sid: string, cwd: string, tool: string, turnCount: number) => ({
     sessionId: sid, status: "running" as const, accumulatedContent: "", finalReply: "", chunkCount: 0, turnCount, contextTokens: 0, updatedAt: Date.now(), cwd, tool,
   }),
+  isFinalReplySentForTurn: (state: { turnCount: number; finalReplySentTurn?: number }) => state.finalReplySentTurn === state.turnCount,
+  markFinalReplySent: async (sid: string, turnCount: number, sentAt = Date.now()) => {
+    const state = mockStreamStates.get(sid);
+    if (!state) return;
+    if ((state.turnCount ?? 0) !== turnCount) return;
+    if ((state.status ?? "running") === "running") return;
+    state.finalReplySentTurn = turnCount;
+    state.finalReplySentAt = sentAt;
+  },
   fixStaleStreamStates: async () => {},
 }));
 import {
@@ -41,8 +87,13 @@ import {
   setSessionPlatform,
   recordChatPlatform,
   _getPlatformForChatForTest,
+  runAgentSession,
   startUnifiedDisplayLoop,
   stopUnifiedDisplayLoop,
+  _setProcessAliveForTest,
+  _resetProcessAliveForTest,
+  _setProcessMonitorIntervalForTest,
+  _resetProcessMonitorIntervalForTest,
 } from "../session.ts";
 import {
   activePrompts,
@@ -56,7 +107,7 @@ import {
   displayCards,
 } from "../session-chat-binding.ts";
 import type { AccumulatorState } from "../session.ts";
-import type { ToolAdapter, UnifiedBlock, SessionInfo } from "../adapters/adapter-interface.ts";
+import type { ToolAdapter, ToolPromptOptions, UnifiedBlock, SessionInfo } from "../adapters/adapter-interface.ts";
 import type { PlatformAdapter } from "../platform-adapter.ts";
 
 // Helper to create a mock active session entry
@@ -185,6 +236,168 @@ describe("chat platform routing", () => {
 // processedMessages 全部保留——SDK 重连不应当影响后台 prompt 的执行。
 // ---------------------------------------------------------------------------
 
+describe("runAgentSession previous final delivery guard", () => {
+  let registryFile = "";
+  let toolsFile = "";
+
+  beforeEach(async () => {
+    resetState();
+    resetBindingState();
+    mockStreamStates.clear();
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-final-guard-"));
+    registryFile = join(dir, "session-registry.json");
+    toolsFile = join(dir, "session-tools.json");
+    _setSessionRegistryFileForTest(registryFile);
+    _setSessionToolsFileForTest(toolsFile);
+    _setAdapterForToolForTest(
+      "claude",
+      mockAdapter((sid) => ({ sessionId: sid, cwd: "/tmp" })),
+    );
+  });
+
+  afterEach(() => {
+    _resetSessionRegistryFileForTest();
+    _resetSessionToolsFileForTest();
+    _clearAdapterCacheForTest();
+    resetBindingState();
+  });
+
+  it("does not resend the previous terminal final when the same turn is already marked sent", async () => {
+    const platform = mockPlatform("feishu");
+    setSessionPlatform(platform);
+    bindChatToSession("sid-final", "chat-final");
+    recordLastActiveChat("sid-final", "chat-final");
+    sessionInfoMap.set("chat-final", {
+      sessionId: "sid-final",
+      turnCount: 1,
+      lastContextTokens: 0,
+      startTime: 0,
+      tool: "claude",
+    });
+    mockStreamStates.set("sid-final", {
+      accumulatedContent: "",
+      finalReply: "old final",
+      status: "done",
+      turnCount: 1,
+      finalReplySentTurn: 1,
+    });
+
+    await runAgentSession("sid-final", "next prompt", platform, "chat-final", Date.now(), "claude");
+
+    expect(platform.sendText).not.toHaveBeenCalledWith("chat-final", "old final");
+  });
+
+  it("resends the previous terminal final when there is no delivery marker", async () => {
+    const platform = mockPlatform("feishu");
+    setSessionPlatform(platform);
+    bindChatToSession("sid-unsent", "chat-unsent");
+    recordLastActiveChat("sid-unsent", "chat-unsent");
+    sessionInfoMap.set("chat-unsent", {
+      sessionId: "sid-unsent",
+      turnCount: 1,
+      lastContextTokens: 0,
+      startTime: 0,
+      tool: "claude",
+    });
+    mockStreamStates.set("sid-unsent", {
+      accumulatedContent: "",
+      finalReply: "old final",
+      status: "done",
+      turnCount: 1,
+    });
+
+    await runAgentSession("sid-unsent", "next prompt", platform, "chat-unsent", Date.now(), "claude");
+
+    expect(platform.sendText).toHaveBeenCalledWith("chat-unsent", "old final");
+  });
+});
+
+describe("runAgentSession process monitor", () => {
+  let registryFile = "";
+  let toolsFile = "";
+
+  beforeEach(async () => {
+    vi.useFakeTimers();
+    resetState();
+    resetBindingState();
+    mockStreamStates.clear();
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-process-monitor-"));
+    registryFile = join(dir, "session-registry.json");
+    toolsFile = join(dir, "session-tools.json");
+    _setSessionRegistryFileForTest(registryFile);
+    _setSessionToolsFileForTest(toolsFile);
+    _setProcessMonitorIntervalForTest(50);
+  });
+
+  afterEach(() => {
+    _resetSessionRegistryFileForTest();
+    _resetSessionToolsFileForTest();
+    _clearAdapterCacheForTest();
+    _resetProcessAliveForTest();
+    _resetProcessMonitorIntervalForTest();
+    resetBindingState();
+    vi.useRealTimers();
+  });
+
+  it("marks the turn as error and sends a separate notice when the CLI process disappears", async () => {
+    const platform = mockPlatform("feishu");
+    setSessionPlatform(platform);
+    bindChatToSession("sid-process", "chat-process");
+    recordLastActiveChat("sid-process", "chat-process");
+    _setProcessAliveForTest(() => false);
+
+    const adapter: ToolAdapter = {
+      displayName: "Cursor",
+      sessionDescPrefix: "Cursor Session:",
+      createSession: async () => ({ sessionId: "sid-process" }),
+      getSessionInfo: async (sid) => ({ sessionId: sid, cwd: "/tmp" }),
+      closeSession: async () => {},
+      prompt: async function* (
+        _sid: string,
+        _text: string,
+        _cwd: string,
+        signal?: AbortSignal,
+        options?: ToolPromptOptions,
+      ) {
+        options?.onProcessStart?.({ pid: 12345 });
+        yield { type: "assistant", blocks: [{ type: "text", text: "partial answer" }] };
+        await new Promise<void>((resolve) => {
+          if (signal?.aborted) {
+            resolve();
+            return;
+          }
+          signal?.addEventListener("abort", () => resolve(), { once: true });
+        });
+      },
+    };
+    _setAdapterForToolForTest("cursor", adapter);
+
+    const runPromise = runAgentSession(
+      "sid-process",
+      "prompt",
+      platform,
+      "chat-process",
+      Date.now(),
+      "cursor",
+    );
+
+    await vi.waitFor(() => {
+      expect(activePrompts.get("sid-process")?.processPid).toBe(12345);
+    });
+    await vi.advanceTimersByTimeAsync(60);
+    await runPromise;
+
+    const state = mockStreamStates.get("sid-process");
+    expect(state?.status).toBe("error");
+    expect(state?.finalReply).toContain("partial answer");
+    expect(activePrompts.has("sid-process")).toBe(false);
+    expect(platform.sendText).toHaveBeenCalledWith(
+      "chat-process",
+      expect.stringContaining("进程异常结束"),
+    );
+  });
+});
+
 describe("unified display loop WeChat delta", () => {
   beforeEach(() => {
     vi.useFakeTimers();
@@ -1004,6 +1217,7 @@ describe("switchChatBinding", () => {
     displayCards.set("chat-1", {
       cardId: "c1", sequence: 1, cardBusy: false,
       cardCreatedAt: 0, lastSentContent: "", streamErrorNotified: false,
+      sessionId: "old-sid", turnCount: 5, dotCount: 0,
     });
 
     const result = await switchChatBinding({
@@ -1068,6 +1282,7 @@ describe("switchChatBinding", () => {
     const oldDisplay = {
       cardId: "c1", sequence: 1, cardBusy: false,
       cardCreatedAt: 0, lastSentContent: "", streamErrorNotified: false,
+      sessionId: "old-sid", turnCount: 5, dotCount: 0,
     };
     displayCards.set("chat-1", oldDisplay);
 

package/src/__tests__/stream-state.test.ts

@@ -15,10 +15,12 @@ vi.mock("../config.ts", async () => {
 });
 
 const {
-  writeStreamState,
-  readStreamState,
-  createEmptyStreamState,
-  STREAMS_DIR,
+  writeStreamState,
+  readStreamState,
+  createEmptyStreamState,
+  isFinalReplySentForTurn,
+  markFinalReplySent,
+  STREAMS_DIR,
   _setRenameForTest,
   _resetRenameForTest,
 } = await import("../stream-state.ts");
@@ -117,9 +119,36 @@ describe("writeStreamState — atomic rename", () => {
     const got = await readStreamState("never-existed");
     expect(got).toBeNull();
   });
-});
-
-describe("createEmptyStreamState", () => {
+  it("marks final reply delivery for the matching terminal turn only", async () => {
+    const state = createEmptyStreamState("sid-delivered", "/tmp", "claude", 2);
+    state.status = "done";
+    state.finalReply = "done";
+    await writeStreamState(state);
+
+    await markFinalReplySent("sid-delivered", 2, 12345);
+
+    const got = await readStreamState("sid-delivered");
+    expect(got).not.toBeNull();
+    expect(got!.finalReplySentTurn).toBe(2);
+    expect(got!.finalReplySentAt).toBe(12345);
+    expect(isFinalReplySentForTurn(got!)).toBe(true);
+  });
+
+  it("does not mark a running state or a different turn as delivered", async () => {
+    const state = createEmptyStreamState("sid-running", "/tmp", "claude", 3);
+    await writeStreamState(state);
+
+    await markFinalReplySent("sid-running", 2, 12345);
+    await markFinalReplySent("sid-running", 3, 12345);
+
+    const got = await readStreamState("sid-running");
+    expect(got).not.toBeNull();
+    expect(got!.finalReplySentTurn).toBeUndefined();
+    expect(isFinalReplySentForTurn(got!)).toBe(false);
+  });
+});
+
+describe("createEmptyStreamState", () => {
   it("生成的 state 字段正确且 status=running", () => {
     const s = createEmptyStreamState("sid-X", "/cwd", "cursor", 5);
     expect(s.sessionId).toBe("sid-X");
@@ -127,8 +156,9 @@ describe("createEmptyStreamState", () => {
     expect(s.tool).toBe("cursor");
     expect(s.turnCount).toBe(5);
     expect(s.status).toBe("running");
-    expect(s.accumulatedContent).toBe("");
-    expect(s.finalReply).toBe("");
-    expect(s.chunkCount).toBe(0);
-  });
-});
+    expect(s.accumulatedContent).toBe("");
+    expect(s.finalReply).toBe("");
+    expect(s.finalReplySentTurn).toBeUndefined();
+    expect(s.chunkCount).toBe(0);
+  });
+});

package/src/adapters/adapter-interface.ts

@@ -113,6 +113,18 @@ export interface SessionInfo {
   model?: string;
 }
 
+export interface ToolProcessInfo {
+  /** Root PID returned by child_process.spawn. With shell:true this is the shell wrapper PID. */
+  pid: number;
+}
+
+export interface ToolPromptOptions {
+  /** Called once a CLI-backed prompt process has been spawned. */
+  onProcessStart?: (info: ToolProcessInfo) => void;
+  /** Called when the adapter leaves the prompt process scope normally or by abort. */
+  onProcessExit?: (info: ToolProcessInfo) => void;
+}
+
 // ---------------------------------------------------------------------------
 // ToolAdapter — 统一的 AI 工具适配器接口
 // ---------------------------------------------------------------------------
@@ -139,6 +151,7 @@ export interface ToolAdapter {
     userText: string,
     cwd: string,
     signal?: AbortSignal,
+    options?: ToolPromptOptions,
   ): AsyncIterable<UnifiedStreamMessage>;
 
   /**

package/src/adapters/codex-adapter.ts

@@ -13,6 +13,7 @@ import { randomUUID } from "node:crypto";
 
 import type {
   ToolAdapter,
+  ToolPromptOptions,
   UnifiedBlock,
   UnifiedStreamMessage,
   CreateSessionResult,
@@ -238,6 +239,7 @@ class CodexAdapter implements ToolAdapter {
     userText: string,
     cwd: string,
     signal?: AbortSignal,
+    options?: ToolPromptOptions,
   ): AsyncIterable<UnifiedStreamMessage> {
     let meta = await this.metaStore.get(sessionId);
     const threadId = meta?.threadId;
@@ -250,6 +252,7 @@ class CodexAdapter implements ToolAdapter {
       : [...CODEX_BASE_ARGS, "resume", threadId, "-"];
 
     const proc = spawnCodex(args, cwd, userText);
+    if (proc.pid !== undefined) options?.onProcessStart?.({ pid: proc.pid });
 
     // 关键：spawn 用了 shell:true，proc.pid 指向的是壳进程（cmd.exe / sh）。
     // 真正干活的是壳的孙子 codex.exe。普通 proc.kill() 在 Windows 上只杀第一层，
@@ -278,6 +281,7 @@ class CodexAdapter implements ToolAdapter {
     } finally {
       signal?.removeEventListener("abort", onAbort);
       await killProcessTree(proc.pid);
+      if (proc.pid !== undefined) options?.onProcessExit?.({ pid: proc.pid });
     }
   }
 

package/src/adapters/cursor-adapter.ts

@@ -10,6 +10,7 @@ import { createInterface } from "node:readline";
 
 import type {
   ToolAdapter,
+  ToolPromptOptions,
   UnifiedBlock,
   UnifiedStreamMessage,
   CreateSessionResult,
@@ -354,10 +355,12 @@ class CursorAdapter implements ToolAdapter {
     userText: string,
     cwd: string,
     signal?: AbortSignal,
+    options?: ToolPromptOptions,
   ): AsyncIterable<UnifiedStreamMessage> {
     console.log(`[Cursor debug] prompt start: sessionId=${sessionId}, cwd=${cwd}, userTextLen=${userText.length}`);
     const proc = spawnAgent(["--resume", sessionId], cwd, userText);
     this.activeProcs.add(proc);
+    if (proc.pid !== undefined) options?.onProcessStart?.({ pid: proc.pid });
 
     // 见 codex-adapter.ts 同位置注释：spawn 用了 shell:true，必须杀整棵树，
     // 否则 abort 后真正在跑的孙进程 cursor-agent 还会继续输出 & 占用资源。
@@ -384,6 +387,7 @@ class CursorAdapter implements ToolAdapter {
       signal?.removeEventListener("abort", onAbort);
       await killProcessTree(proc.pid);
       this.activeProcs.delete(proc);
+      if (proc.pid !== undefined) options?.onProcessExit?.({ pid: proc.pid });
       console.log(`[Cursor debug] prompt end: sessionId=${sessionId}, signalAborted=${signal?.aborted ?? false}`);
     }
   }

package/src/session-chat-binding.ts

@@ -65,6 +65,12 @@ export interface ActivePrompt {
   controller: AbortController;
   stopped: boolean;
   startTime: number;
+  /** Root PID for the CLI process currently serving this prompt, if the adapter exposes one. */
+  processPid?: number;
+  processMonitor?: ReturnType<typeof setInterval>;
+  /** Set when the watchdog detects that the CLI process disappeared before stream finalization. */
+  abnormalExit?: boolean;
+  abnormalExitNotified?: boolean;
 }
 
 export const activePrompts = new Map<string, ActivePrompt>();
@@ -206,6 +212,9 @@ export function consumeQueuedMessage(platform: PlatformAdapter, msg: QueuedMessa
 export function resetBindingState(): void {
   sessionChatsMap.clear();
   lastActiveChatMap.clear();
+  for (const prompt of activePrompts.values()) {
+    if (prompt.processMonitor) clearInterval(prompt.processMonitor);
+  }
   activePrompts.clear();
   queuedMessages.clear();
   displayCards.clear();

package/src/session.ts

@@ -25,6 +25,7 @@ import { simplifyToolUse, simplifyToolResult } from "./simplify.ts";
 import { logTrace } from "./trace.ts";
 import type { UnifiedBlock } from "./adapters/adapter-interface.ts";
 import type { ToolAdapter } from "./adapters/adapter-interface.ts";
+import type { ToolProcessInfo } from "./adapters/adapter-interface.ts";
 import { createClaudeAdapter } from "./adapters/claude-adapter.ts";
 import { createCursorAdapter } from "./adapters/cursor-adapter.ts";
 import { createCodexAdapter } from "./adapters/codex-adapter.ts";
@@ -37,7 +38,14 @@ function compressWechatDisplayText(text: string): string {
   if (lines.length <= 10) return text;
   return [...lines.slice(0, 5), "...", ...lines.slice(-5)].join("\n");
 }
-import { readStreamState, writeStreamState, createEmptyStreamState, fixStaleStreamStates } from "./stream-state.ts";
+import {
+  readStreamState,
+  writeStreamState,
+  createEmptyStreamState,
+  fixStaleStreamStates,
+  isFinalReplySentForTurn,
+  markFinalReplySent,
+} from "./stream-state.ts";
 import { addCardToTurn, finalizeTurnCards, markCardDone } from "./turn-cards.ts";
 import {
   bindChatToSession,
@@ -59,6 +67,18 @@ import {
   consumeQueuePreservedChat,
 } from "./session-chat-binding.ts";
 
+async function sendFinalReplyTextOnce(
+  platform: PlatformAdapter,
+  chatId: string,
+  sessionId: string,
+  turnCount: number,
+  text: string,
+): Promise<boolean> {
+  const sent = await platform.sendText(chatId, text).then((ok) => ok !== false).catch(() => false);
+  if (sent) await markFinalReplySent(sessionId, turnCount);
+  return sent;
+}
+
 // ---------------------------------------------------------------------------
 // Shared state (imported by index.ts)
 // ---------------------------------------------------------------------------
@@ -95,6 +115,110 @@ function platformForChat(chatId: string): PlatformAdapter | null {
   return chatPlatformMap.get(chatId) ?? platformRef;
 }
 
+const DEFAULT_PROCESS_MONITOR_INTERVAL_MS = 5000;
+let processMonitorIntervalMs = DEFAULT_PROCESS_MONITOR_INTERVAL_MS;
+let isProcessAliveImpl = (pid: number): boolean => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+export function _setProcessAliveForTest(impl: (pid: number) => boolean): void {
+  isProcessAliveImpl = impl;
+}
+
+export function _resetProcessAliveForTest(): void {
+  isProcessAliveImpl = (pid: number): boolean => {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+}
+
+export function _setProcessMonitorIntervalForTest(ms: number): void {
+  processMonitorIntervalMs = ms;
+}
+
+export function _resetProcessMonitorIntervalForTest(): void {
+  processMonitorIntervalMs = DEFAULT_PROCESS_MONITOR_INTERVAL_MS;
+}
+
+function clearPromptProcessMonitor(sessionId: string): void {
+  const prompt = activePrompts.get(sessionId);
+  if (!prompt?.processMonitor) return;
+  clearInterval(prompt.processMonitor);
+  prompt.processMonitor = undefined;
+}
+
+function formatTerminalHeader(status: "running" | "done" | "stopped" | "error"): {
+  title: string;
+  template?: string;
+} {
+  if (status === "stopped") return { title: "已停止", template: "red" };
+  if (status === "error") return { title: "异常结束", template: "red" };
+  return { title: "完成" };
+}
+
+function turnFinalStatus(status: "running" | "done" | "stopped" | "error"): "done" | "stopped" {
+  return status === "stopped" || status === "error" ? "stopped" : "done";
+}
+
+function startPromptProcessMonitor(sessionId: string, info: ToolProcessInfo): void {
+  const prompt = activePrompts.get(sessionId);
+  if (!prompt) return;
+  prompt.processPid = info.pid;
+  clearPromptProcessMonitor(sessionId);
+
+  const check = async () => {
+    const current = activePrompts.get(sessionId);
+    if (!current || current !== prompt) {
+      clearPromptProcessMonitor(sessionId);
+      return;
+    }
+    if (current.stopped || current.abnormalExit) return;
+    if (isProcessAliveImpl(info.pid)) return;
+
+    current.abnormalExit = true;
+    clearPromptProcessMonitor(sessionId);
+
+    const state = await readStreamState(sessionId);
+    if (state?.status === "running") {
+      await writeStreamState({
+        ...state,
+        status: "error",
+        updatedAt: Date.now(),
+      });
+    }
+
+    const chatId = pickDisplayChat(sessionId) ?? getLastActiveChat(sessionId) ?? getChatsForSession(sessionId)[0];
+    const p = chatId ? platformForChat(chatId) : null;
+    if (chatId && p && !current.abnormalExitNotified) {
+      current.abnormalExitNotified = true;
+      await p.sendText(
+        chatId,
+        `⚠️ 进程异常结束：session ${sessionId} 对应的 CLI 进程 PID ${info.pid} 已不存在，已按完成处理。若回复不完整，请重新发送上一条指令。`,
+      ).catch(() => {});
+    }
+
+    // 主动关闭 readline，让 runAgentSession 的 finally 落盘 error 终态并清理 activePrompts。
+    current.controller.abort();
+  };
+
+  const handle = setInterval(() => {
+    void check().catch((err) => {
+      console.warn(`[${ts()}] [PROCESS-MONITOR] check failed for ${sessionId}: ${(err as Error).message}`);
+    });
+  }, processMonitorIntervalMs);
+  handle.unref?.();
+  prompt.processMonitor = handle;
+}
+
 export function _getPlatformForChatForTest(chatId: string): PlatformAdapter | null {
   return platformForChat(chatId);
 }
@@ -170,6 +294,9 @@ export function resetState(): void {
   processedMessages.clear();
   lastMsgTimestamps.clear();
   chatPlatformMap.clear();
+  for (const prompt of activePrompts.values()) {
+    if (prompt.processMonitor) clearInterval(prompt.processMonitor);
+  }
   activePrompts.clear();
   displayCards.clear();
   stopUnifiedDisplayLoop();
@@ -809,27 +936,38 @@ export async function runAgentSession(
       if (display && pp) {
         // 统一 display loop 被 cardBusy 挡住或尚未 tick → 现在终结卡片
         while (display.cardBusy) await new Promise(r => setTimeout(r, 20));
-        const nextSeq = display.sequence + 1;
-        const headerTitle = prevState.status === "stopped" ? "已停止" : "完成";
-        const headerTemplate = prevState.status === "stopped" ? "red" : undefined;
-        const cardContent = truncateContent(prevState.accumulatedContent + prevState.finalReply) || " ";
-        const doneCard = buildProgressCard(cardContent, { showStop: false, headerTitle, headerTemplate });
-        await pp.cardUpdate(display.cardId, doneCard, nextSeq).catch(() => {});
-        displayCards.delete(displayChatId);
-
-        // 持久化：标记上一轮所有卡片为终态
-        const finalStatus = prevState.status === "stopped" ? "stopped" : "done";
-        finalizeTurnCards(sessionId, prevState.turnCount, finalStatus).catch(() => {});
 
-        if (prevState.finalReply) {
-          await pp.sendText(displayChatId, prevState.finalReply).catch(() => {});
+        // 竞态防护：等待期间统一 display loop 的 tick 可能也已读到同一个
+        // terminal state，发送了 finalReply 并删除/替换了 displayCards 条目。
+        // 通过引用比较检测——若统一 loop 已处理则只补持久化和头像，不重复发。
+        if (displayCards.get(displayChatId) !== display) {
+          const finalStatus = turnFinalStatus(prevState.status);
+          finalizeTurnCards(sessionId, prevState.turnCount, finalStatus).catch(() => {});
+          pp.setChatAvatar(displayChatId, prevState.tool, "idle").catch(() => {});
+        } else {
+          const nextSeq = display.sequence + 1;
+          const { title: headerTitle, template: headerTemplate } = formatTerminalHeader(prevState.status);
+          const cardContent = truncateContent(prevState.accumulatedContent + prevState.finalReply) || " ";
+          const doneCard = buildProgressCard(cardContent, { showStop: false, headerTitle, headerTemplate });
+          await pp.cardUpdate(display.cardId, doneCard, nextSeq).catch(() => {});
+          // cardUpdate IO 期间统一 loop 可能也已处理此 display → 删前检查引用
+          const stillOursAfterUpdate = displayCards.get(displayChatId) === display;
+          displayCards.delete(displayChatId);
+
+          // 持久化：标记上一轮所有卡片为终态
+          const finalStatus = turnFinalStatus(prevState.status);
+          finalizeTurnCards(sessionId, prevState.turnCount, finalStatus).catch(() => {});
+
+          if (prevState.finalReply && stillOursAfterUpdate && !isFinalReplySentForTurn(prevState)) {
+            await sendFinalReplyTextOnce(pp, displayChatId, sessionId, prevState.turnCount, prevState.finalReply);
+          }
+          pp.setChatAvatar(displayChatId, prevState.tool, "idle").catch(() => {});
         }
-        pp.setChatAvatar(displayChatId, prevState.tool, "idle").catch(() => {});
-      } else if (pp && prevState.finalReply) {
+      } else if (pp && prevState.finalReply && !isFinalReplySentForTurn(prevState)) {
         // 无 display 记录但上一轮有 finalReply（极快轮次），至少发送
-        const finalStatus = prevState.status === "stopped" ? "stopped" : "done";
+        const finalStatus = turnFinalStatus(prevState.status);
         finalizeTurnCards(sessionId, prevState.turnCount, finalStatus).catch(() => {});
-        await pp.sendText(displayChatId, prevState.finalReply).catch(() => {});
+        await sendFinalReplyTextOnce(pp, displayChatId, sessionId, prevState.turnCount, prevState.finalReply);
       }
       // else: displayCards 无记录且无 finalReply → 无需处理
     }
@@ -897,7 +1035,14 @@ export async function runAgentSession(
   const toolCallMap = new Map<string, { name: string; input: unknown }>();
 
   try {
-    for await (const unifiedMsg of adapter.prompt(sessionId, userTextWithCapabilities, cwd, controller.signal)) {
+    for await (const unifiedMsg of adapter.prompt(sessionId, userTextWithCapabilities, cwd, controller.signal, {
+      onProcessStart: (processInfo) => {
+        startPromptProcessMonitor(sessionId, processInfo);
+      },
+      onProcessExit: () => {
+        clearPromptProcessMonitor(sessionId);
+      },
+    })) {
       for (const block of unifiedMsg.blocks) {
         accumulateBlockContent(block, state, toolCallMap);
 
@@ -940,13 +1085,15 @@ export async function runAgentSession(
     // 标记 prompt 结束
     const prompt = activePrompts.get(sessionId);
     const wasStopped = prompt?.stopped ?? false;
+    const wasAbnormalExit = prompt?.abnormalExit ?? false;
+    clearPromptProcessMonitor(sessionId);
     activePrompts.delete(sessionId);
 
     // 先写最终状态（done/stopped），确保 display loop 在下一轮消费前
     // 读到新状态并终结旧卡片。否则 setImmediate 在 CHECK 阶段先于
     // writeFile I/O（POLL 阶段）执行，display loop 会误以为旧轮仍在
     // 运行中并更新旧卡片，而不是新建卡片。
-    const finalStatus = wasStopped ? "stopped" : "done";
+    const finalStatus = wasAbnormalExit ? "error" : wasStopped ? "stopped" : "done";
     const finalReply = pickFinalReply(state).trim();
     await writeStreamState({
       sessionId,
@@ -1008,6 +1155,23 @@ export async function runAgentSession(
       if (active1) platform.setChatAvatar(active1, tool, "idle").catch(() => {});
       console.log(`[${ts()}] Session ${sessionId} stopped (content chunks: ${state.chunkCount})`);
       if (tid) logTrace(tid, "SESSION_END", { sessionId, outcome: "stopped", chunks: state.chunkCount });
+    } else if (wasAbnormalExit) {
+      for (const cid of getChatsForSession(sessionId)) {
+        const finfo = sessionInfoMap.get(cid);
+        await recordSessionRegistry({
+          chatId: cid,
+          sessionId,
+          tool,
+          turnCount: finfo?.turnCount ?? nextTurnCount,
+          lastContextTokens: finfo?.lastContextTokens ?? nextContextTokens,
+          startTime: finfo?.startTime ?? now,
+          running: false,
+        });
+      }
+      const activeErr = getLastActiveChat(sessionId) ?? getChatsForSession(sessionId)[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)) {
         const finfo = sessionInfoMap.get(cid);
@@ -1092,24 +1256,45 @@ export function startUnifiedDisplayLoop(): void {
                 replyDelta = state.finalReply;
               }
               const remaining = (accDelta + replyDelta).trim();
+
+              // 若 session 仍在 activePrompts 中，说明 runAgentSession 的 finally
+              // 还没执行，当前 stream state 可能是 stopSession fire-and-forget
+              // 写入的，finalReply 滞后于内存态。跳过发送，等 finally 落盘后
+              // 下一次 tick 再处理，避免发送过期内容或与后续发送重复。
+              if (activePrompts.has(sessionId)) continue;
+
               const tail = "━━━ 回答结束 ━━━";
               const finalMsg = remaining ? remaining + "\n" + tail : tail;
-              await p.sendText(chatId, finalMsg).catch(() => {});
+              if (!isFinalReplySentForTurn(state)) {
+                await sendFinalReplyTextOnce(p, chatId, sessionId, state.turnCount, finalMsg);
+              }
               displayCards.delete(chatId);
             } else {
               // 发送最终结果（卡片平台）
               while (display.cardBusy) await new Promise(r => setTimeout(r, 20));
               const nextSeq = display.sequence + 1;
-              const headerTitle = state.status === "stopped" ? "已停止" : "完成";
-              const headerTemplate = state.status === "stopped" ? "red" : undefined;
+              const { title: headerTitle, template: headerTemplate } = formatTerminalHeader(state.status);
               const cardContent = truncateContent(state.accumulatedContent + state.finalReply) || " ";
               const doneCard = buildProgressCard(cardContent, { showStop: false, headerTitle, headerTemplate });
               await p.cardUpdate(display.cardId, doneCard, nextSeq).catch(() => {});
-              const finalSt = state.status === "stopped" ? "stopped" : "done";
+
+              // 若 session 仍在 activePrompts 中，说明 runAgentSession 的 finally
+              // 还没执行，当前 stream state 可能是 stopSession fire-and-forget
+              // 写入的，finalReply 滞后于内存态。卡片已更新为终态外观，但不发送
+              // 文本、不删除 display 条目，留给 finally 落盘后的下一次 tick 处理。
+              if (activePrompts.has(sessionId)) {
+                display.lastSentAccLen = state.accumulatedContent.length;
+                display.lastSentFinalReply = state.finalReply;
+                continue;
+              }
+
+              const finalSt = turnFinalStatus(state.status);
               finalizeTurnCards(sessionId, state.turnCount, finalSt).catch(() => {});
               displayCards.delete(chatId);
               if (state.finalReply) {
-                await p.sendText(chatId, state.finalReply).catch(() => {});
+                if (!isFinalReplySentForTurn(state)) {
+                  await sendFinalReplyTextOnce(p, chatId, sessionId, state.turnCount, state.finalReply);
+                }
               } else if (state.accumulatedContent.trim()) {
                 const short = truncateContent(state.accumulatedContent, 30, 4000);
                 await p.sendText(chatId, `[生成过程]\n${short}`).catch(() => {});
@@ -1165,7 +1350,7 @@ export function startUnifiedDisplayLoop(): void {
                 try {
                   const oldSeqBase = display.sequence;
                   const oldContent = state.accumulatedContent + state.finalReply;
-                  const oldCard = buildProgressCard(truncateContent(oldContent) || " ", { showStop: false, headerTitle: "完成" });
+                  const oldCard = buildProgressCard(truncateContent(oldContent) || " ", { showStop: false, headerTitle: "生成中（上轮）" });
                   await p.cardUpdate(display.cardId, oldCard, oldSeqBase + 1).catch(() => {});
                   markCardDone(sessionId, display.turnCount, display.cardId).catch(() => {});
                   const newCardId = await p.cardCreate(buildProgressCard(
@@ -1290,6 +1475,7 @@ export function stopSession(sessionId: string): boolean {
   const prompt = activePrompts.get(sessionId);
   if (!prompt) return false;
   prompt.stopped = true;
+  clearPromptProcessMonitor(sessionId);
   cancelQueuedMessage(sessionId);
   prompt.controller.abort();
   console.log(`[${ts()}] [STOP] Session ${sessionId} aborted`);
@@ -1381,7 +1567,8 @@ export async function getSessionStatus(chatId: string): Promise<SessionStatus |
   const info = sessionInfoMap.get(chatId);
   if (!info) return null;
 
-  const isActive = activePrompts.has(info.sessionId) && !(activePrompts.get(info.sessionId)?.stopped);
+  const activePrompt = activePrompts.get(info.sessionId);
+  const isActive = !!activePrompt && !activePrompt.stopped && !activePrompt.abnormalExit;
   const { model, effort } = await resolveModelEffort(info.tool, info.sessionId);
 
   const registry = await loadSessionRegistry();
@@ -1456,7 +1643,9 @@ export async function getAllSessionsStatus(): Promise<SessionsListEntry[]> {
         chatId: info.chatId,
         sessionId: info.sessionId,
         chatName: info.chatName || "",
-        active: activePrompts.has(info.sessionId) && !(activePrompts.get(info.sessionId)?.stopped),
+        active: !!activePrompts.get(info.sessionId) &&
+          !activePrompts.get(info.sessionId)?.stopped &&
+          !activePrompts.get(info.sessionId)?.abnormalExit,
         turnCount: info.turnCount,
         startTime: info.startTime,
         model,

package/src/stream-state.ts

@@ -9,14 +9,17 @@ import { USER_DATA_DIR, ts } from "./config.ts";
 
 export const STREAMS_DIR = join(USER_DATA_DIR, "state", "streams");
 
-export interface StreamState {
-  sessionId: string;
-  status: "running" | "done" | "stopped" | "error";
-  accumulatedContent: string;
-  finalReply: string;
-  chunkCount: number;
-  turnCount: number;
-  contextTokens: number;
+export interface StreamState {
+  sessionId: string;
+  status: "running" | "done" | "stopped" | "error";
+  accumulatedContent: string;
+  finalReply: string;
+  /** The turn whose terminal text reply has already been delivered to IM. */
+  finalReplySentTurn?: number;
+  finalReplySentAt?: number;
+  chunkCount: number;
+  turnCount: number;
+  contextTokens: number;
   updatedAt: number;
   cwd: string;
   tool: string;
@@ -71,7 +74,7 @@ export function _resetRenameForTest(): void {
  * 真文件,这一帧可能被 reader 读到半截,但 readStreamState 的 try/catch 兜底
  * 会让 loop 跳过这一帧,2 秒后下次 write 大概率成功——比写盘失败丢数据好。
  */
-export async function writeStreamState(state: StreamState): Promise<void> {
+export async function writeStreamState(state: StreamState): Promise<void> {
   const filePath = getStreamStatePath(state.sessionId);
   const payload = JSON.stringify(state, null, 2);
   try {
@@ -95,10 +98,26 @@ export async function writeStreamState(state: StreamState): Promise<void> {
   } catch (err) {
     console.error(`[${ts()}] Failed to write stream-state for ${state.sessionId}: ${(err as Error).message}`);
   }
-}
-
-export function createEmptyStreamState(sessionId: string, cwd: string, tool: string, turnCount: number): StreamState {
-  return {
+}
+
+export function isFinalReplySentForTurn(state: Pick<StreamState, "turnCount" | "finalReplySentTurn">): boolean {
+  return state.finalReplySentTurn === state.turnCount;
+}
+
+export async function markFinalReplySent(sessionId: string, turnCount: number, sentAt = Date.now()): Promise<void> {
+  const state = await readStreamState(sessionId);
+  if (!state) return;
+  if (state.turnCount !== turnCount) return;
+  if (state.status === "running") return;
+
+  state.finalReplySentTurn = turnCount;
+  state.finalReplySentAt = sentAt;
+  state.updatedAt = Date.now();
+  await writeStreamState(state);
+}
+
+export function createEmptyStreamState(sessionId: string, cwd: string, tool: string, turnCount: number): StreamState {
+  return {
     sessionId,
     status: "running",
     accumulatedContent: "",
@@ -138,4 +157,4 @@ export async function fixStaleStreamStates(): Promise<void> {
   } catch (err) {
     console.error(`[${ts()}] [STREAM-STATE] fixStaleStreamStates failed: ${(err as Error).message}`);
   }
-}
+}