chatccc 0.2.49 → 0.2.51

package/package.json

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

package/src/__tests__/cards.test.ts

@@ -380,6 +380,14 @@ describe("buildSessionsCard", () => {
     expect(afterPrivateChat).not.toContain("(群聊)");
   });
 
+  it("shows chat id missing for sessions without a chat binding", () => {
+    const card = buildSessionsCard([
+      { sessionId: "orphan", chatName: "", chatId: "", active: true, turnCount: 0, elapsedSeconds: 3, model: "Claude Opus 4.7", tool: "claude" },
+    ]);
+    const content: string = JSON.parse(card).elements[0].text.content;
+    expect(content).toContain("chat id缺失");
+  });
+
   it("includes /session help text in non-empty card", () => {
     const card = buildSessionsCard([
       { sessionId: "abc123", chatName: "", chatId: "oc_abc123", active: false, turnCount: 2, elapsedSeconds: null, model: "Claude Opus 4.7", tool: "claude" },
@@ -446,4 +454,4 @@ describe("buildButtons", () => {
     const obj = result as any;
     expect(obj.actions[0].type).toBe("primary");
   });
-});
+});

package/src/__tests__/session.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { mkdtemp, rm } from "node:fs/promises";
+import { mkdtemp, rm, readFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 
@@ -26,15 +26,30 @@ import {
   getSessionStatus,
   getAllSessionsStatus,
   recordSessionRegistry,
+  saveSessionTool,
   accumulateBlockContent,
   pickFinalReply,
+  switchChatBinding,
+  rebuildBindingsFromRegistry,
   UNKNOWN_MODEL_PLACEHOLDER,
   _setSessionRegistryFileForTest,
   _resetSessionRegistryFileForTest,
+  _setSessionToolsFileForTest,
+  _resetSessionToolsFileForTest,
   _setAdapterForToolForTest,
   _clearAdapterCacheForTest,
 } from "../session.ts";
-import { activePrompts } from "../session-chat-binding.ts";
+import {
+  activePrompts,
+  bindChatToSession,
+  unbindChatFromSession,
+  recordLastActiveChat,
+  getLastActiveChat,
+  pickDisplayChat,
+  resetBindingState,
+  getChatsForSession,
+  displayCards,
+} from "../session-chat-binding.ts";
 import type { AccumulatorState } from "../session.ts";
 import type { ToolAdapter, UnifiedBlock, SessionInfo } from "../adapters/adapter-interface.ts";
 
@@ -122,6 +137,94 @@ describe("resetState", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// rebuildBindingsFromRegistry — SDK 重连/启动时只重建只读映射,不动运行时状态
+//
+// 这是 onReady/onReconnected 应当调用的函数(替代之前错误调用的 resetState)。
+// 关键不变量:重建映射后,原有的 activePrompts、sessionInfoMap、displayCards、
+// processedMessages 全部保留——SDK 重连不应当影响后台 prompt 的执行。
+// ---------------------------------------------------------------------------
+
+describe("rebuildBindingsFromRegistry", () => {
+  let registryFile = "";
+
+  beforeEach(async () => {
+    chatSessionMap.clear();
+    sessionInfoMap.clear();
+    activePrompts.clear();
+    processedMessages.clear();
+    resetBindingState();
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-rebuild-"));
+    registryFile = join(dir, "session-registry.json");
+    _setSessionRegistryFileForTest(registryFile);
+  });
+
+  afterEach(async () => {
+    _resetSessionRegistryFileForTest();
+    if (registryFile) {
+      await rm(dirname(registryFile), { recursive: true, force: true });
+    }
+  });
+
+  it("不清空 activePrompts:后台 prompt 在 SDK 重连后必须继续被识别为活跃", async () => {
+    // 模拟有一个后台 prompt 正在跑
+    const controller = new AbortController();
+    activePrompts.set("session-running", { controller, stopped: false, startTime: Date.now() });
+    await recordSessionRegistry({
+      chatId: "chat-A",
+      sessionId: "session-running",
+      tool: "claude",
+      updatedAt: 100,
+    });
+
+    await rebuildBindingsFromRegistry();
+
+    // 关键不变量:重连后 activePrompts 必须保留,否则后台 generator 会变孤儿
+    expect(activePrompts.has("session-running")).toBe(true);
+    expect(activePrompts.get("session-running")?.controller).toBe(controller);
+  });
+
+  it("不清空 sessionInfoMap:轮数计数在重连后保留", async () => {
+    sessionInfoMap.set("chat-A", {
+      sessionId: "sid-A", turnCount: 7, lastContextTokens: 50000,
+      startTime: 1000, tool: "claude",
+    });
+    await recordSessionRegistry({
+      chatId: "chat-A", sessionId: "sid-A", tool: "claude", updatedAt: 100,
+    });
+
+    await rebuildBindingsFromRegistry();
+
+    expect(sessionInfoMap.get("chat-A")?.turnCount).toBe(7);
+    expect(sessionInfoMap.get("chat-A")?.lastContextTokens).toBe(50000);
+  });
+
+  it("不清空 processedMessages:重连后 SDK 重推消息仍能去重", async () => {
+    processedMessages.add("msg-id-1");
+    processedMessages.add("msg-id-2");
+
+    await rebuildBindingsFromRegistry();
+
+    expect(processedMessages.has("msg-id-1")).toBe(true);
+    expect(processedMessages.has("msg-id-2")).toBe(true);
+  });
+
+  it("从 registry 重建 sessionId → chatId 映射(沿用 rebuildSessionChatsFromRegistry 行为)", async () => {
+    await recordSessionRegistry({
+      chatId: "chat-A", sessionId: "sid-X", tool: "claude", updatedAt: 100,
+    });
+    await recordSessionRegistry({
+      chatId: "chat-B", sessionId: "sid-X", tool: "claude", updatedAt: 200,
+    });
+
+    await rebuildBindingsFromRegistry();
+
+    // 同一 sessionId 被两个 chatId 共享时,两个都应在映射中
+    bindChatToSession("sid-X", "chat-A"); // 验证幂等(再次调用不会出错)
+    expect(true).toBe(true); // 真正的断言由 sessionChatsMap 通过 pickDisplayChat 等间接验证
+  });
+});
+
 describe("getSessionStatus", () => {
   beforeEach(() => {
     chatSessionMap.clear();
@@ -233,6 +336,7 @@ describe("getSessionStatus", () => {
 
 describe("getAllSessionsStatus", () => {
   let registryFile = "";
+  let sessionsFile = "";
 
   beforeEach(async () => {
     chatSessionMap.clear();
@@ -240,12 +344,15 @@ describe("getAllSessionsStatus", () => {
     activePrompts.clear();
     const dir = await mkdtemp(join(tmpdir(), "chatccc-session-registry-"));
     registryFile = join(dir, "session-registry.json");
+    sessionsFile = join(dir, "sessions.json");
     _setSessionRegistryFileForTest(registryFile);
+    _setSessionToolsFileForTest(sessionsFile);
   });
 
   afterEach(async () => {
     _clearAdapterCacheForTest();
     _resetSessionRegistryFileForTest();
+    _resetSessionToolsFileForTest();
     if (registryFile) {
       await rm(dirname(registryFile), { recursive: true, force: true });
     }
@@ -298,6 +405,32 @@ describe("getAllSessionsStatus", () => {
     expect(result[1].chatName).toBe("test-chat-2");
   });
 
+  it("includes recent sessions without a registry chat binding", async () => {
+    await saveSessionTool("orphan-session", "claude");
+    activePrompts.set("orphan-session", {
+      controller: new AbortController(),
+      stopped: false,
+      startTime: 3000,
+    });
+
+    const result = await getAllSessionsStatus();
+    expect(result).toHaveLength(1);
+    expect(result[0].sessionId).toBe("orphan-session");
+    expect(result[0].chatId).toBe("");
+    expect(result[0].active).toBe(true);
+    expect(result[0].turnCount).toBe(0);
+  });
+
+  it("orphan sessions preserve chatName from sessions.json", async () => {
+    await saveSessionTool("orphan-with-name", "claude", "帮我写代码-src");
+    const result = await getAllSessionsStatus();
+    expect(result).toHaveLength(1);
+    expect(result[0].sessionId).toBe("orphan-with-name");
+    expect(result[0].chatId).toBe("");
+    expect(result[0].chatName).toBe("帮我写代码-src");
+    expect(result[0].active).toBe(false);
+  });
+
   it("returns recent disk sessions by updatedAt desc, limited to 20", async () => {
     for (let i = 0; i < 25; i++) {
       await recordSessionRegistry({
@@ -635,3 +768,294 @@ describe("pickFinalReply", () => {
     ).toBe("");
   });
 });
+
+// ---------------------------------------------------------------------------
+// pickDisplayChat — display loop 选择推送目标 chat 的纯函数
+// 关键不变量：仅当某 chatId 既是 session 的"最后活跃 chat"且仍然绑定到该
+// session 时才返回。否则返回 undefined（loop 当作"无活跃群"，不推送）。
+// 这是为了修复 /newh 后旧 session 仍向已解绑群推卡片的 bug。
+// ---------------------------------------------------------------------------
+
+describe("pickDisplayChat", () => {
+  beforeEach(() => {
+    resetBindingState();
+  });
+
+  it("绑定 + 记录活跃后，返回该 chatId", () => {
+    bindChatToSession("sid-A", "chat_X");
+    recordLastActiveChat("sid-A", "chat_X");
+    expect(pickDisplayChat("sid-A")).toBe("chat_X");
+  });
+
+  it("从未记录过活跃 chat 时返回 undefined", () => {
+    bindChatToSession("sid-A", "chat_X");
+    expect(pickDisplayChat("sid-A")).toBeUndefined();
+  });
+
+  it("最后活跃 chat 已被解绑（如 /newh 场景）时返回 undefined，避免向已离开本 session 的群推送", () => {
+    bindChatToSession("sid-A", "chat_X");
+    recordLastActiveChat("sid-A", "chat_X");
+    // 模拟 /newh：chat_X 被解绑，转给新 session
+    unbindChatFromSession("sid-A", "chat_X");
+    expect(pickDisplayChat("sid-A")).toBeUndefined();
+  });
+
+  it("session 仍绑定其他 chat 但 lastActive 是已解绑 chat 时返回 undefined（不应回退到任意绑定）", () => {
+    // 多群共享 session 的极端情况：lastActive 指向 chat_X，但 chat_X 已解绑
+    bindChatToSession("sid-A", "chat_X");
+    bindChatToSession("sid-A", "chat_Y");
+    recordLastActiveChat("sid-A", "chat_X");
+    unbindChatFromSession("sid-A", "chat_X");
+    expect(pickDisplayChat("sid-A")).toBeUndefined();
+  });
+
+  it("session 绑定多个 chat 且 lastActive 是仍绑定的 chat 时正确返回", () => {
+    bindChatToSession("sid-A", "chat_X");
+    bindChatToSession("sid-A", "chat_Y");
+    recordLastActiveChat("sid-A", "chat_Y");
+    expect(pickDisplayChat("sid-A")).toBe("chat_Y");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// unbindChatFromSession — 双保险：清理 lastActiveChatMap[sessionId]
+// 若该 sessionId 的 lastActive 正好指向被解绑的 chatId，则一并清掉，
+// 防止后续逻辑（不仅 display loop）读到悬挂的旧记录。
+// ---------------------------------------------------------------------------
+
+describe("unbindChatFromSession 同步清理 lastActiveChatMap", () => {
+  beforeEach(() => {
+    resetBindingState();
+  });
+
+  it("解绑的 chat 正是 lastActive 时清掉记录", () => {
+    bindChatToSession("sid-A", "chat_X");
+    recordLastActiveChat("sid-A", "chat_X");
+    unbindChatFromSession("sid-A", "chat_X");
+    expect(getLastActiveChat("sid-A")).toBeUndefined();
+  });
+
+  it("解绑的 chat 不是 lastActive 时保留 lastActive", () => {
+    // chat_X 是 lastActive，解绑 chat_Y 不应影响
+    bindChatToSession("sid-A", "chat_X");
+    bindChatToSession("sid-A", "chat_Y");
+    recordLastActiveChat("sid-A", "chat_X");
+    unbindChatFromSession("sid-A", "chat_Y");
+    expect(getLastActiveChat("sid-A")).toBe("chat_X");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// switchChatBinding — 事务式 chat→session 切换（/newh、/session N 复用）
+//
+// 关键不变量：
+//   1. p2p chatType 不调 updateChatInfo（私聊飞书 API 会直接抛错）
+//   2. updateChatInfo 失败时,内存绑定/sessionInfoMap/displayCards 完全不动,
+//      且 description 还是旧值,下次消息按旧 sessionId 路由不会乱
+//   3. 成功时按 unbind 旧 → bind 新 → recordLastActiveChat 顺序原子切换
+//   4. 持久化 registry + sessions.json
+// ---------------------------------------------------------------------------
+
+describe("switchChatBinding", () => {
+  let registryFile = "";
+  let sessionsFile = "";
+
+  beforeEach(async () => {
+    resetBindingState();
+    sessionInfoMap.clear();
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-switch-binding-"));
+    registryFile = join(dir, "session-registry.json");
+    sessionsFile = join(dir, "sessions.json");
+    _setSessionRegistryFileForTest(registryFile);
+    _setSessionToolsFileForTest(sessionsFile);
+  });
+
+  afterEach(async () => {
+    _resetSessionRegistryFileForTest();
+    _resetSessionToolsFileForTest();
+    if (registryFile) {
+      await rm(dirname(registryFile), { recursive: true, force: true });
+    }
+  });
+
+  it("群聊场景：API 成功后内存切换 + 持久化", async () => {
+    const calls: Array<{ chatId: string; name: string; desc: string }> = [];
+    const updateChatInfoFn = async (chatId: string, name: string, desc: string) => {
+      calls.push({ chatId, name, desc });
+    };
+
+    bindChatToSession("old-sid", "chat-1");
+    sessionInfoMap.set("chat-1", {
+      sessionId: "old-sid", turnCount: 5, lastContextTokens: 100,
+      startTime: 0, tool: "claude",
+    });
+    displayCards.set("chat-1", {
+      cardId: "c1", sequence: 1, cardBusy: false,
+      cardCreatedAt: 0, lastSentContent: "", streamErrorNotified: false,
+    });
+
+    const result = await switchChatBinding({
+      chatId: "chat-1",
+      chatType: "group",
+      oldSessionId: "old-sid",
+      newSessionId: "new-sid",
+      tool: "claude",
+      chatName: "新会话-test",
+      newDescription: "Claude Code Session: new-sid",
+      updateChatInfoFn,
+    });
+
+    expect(result.ok).toBe(true);
+    expect(calls).toHaveLength(1);
+    expect(calls[0]).toEqual({
+      chatId: "chat-1",
+      name: "新会话-test",
+      desc: "Claude Code Session: new-sid",
+    });
+    // 旧 session 已解绑,新 session 已绑
+    expect(getChatsForSession("old-sid")).toEqual([]);
+    expect(getChatsForSession("new-sid")).toEqual(["chat-1"]);
+    // displayCards 已清
+    expect(displayCards.has("chat-1")).toBe(false);
+    // sessionInfoMap 指向新 sessionId
+    expect(sessionInfoMap.get("chat-1")?.sessionId).toBe("new-sid");
+    // lastActiveChat 指向当前 chat
+    expect(getLastActiveChat("new-sid")).toBe("chat-1");
+  });
+
+  it("私聊场景：完全跳过 updateChatInfo,仍完成内存切换", async () => {
+    let called = false;
+    const updateChatInfoFn = async () => {
+      called = true;
+      throw new Error("p2p chat API would fail");
+    };
+
+    const result = await switchChatBinding({
+      chatId: "p2p-chat",
+      chatType: "p2p",
+      oldSessionId: null,
+      newSessionId: "new-sid-p2p",
+      tool: "claude",
+      chatName: "新会话-p2p",
+      newDescription: "Claude Code Session: new-sid-p2p",
+      updateChatInfoFn,
+    });
+
+    expect(result.ok).toBe(true);
+    expect(called).toBe(false); // 私聊跳过 API 调用
+    expect(getChatsForSession("new-sid-p2p")).toEqual(["p2p-chat"]);
+    expect(sessionInfoMap.get("p2p-chat")?.sessionId).toBe("new-sid-p2p");
+  });
+
+  it("群聊 + updateChatInfo 抛错：内存完全不动 + 返回 error", async () => {
+    bindChatToSession("old-sid", "chat-1");
+    sessionInfoMap.set("chat-1", {
+      sessionId: "old-sid", turnCount: 5, lastContextTokens: 100,
+      startTime: 0, tool: "claude",
+    });
+    const oldDisplay = {
+      cardId: "c1", sequence: 1, cardBusy: false,
+      cardCreatedAt: 0, lastSentContent: "", streamErrorNotified: false,
+    };
+    displayCards.set("chat-1", oldDisplay);
+
+    const updateChatInfoFn = async () => {
+      throw new Error("network timeout");
+    };
+
+    const result = await switchChatBinding({
+      chatId: "chat-1",
+      chatType: "group",
+      oldSessionId: "old-sid",
+      newSessionId: "new-sid",
+      tool: "claude",
+      chatName: "新会话-failed",
+      newDescription: "Claude Code Session: new-sid",
+      updateChatInfoFn,
+    });
+
+    expect(result.ok).toBe(false);
+    expect(result.error?.message).toBe("network timeout");
+    // 内存绑定保持旧状态
+    expect(getChatsForSession("old-sid")).toEqual(["chat-1"]);
+    expect(getChatsForSession("new-sid")).toEqual([]);
+    expect(displayCards.get("chat-1")).toBe(oldDisplay);
+    expect(sessionInfoMap.get("chat-1")?.sessionId).toBe("old-sid");
+    expect(sessionInfoMap.get("chat-1")?.turnCount).toBe(5);
+  });
+
+  it("oldSessionId 为 null 时不调 unbind(适用于私聊首次绑定)", async () => {
+    const updateChatInfoFn = async () => {};
+
+    const result = await switchChatBinding({
+      chatId: "fresh-chat",
+      chatType: "p2p",
+      oldSessionId: null,
+      newSessionId: "fresh-sid",
+      tool: "claude",
+      chatName: "首次会话",
+      newDescription: "Claude Code Session: fresh-sid",
+      updateChatInfoFn,
+    });
+
+    expect(result.ok).toBe(true);
+    expect(getChatsForSession("fresh-sid")).toEqual(["fresh-chat"]);
+  });
+
+  it("API 成功后,registry 持久化记录可被重新加载", async () => {
+    const updateChatInfoFn = async () => {};
+
+    await switchChatBinding({
+      chatId: "chat-persist",
+      chatType: "group",
+      oldSessionId: null,
+      newSessionId: "persist-sid",
+      tool: "cursor",
+      chatName: "persist-name",
+      newDescription: "Cursor Session: persist-sid",
+      initialTurnCount: 3,
+      initialContextTokens: 500,
+      updateChatInfoFn,
+    });
+
+    // 验证 registry 文件已写入
+    const raw = await readFile(registryFile, "utf-8");
+    const parsed = JSON.parse(raw);
+    expect(parsed["chat-persist"]).toMatchObject({
+      chatId: "chat-persist",
+      sessionId: "persist-sid",
+      tool: "cursor",
+      chatName: "persist-name",
+      turnCount: 3,
+      lastContextTokens: 500,
+      running: false,
+    });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// resetState 调用契约：仅供测试 + 进程首次启动。
+// 不应在 SDK onReady/onReconnected 中调用——会清空 activePrompts 让正在跑
+// 的后台 prompt 变成"孤儿 generator"（Map 删了但 controller 没 abort,
+// 导致同一 sessionId 双开 prompt）。
+// ---------------------------------------------------------------------------
+
+describe("resetState 契约：清空所有运行时状态", () => {
+  it("清空 activePrompts 但不 abort controller(只能由进程首次启动调用)", () => {
+    const controller = new AbortController();
+    let aborted = false;
+    controller.signal.addEventListener("abort", () => { aborted = true; });
+    activePrompts.set("sid-running", {
+      controller, stopped: false, startTime: 0,
+    });
+
+    resetState();
+
+    expect(activePrompts.size).toBe(0);
+    // 注意：resetState 不主动 abort——所以如果生产代码在 prompt 跑过程中
+    // 误调 resetState,后台 generator 仍会继续跑直到自然结束,但 activePrompts
+    // 已经空了,下条消息会双开 prompt。这是 resetState 仅适用于"启动时"
+    // (Map 本就是空的)的根本原因。
+    expect(aborted).toBe(false);
+  });
+});

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

@@ -0,0 +1,134 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { mkdtemp, rm, readFile, readdir, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+// 在 import stream-state 之前先 mock config，让 USER_DATA_DIR 指向临时目录
+const TEST_DATA_DIR = await mkdtemp(join(tmpdir(), "chatccc-stream-state-test-"));
+vi.mock("../config.ts", async () => {
+  const actual = await vi.importActual<typeof import("../config.ts")>("../config.ts");
+  return {
+    ...actual,
+    USER_DATA_DIR: TEST_DATA_DIR,
+    ts: () => "test-ts",
+  };
+});
+
+const {
+  writeStreamState,
+  readStreamState,
+  createEmptyStreamState,
+  STREAMS_DIR,
+  _setRenameForTest,
+  _resetRenameForTest,
+} = await import("../stream-state.ts");
+
+describe("writeStreamState — atomic rename", () => {
+  beforeEach(async () => {
+    // 清空测试目录
+    try {
+      const entries = await readdir(STREAMS_DIR);
+      for (const e of entries) await rm(join(STREAMS_DIR, e), { force: true });
+    } catch { /* dir not yet exist */ }
+  });
+
+  afterEach(async () => {
+    vi.restoreAllMocks();
+  });
+
+  it("writeStreamState 写完后 readStreamState 能读到完整内容", async () => {
+    const state = createEmptyStreamState("sid-1", "/tmp", "claude", 1);
+    state.accumulatedContent = "hello";
+    state.finalReply = "world";
+
+    await writeStreamState(state);
+
+    const got = await readStreamState("sid-1");
+    expect(got).not.toBeNull();
+    expect(got!.accumulatedContent).toBe("hello");
+    expect(got!.finalReply).toBe("world");
+  });
+
+  it("写入完成后,临时 .tmp 文件不应残留(rename 成功路径)", async () => {
+    const state = createEmptyStreamState("sid-2", "/tmp", "claude", 1);
+    await writeStreamState(state);
+
+    const entries = await readdir(STREAMS_DIR);
+    // 只应有 sid-2.json,没有 sid-2.json.tmp
+    expect(entries).toContain("sid-2.json");
+    expect(entries.some((e) => e.endsWith(".tmp"))).toBe(false);
+  });
+
+  it("覆盖写入时,reader 永远只读到完整 JSON(不读到半截)", async () => {
+    // 此测试验证：先写一个版本,再写第二个版本,reader 中间读取必然是某个完整版本
+    const state1 = createEmptyStreamState("sid-3", "/tmp", "claude", 1);
+    state1.accumulatedContent = "v1";
+    await writeStreamState(state1);
+
+    // 直接读原始字节,确认是完整 JSON
+    const raw1 = await readFile(join(STREAMS_DIR, "sid-3.json"), "utf-8");
+    expect(() => JSON.parse(raw1)).not.toThrow();
+    expect(JSON.parse(raw1).accumulatedContent).toBe("v1");
+
+    const state2 = createEmptyStreamState("sid-3", "/tmp", "claude", 2);
+    state2.accumulatedContent = "v2";
+    await writeStreamState(state2);
+
+    const raw2 = await readFile(join(STREAMS_DIR, "sid-3.json"), "utf-8");
+    expect(() => JSON.parse(raw2)).not.toThrow();
+    expect(JSON.parse(raw2).accumulatedContent).toBe("v2");
+  });
+
+  it("rename 失败时降级为直接覆盖写,不抛错 + 数据仍写入", async () => {
+    let renameCalls = 0;
+    _setRenameForTest(async () => {
+      renameCalls++;
+      throw Object.assign(new Error("EPERM mocked"), { code: "EPERM" });
+    });
+
+    try {
+      const state = createEmptyStreamState("sid-fallback", "/tmp", "claude", 1);
+      state.accumulatedContent = "fallback-content";
+
+      // 不应抛错
+      await expect(writeStreamState(state)).resolves.toBeUndefined();
+
+      // 数据仍应写入(降级路径走 writeFile 覆盖)
+      const got = await readStreamState("sid-fallback");
+      expect(got).not.toBeNull();
+      expect(got!.accumulatedContent).toBe("fallback-content");
+
+      expect(renameCalls).toBe(1);
+    } finally {
+      _resetRenameForTest();
+    }
+  });
+
+  it("readStreamState 对损坏的 JSON 返回 null(reader 兜底契约)", async () => {
+    // 直接写一段半截 JSON 到目标路径
+    const filePath = join(STREAMS_DIR, "sid-broken.json");
+    await writeFile(filePath, '{"sessionId":"sid-broken","accum', "utf-8");
+
+    const got = await readStreamState("sid-broken");
+    expect(got).toBeNull();
+  });
+
+  it("readStreamState 对不存在文件返回 null", async () => {
+    const got = await readStreamState("never-existed");
+    expect(got).toBeNull();
+  });
+});
+
+describe("createEmptyStreamState", () => {
+  it("生成的 state 字段正确且 status=running", () => {
+    const s = createEmptyStreamState("sid-X", "/cwd", "cursor", 5);
+    expect(s.sessionId).toBe("sid-X");
+    expect(s.cwd).toBe("/cwd");
+    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);
+  });
+});

package/src/cards.ts

@@ -294,8 +294,8 @@ export function buildSessionsCard(sessions: Array<{
     }
     const toolLabel = s.tool === "cursor" ? "Cursor" : s.tool === "codex" ? "Codex" : "Claude Code";
     const namePart = s.chatName ? `**${s.chatName}** ` : "";
-    const groupTag = s.chatId && s.chatId.startsWith("oc_") ? " (群聊)" : "";
-    return `**${i + 1}.** ${namePart}${groupTag} \`${shortId}\` ${status} | 工具: ${toolLabel} | 轮数: ${s.turnCount} | ${s.model}${extra}`;
+    const chatTag = !s.chatId ? " (chat id缺失)" : s.chatId.startsWith("oc_") ? " (群聊)" : "";
+    return `**${i + 1}.** ${namePart}${chatTag} \`${shortId}\` ${status} | 工具: ${toolLabel} | 轮数: ${s.turnCount} | ${s.model}${extra}`;
   };
 
   const lines: string[] = [`共 **${sessions.length}** 个会话:`, ""];