chatccc 0.2.122 → 0.2.123

package/package.json

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

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

@@ -1,442 +1,442 @@
-import { describe, it, expect } from "vitest";
-import { normalizeSdkMessage, createClaudeAdapter } from "../adapters/claude-adapter.ts";
-import type { UnifiedStreamMessage } from "../adapters/adapter-interface.ts";
-import type {
-  ClaudeSessionMeta,
-  ClaudeSessionMetaStore,
-} from "../adapters/claude-session-meta-store.ts";
-
-// ---------------------------------------------------------------------------
-// 进程内内存版 meta store（测试用，避开磁盘 IO）
-// ---------------------------------------------------------------------------
-
-function createInMemoryMetaStore(
-  initial: Record<string, ClaudeSessionMeta> = {},
-): ClaudeSessionMetaStore & { snapshot(): Record<string, ClaudeSessionMeta> } {
-  const map = new Map<string, ClaudeSessionMeta>(Object.entries(initial));
-  return {
-    async get(sid) {
-      return map.get(sid);
-    },
-    async set(sid, partial) {
-      const existing = map.get(sid);
-      const merged: { cwd?: string; model?: string } = { ...existing };
-      if (typeof partial.cwd === "string" && partial.cwd.length > 0) merged.cwd = partial.cwd;
-      if (typeof partial.model === "string" && partial.model.length > 0) merged.model = partial.model;
-      if (!merged.cwd) return;
-      map.set(sid, merged.model ? { cwd: merged.cwd, model: merged.model } : { cwd: merged.cwd });
-    },
-    snapshot() {
-      return Object.fromEntries(map);
-    },
-  };
-}
-
-// ---------------------------------------------------------------------------
-// normalizeSdkMessage — 核心映射逻辑测试（纯函数，CLI 与 SDK 格式相同）
-// ---------------------------------------------------------------------------
-
-describe("normalizeSdkMessage", () => {
-  // --- assistant messages ---
-
-  it("normalizes assistant message with text block", () => {
-    const result = normalizeSdkMessage({
-      type: "assistant",
-      message: { content: [{ type: "text", text: "Hello world" }] },
-    });
-    expect(result).not.toBeNull();
-    expect(result!.type).toBe("assistant");
-    expect(result!.blocks).toEqual([{ type: "text", text: "Hello world" }]);
-  });
-
-  it("normalizes assistant message with thinking block", () => {
-    const result = normalizeSdkMessage({
-      type: "assistant",
-      message: { content: [{ type: "thinking", thinking: "Let me analyze..." }] },
-    });
-    expect(result).not.toBeNull();
-    expect(result!.blocks).toEqual([{ type: "thinking", thinking: "Let me analyze..." }]);
-  });
-
-  it("normalizes assistant message with tool_use block", () => {
-    const result = normalizeSdkMessage({
-      type: "assistant",
-      message: {
-        content: [{ type: "tool_use", name: "Read", input: { file_path: "/tmp/test.txt" } }],
-      },
-    });
-    expect(result).not.toBeNull();
-    expect(result!.blocks).toEqual([
-      { type: "tool_use", name: "Read", input: { file_path: "/tmp/test.txt" } },
-    ]);
-  });
-
-  it('uses "unknown" for tool_use without name', () => {
-    const result = normalizeSdkMessage({
-      type: "assistant",
-      message: { content: [{ type: "tool_use", input: { x: 1 } }] },
-    });
-    expect(result!.blocks[0]).toMatchObject({ type: "tool_use", name: "unknown" });
-  });
-
-  it("normalizes user message with tool_result block (success)", () => {
-    const result = normalizeSdkMessage({
-      type: "user",
-      message: {
-        content: [
-          { type: "tool_result", tool_use_id: "abc123", content: "file content here", is_error: false },
-        ],
-      },
-    });
-    expect(result).not.toBeNull();
-    expect(result!.type).toBe("user");
-    const block = result!.blocks[0] as any;
-    expect(block.type).toBe("tool_result");
-    expect(block.tool_use_id).toBe("abc123");
-    expect(block.content).toBe("file content here");
-    expect(block.is_error).toBe(false);
-  });
-
-  it("normalizes user message with tool_result block (error)", () => {
-    const result = normalizeSdkMessage({
-      type: "user",
-      message: {
-        content: [
-          { type: "tool_result", tool_use_id: "err456", content: "permission denied", is_error: true },
-        ],
-      },
-    });
-    expect(result!.blocks[0]).toMatchObject({
-      type: "tool_result",
-      tool_use_id: "err456",
-      is_error: true,
-    });
-  });
-
-  it("normalizes tool_result with array content", () => {
-    const content = [{ type: "text", text: "line 1" }, { type: "text", text: "line 2" }];
-    const result = normalizeSdkMessage({
-      type: "user",
-      message: { content: [{ type: "tool_result", tool_use_id: "arr", content }] },
-    });
-    expect(result!.blocks[0]).toMatchObject({
-      type: "tool_result",
-      tool_use_id: "arr",
-    });
-    expect((result!.blocks[0] as any).content).toEqual(content);
-  });
-
-  it("skips text blocks in user messages (replayed input from --replay-user-messages)", () => {
-    // user 消息中的 text block 来自 --replay-user-messages 重放的用户输入
-    // （含内嵌的 IM skill prompt），不应出现在最终回复中
-    const result = normalizeSdkMessage({
-      type: "user",
-      message: {
-        content: [
-          { type: "text", text: "[ChatCCC IM skill: feishu-skill]\n...[/ChatCCC IM skill: feishu-skill]" },
-          { type: "tool_result", tool_use_id: "abc", content: "result" },
-        ],
-      },
-    });
-    expect(result).not.toBeNull();
-    expect(result!.type).toBe("user");
-    // text block 应被跳过，只保留 tool_result
-    expect(result!.blocks).toHaveLength(1);
-    expect(result!.blocks[0]).toMatchObject({ type: "tool_result", tool_use_id: "abc" });
-  });
-
-  it("returns null for user message with only text blocks (all skipped)", () => {
-    // 纯 user text 消息（无 tool_result）→ 全部跳过，不产生有效 blocks
-    const result = normalizeSdkMessage({
-      type: "user",
-      message: {
-        content: [{ type: "text", text: "some replayed user input" }],
-      },
-    });
-    // 此时 blocks 为空，但消息本身仍有 type，返回非 null 以保持流完整性
-    // 调用方 accumulateBlockContent 对空 blocks 是 no-op
-    expect(result).not.toBeNull();
-    expect(result!.blocks).toEqual([]);
-  });
-
-  it("normalizes redacted_thinking block", () => {
-    const result = normalizeSdkMessage({
-      type: "assistant",
-      message: { content: [{ type: "redacted_thinking" }] },
-    });
-    expect(result!.blocks).toEqual([{ type: "redacted_thinking" }]);
-  });
-
-  it("normalizes search_result block", () => {
-    const result = normalizeSdkMessage({
-      type: "assistant",
-      message: {
-        content: [{ type: "search_result", query: "TypeScript best practices" }],
-      },
-    });
-    expect(result!.blocks).toEqual([
-      { type: "search_result", query: "TypeScript best practices" },
-    ]);
-  });
-
-  it("normalizes search_result without query (empty string)", () => {
-    const result = normalizeSdkMessage({
-      type: "assistant",
-      message: { content: [{ type: "search_result" }] },
-    });
-    expect(result!.blocks).toEqual([{ type: "search_result", query: "" }]);
-  });
-
-  // --- system messages ---
-
-  it("normalizes system compact_boundary message", () => {
-    const result = normalizeSdkMessage({
-      type: "system",
-      subtype: "compact_boundary",
-      compact_metadata: {
-        trigger: "auto",
-        pre_tokens: 15000,
-        post_tokens: 8000,
-      },
-    });
-    expect(result).not.toBeNull();
-    expect(result!.type).toBe("system");
-    expect(result!.blocks).toEqual([
-      { type: "compact_boundary", trigger: "auto", pre_tokens: 15000, post_tokens: 8000 },
-    ]);
-  });
-
-  it("normalizes compact_boundary with manual trigger", () => {
-    const result = normalizeSdkMessage({
-      type: "system",
-      subtype: "compact_boundary",
-      compact_metadata: { trigger: "manual", pre_tokens: 20000 },
-    });
-    expect(result!.blocks).toEqual([
-      { type: "compact_boundary", trigger: "manual", pre_tokens: 20000, post_tokens: undefined },
-    ]);
-  });
-
-  it("normalizes compact_boundary without post_tokens", () => {
-    const result = normalizeSdkMessage({
-      type: "system",
-      subtype: "compact_boundary",
-      compact_metadata: { trigger: "auto", pre_tokens: 10000 },
-    });
-    expect(result!.blocks).toEqual([
-      { type: "compact_boundary", trigger: "auto", pre_tokens: 10000, post_tokens: undefined },
-    ]);
-  });
-
-  // --- mixed blocks ---
-
-  it("normalizes message with multiple block types mixed", () => {
-    const result = normalizeSdkMessage({
-      type: "assistant",
-      message: {
-        content: [
-          { type: "thinking", thinking: "Hmm..." },
-          { type: "tool_use", name: "Grep", input: { pattern: "foo" } },
-          { type: "text", text: "Found it." },
-        ],
-      },
-    });
-    expect(result).not.toBeNull();
-    expect(result!.blocks).toHaveLength(3);
-    expect(result!.blocks[0]).toEqual({ type: "thinking", thinking: "Hmm..." });
-    expect(result!.blocks[1]).toEqual({ type: "tool_use", name: "Grep", input: { pattern: "foo" } });
-    expect(result!.blocks[2]).toEqual({ type: "text", text: "Found it." });
-  });
-
-  // --- edge cases ---
-
-  it("skips unknown block types", () => {
-    const result = normalizeSdkMessage({
-      type: "assistant",
-      message: {
-        content: [
-          { type: "unknown_type", data: "whatever" },
-          { type: "text", text: "still here" },
-        ],
-      },
-    });
-    expect(result!.blocks).toHaveLength(1);
-    expect(result!.blocks[0]).toEqual({ type: "text", text: "still here" });
-  });
-
-  it("returns null for non-assistant/non-user/non-system messages", () => {
-    expect(
-      normalizeSdkMessage({ type: "result", subtype: "success" }),
-    ).toBeNull();
-    expect(
-      normalizeSdkMessage({ type: "stream_event" }),
-    ).toBeNull();
-    expect(
-      normalizeSdkMessage({ type: "status" }),
-    ).toBeNull();
-  });
-
-  it("returns null for system message without compact_boundary subtype", () => {
-    expect(
-      normalizeSdkMessage({ type: "system", subtype: "init" }),
-    ).toBeNull();
-    expect(
-      normalizeSdkMessage({ type: "system", subtype: "notification" }),
-    ).toBeNull();
-  });
-
-  it("returns message with empty blocks for content=[ ]", () => {
-    const result = normalizeSdkMessage({
-      type: "assistant",
-      message: { content: [] },
-    });
-    expect(result).not.toBeNull();
-    expect(result!.blocks).toEqual([]);
-  });
-
-  it("returns null for message without content", () => {
-    const result = normalizeSdkMessage({
-      type: "assistant",
-      message: {},
-    });
-    expect(result).toBeNull();
-  });
-
-  it("returns null for message with null content array", () => {
-    const result = normalizeSdkMessage({
-      type: "assistant",
-      message: { content: undefined as any },
-    });
-    expect(result).toBeNull();
-  });
-
-  it("returns null for compact_boundary without metadata", () => {
-    const result = normalizeSdkMessage({
-      type: "system",
-      subtype: "compact_boundary",
-    });
-    expect(result).toBeNull();
-  });
-
-  it("skips thinking block with empty thinking string", () => {
-    const result = normalizeSdkMessage({
-      type: "assistant",
-      message: { content: [{ type: "thinking", thinking: "" }] },
-    });
-    expect(result!.blocks).toEqual([]);
-  });
-
-  it("skips text block with empty text string", () => {
-    const result = normalizeSdkMessage({
-      type: "assistant",
-      message: { content: [{ type: "text", text: "" }] },
-    });
-    expect(result!.blocks).toEqual([]);
-  });
-
-  it("handles message with undefined type gracefully", () => {
-    const result = normalizeSdkMessage({
-      message: { content: [{ type: "text", text: "orphan" }] },
-    });
-    expect(result).toBeNull();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// createClaudeAdapter — 工厂函数 + getSessionInfo / closeSession 测试
-// ---------------------------------------------------------------------------
-
-describe("createClaudeAdapter", () => {
-  it("returns adapter with correct displayName and sessionDescPrefix", () => {
-    const adapter = createClaudeAdapter({
-      model: "claude-sonnet-4-6",
-      effort: "high",
-      isEmpty: (v) => v.trim() === "",
-    });
-    expect(adapter.displayName).toBe("Claude Code");
-    expect(adapter.sessionDescPrefix).toBe("Claude Code Session:");
-  });
-
-  it("closeSession does not throw", async () => {
-    const adapter = createClaudeAdapter({
-      model: "claude-sonnet-4-6",
-      effort: "high",
-      isEmpty: () => false,
-    });
-    await expect(adapter.closeSession("any-sid")).resolves.toBeUndefined();
-  });
-
-  // -------------------------------------------------------------------------
-  // getSessionInfo 行为契约
-  //   - cwd 决定 /git 是否可用
-  //   - model 用于 /state、/sessions 显示
-  // -------------------------------------------------------------------------
-
-  it("getSessionInfo: store 中无该 sessionId 时只返回 sessionId", async () => {
-    const store = createInMemoryMetaStore();
-    const adapter = createClaudeAdapter({
-      model: "",
-      effort: "",
-      isEmpty: () => false,
-      metaStore: store,
-    });
-    const info = await adapter.getSessionInfo("unknown-sid");
-    expect(info).toEqual({ sessionId: "unknown-sid" });
-    expect(info?.cwd).toBeUndefined();
-    expect(info?.model).toBeUndefined();
-  });
-
-  it("getSessionInfo: store 仅有 cwd 时返回 cwd，model 仍为 undefined", async () => {
-    const store = createInMemoryMetaStore({ "sid-known": { cwd: "F:/proj/Foo" } });
-    const adapter = createClaudeAdapter({
-      model: "",
-      effort: "",
-      isEmpty: () => false,
-      metaStore: store,
-    });
-    const info = await adapter.getSessionInfo("sid-known");
-    expect(info).toEqual({ sessionId: "sid-known", cwd: "F:/proj/Foo" });
-    expect(info?.model).toBeUndefined();
-  });
-
-  it("getSessionInfo: store 同时有 cwd + model 时一并返回", async () => {
-    const store = createInMemoryMetaStore({
-      "sid-known": { cwd: "F:/proj/Foo", model: "claude-sonnet-4-6" },
-    });
-    const adapter = createClaudeAdapter({
-      model: "",
-      effort: "",
-      isEmpty: () => false,
-      metaStore: store,
-    });
-    const info = await adapter.getSessionInfo("sid-known");
-    expect(info).toEqual({
-      sessionId: "sid-known",
-      cwd: "F:/proj/Foo",
-      model: "claude-sonnet-4-6",
-    });
-  });
-
-  it("getSessionInfo: 不同 sessionId 互不影响", async () => {
-    const store = createInMemoryMetaStore({
-      "sid-A": { cwd: "/a", model: "mA" },
-      "sid-B": { cwd: "/b" },
-    });
-    const adapter = createClaudeAdapter({
-      model: "",
-      effort: "",
-      isEmpty: () => false,
-      metaStore: store,
-    });
-    expect(await adapter.getSessionInfo("sid-A")).toEqual({
-      sessionId: "sid-A",
-      cwd: "/a",
-      model: "mA",
-    });
-    expect(await adapter.getSessionInfo("sid-B")).toEqual({
-      sessionId: "sid-B",
-      cwd: "/b",
-    });
-    expect(await adapter.getSessionInfo("sid-C")).toEqual({ sessionId: "sid-C" });
-  });
+import { describe, it, expect } from "vitest";
+import { normalizeSdkMessage, createClaudeAdapter } from "../adapters/claude-adapter.ts";
+import type { UnifiedStreamMessage } from "../adapters/adapter-interface.ts";
+import type {
+  ClaudeSessionMeta,
+  ClaudeSessionMetaStore,
+} from "../adapters/claude-session-meta-store.ts";
+
+// ---------------------------------------------------------------------------
+// 进程内内存版 meta store（测试用，避开磁盘 IO）
+// ---------------------------------------------------------------------------
+
+function createInMemoryMetaStore(
+  initial: Record<string, ClaudeSessionMeta> = {},
+): ClaudeSessionMetaStore & { snapshot(): Record<string, ClaudeSessionMeta> } {
+  const map = new Map<string, ClaudeSessionMeta>(Object.entries(initial));
+  return {
+    async get(sid) {
+      return map.get(sid);
+    },
+    async set(sid, partial) {
+      const existing = map.get(sid);
+      const merged: { cwd?: string; model?: string } = { ...existing };
+      if (typeof partial.cwd === "string" && partial.cwd.length > 0) merged.cwd = partial.cwd;
+      if (typeof partial.model === "string" && partial.model.length > 0) merged.model = partial.model;
+      if (!merged.cwd) return;
+      map.set(sid, merged.model ? { cwd: merged.cwd, model: merged.model } : { cwd: merged.cwd });
+    },
+    snapshot() {
+      return Object.fromEntries(map);
+    },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// normalizeSdkMessage — 核心映射逻辑测试（纯函数，CLI 与 SDK 格式相同）
+// ---------------------------------------------------------------------------
+
+describe("normalizeSdkMessage", () => {
+  // --- assistant messages ---
+
+  it("normalizes assistant message with text block", () => {
+    const result = normalizeSdkMessage({
+      type: "assistant",
+      message: { content: [{ type: "text", text: "Hello world" }] },
+    });
+    expect(result).not.toBeNull();
+    expect(result!.type).toBe("assistant");
+    expect(result!.blocks).toEqual([{ type: "text", text: "Hello world" }]);
+  });
+
+  it("normalizes assistant message with thinking block", () => {
+    const result = normalizeSdkMessage({
+      type: "assistant",
+      message: { content: [{ type: "thinking", thinking: "Let me analyze..." }] },
+    });
+    expect(result).not.toBeNull();
+    expect(result!.blocks).toEqual([{ type: "thinking", thinking: "Let me analyze..." }]);
+  });
+
+  it("normalizes assistant message with tool_use block", () => {
+    const result = normalizeSdkMessage({
+      type: "assistant",
+      message: {
+        content: [{ type: "tool_use", name: "Read", input: { file_path: "/tmp/test.txt" } }],
+      },
+    });
+    expect(result).not.toBeNull();
+    expect(result!.blocks).toEqual([
+      { type: "tool_use", name: "Read", input: { file_path: "/tmp/test.txt" } },
+    ]);
+  });
+
+  it('uses "unknown" for tool_use without name', () => {
+    const result = normalizeSdkMessage({
+      type: "assistant",
+      message: { content: [{ type: "tool_use", input: { x: 1 } }] },
+    });
+    expect(result!.blocks[0]).toMatchObject({ type: "tool_use", name: "unknown" });
+  });
+
+  it("normalizes user message with tool_result block (success)", () => {
+    const result = normalizeSdkMessage({
+      type: "user",
+      message: {
+        content: [
+          { type: "tool_result", tool_use_id: "abc123", content: "file content here", is_error: false },
+        ],
+      },
+    });
+    expect(result).not.toBeNull();
+    expect(result!.type).toBe("user");
+    const block = result!.blocks[0] as any;
+    expect(block.type).toBe("tool_result");
+    expect(block.tool_use_id).toBe("abc123");
+    expect(block.content).toBe("file content here");
+    expect(block.is_error).toBe(false);
+  });
+
+  it("normalizes user message with tool_result block (error)", () => {
+    const result = normalizeSdkMessage({
+      type: "user",
+      message: {
+        content: [
+          { type: "tool_result", tool_use_id: "err456", content: "permission denied", is_error: true },
+        ],
+      },
+    });
+    expect(result!.blocks[0]).toMatchObject({
+      type: "tool_result",
+      tool_use_id: "err456",
+      is_error: true,
+    });
+  });
+
+  it("normalizes tool_result with array content", () => {
+    const content = [{ type: "text", text: "line 1" }, { type: "text", text: "line 2" }];
+    const result = normalizeSdkMessage({
+      type: "user",
+      message: { content: [{ type: "tool_result", tool_use_id: "arr", content }] },
+    });
+    expect(result!.blocks[0]).toMatchObject({
+      type: "tool_result",
+      tool_use_id: "arr",
+    });
+    expect((result!.blocks[0] as any).content).toEqual(content);
+  });
+
+  it("skips text blocks in user messages (replayed input from --replay-user-messages)", () => {
+    // user 消息中的 text block 来自 --replay-user-messages 重放的用户输入
+    // （含内嵌的 IM skill prompt），不应出现在最终回复中
+    const result = normalizeSdkMessage({
+      type: "user",
+      message: {
+        content: [
+          { type: "text", text: "[ChatCCC IM skill: feishu-skill]\n...[/ChatCCC IM skill: feishu-skill]" },
+          { type: "tool_result", tool_use_id: "abc", content: "result" },
+        ],
+      },
+    });
+    expect(result).not.toBeNull();
+    expect(result!.type).toBe("user");
+    // text block 应被跳过，只保留 tool_result
+    expect(result!.blocks).toHaveLength(1);
+    expect(result!.blocks[0]).toMatchObject({ type: "tool_result", tool_use_id: "abc" });
+  });
+
+  it("returns null for user message with only text blocks (all skipped)", () => {
+    // 纯 user text 消息（无 tool_result）→ 全部跳过，不产生有效 blocks
+    const result = normalizeSdkMessage({
+      type: "user",
+      message: {
+        content: [{ type: "text", text: "some replayed user input" }],
+      },
+    });
+    // 此时 blocks 为空，但消息本身仍有 type，返回非 null 以保持流完整性
+    // 调用方 accumulateBlockContent 对空 blocks 是 no-op
+    expect(result).not.toBeNull();
+    expect(result!.blocks).toEqual([]);
+  });
+
+  it("normalizes redacted_thinking block", () => {
+    const result = normalizeSdkMessage({
+      type: "assistant",
+      message: { content: [{ type: "redacted_thinking" }] },
+    });
+    expect(result!.blocks).toEqual([{ type: "redacted_thinking" }]);
+  });
+
+  it("normalizes search_result block", () => {
+    const result = normalizeSdkMessage({
+      type: "assistant",
+      message: {
+        content: [{ type: "search_result", query: "TypeScript best practices" }],
+      },
+    });
+    expect(result!.blocks).toEqual([
+      { type: "search_result", query: "TypeScript best practices" },
+    ]);
+  });
+
+  it("normalizes search_result without query (empty string)", () => {
+    const result = normalizeSdkMessage({
+      type: "assistant",
+      message: { content: [{ type: "search_result" }] },
+    });
+    expect(result!.blocks).toEqual([{ type: "search_result", query: "" }]);
+  });
+
+  // --- system messages ---
+
+  it("normalizes system compact_boundary message", () => {
+    const result = normalizeSdkMessage({
+      type: "system",
+      subtype: "compact_boundary",
+      compact_metadata: {
+        trigger: "auto",
+        pre_tokens: 15000,
+        post_tokens: 8000,
+      },
+    });
+    expect(result).not.toBeNull();
+    expect(result!.type).toBe("system");
+    expect(result!.blocks).toEqual([
+      { type: "compact_boundary", trigger: "auto", pre_tokens: 15000, post_tokens: 8000 },
+    ]);
+  });
+
+  it("normalizes compact_boundary with manual trigger", () => {
+    const result = normalizeSdkMessage({
+      type: "system",
+      subtype: "compact_boundary",
+      compact_metadata: { trigger: "manual", pre_tokens: 20000 },
+    });
+    expect(result!.blocks).toEqual([
+      { type: "compact_boundary", trigger: "manual", pre_tokens: 20000, post_tokens: undefined },
+    ]);
+  });
+
+  it("normalizes compact_boundary without post_tokens", () => {
+    const result = normalizeSdkMessage({
+      type: "system",
+      subtype: "compact_boundary",
+      compact_metadata: { trigger: "auto", pre_tokens: 10000 },
+    });
+    expect(result!.blocks).toEqual([
+      { type: "compact_boundary", trigger: "auto", pre_tokens: 10000, post_tokens: undefined },
+    ]);
+  });
+
+  // --- mixed blocks ---
+
+  it("normalizes message with multiple block types mixed", () => {
+    const result = normalizeSdkMessage({
+      type: "assistant",
+      message: {
+        content: [
+          { type: "thinking", thinking: "Hmm..." },
+          { type: "tool_use", name: "Grep", input: { pattern: "foo" } },
+          { type: "text", text: "Found it." },
+        ],
+      },
+    });
+    expect(result).not.toBeNull();
+    expect(result!.blocks).toHaveLength(3);
+    expect(result!.blocks[0]).toEqual({ type: "thinking", thinking: "Hmm..." });
+    expect(result!.blocks[1]).toEqual({ type: "tool_use", name: "Grep", input: { pattern: "foo" } });
+    expect(result!.blocks[2]).toEqual({ type: "text", text: "Found it." });
+  });
+
+  // --- edge cases ---
+
+  it("skips unknown block types", () => {
+    const result = normalizeSdkMessage({
+      type: "assistant",
+      message: {
+        content: [
+          { type: "unknown_type", data: "whatever" },
+          { type: "text", text: "still here" },
+        ],
+      },
+    });
+    expect(result!.blocks).toHaveLength(1);
+    expect(result!.blocks[0]).toEqual({ type: "text", text: "still here" });
+  });
+
+  it("returns null for non-assistant/non-user/non-system messages", () => {
+    expect(
+      normalizeSdkMessage({ type: "result", subtype: "success" }),
+    ).toBeNull();
+    expect(
+      normalizeSdkMessage({ type: "stream_event" }),
+    ).toBeNull();
+    expect(
+      normalizeSdkMessage({ type: "status" }),
+    ).toBeNull();
+  });
+
+  it("returns null for system message without compact_boundary subtype", () => {
+    expect(
+      normalizeSdkMessage({ type: "system", subtype: "init" }),
+    ).toBeNull();
+    expect(
+      normalizeSdkMessage({ type: "system", subtype: "notification" }),
+    ).toBeNull();
+  });
+
+  it("returns message with empty blocks for content=[ ]", () => {
+    const result = normalizeSdkMessage({
+      type: "assistant",
+      message: { content: [] },
+    });
+    expect(result).not.toBeNull();
+    expect(result!.blocks).toEqual([]);
+  });
+
+  it("returns null for message without content", () => {
+    const result = normalizeSdkMessage({
+      type: "assistant",
+      message: {},
+    });
+    expect(result).toBeNull();
+  });
+
+  it("returns null for message with null content array", () => {
+    const result = normalizeSdkMessage({
+      type: "assistant",
+      message: { content: undefined as any },
+    });
+    expect(result).toBeNull();
+  });
+
+  it("returns null for compact_boundary without metadata", () => {
+    const result = normalizeSdkMessage({
+      type: "system",
+      subtype: "compact_boundary",
+    });
+    expect(result).toBeNull();
+  });
+
+  it("skips thinking block with empty thinking string", () => {
+    const result = normalizeSdkMessage({
+      type: "assistant",
+      message: { content: [{ type: "thinking", thinking: "" }] },
+    });
+    expect(result!.blocks).toEqual([]);
+  });
+
+  it("skips text block with empty text string", () => {
+    const result = normalizeSdkMessage({
+      type: "assistant",
+      message: { content: [{ type: "text", text: "" }] },
+    });
+    expect(result!.blocks).toEqual([]);
+  });
+
+  it("handles message with undefined type gracefully", () => {
+    const result = normalizeSdkMessage({
+      message: { content: [{ type: "text", text: "orphan" }] },
+    });
+    expect(result).toBeNull();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// createClaudeAdapter — 工厂函数 + getSessionInfo / closeSession 测试
+// ---------------------------------------------------------------------------
+
+describe("createClaudeAdapter", () => {
+  it("returns adapter with correct displayName and sessionDescPrefix", () => {
+    const adapter = createClaudeAdapter({
+      model: "claude-sonnet-4-6",
+      effort: "high",
+      isEmpty: (v) => v.trim() === "",
+    });
+    expect(adapter.displayName).toBe("Claude Code");
+    expect(adapter.sessionDescPrefix).toBe("Claude Code Session:");
+  });
+
+  it("closeSession does not throw", async () => {
+    const adapter = createClaudeAdapter({
+      model: "claude-sonnet-4-6",
+      effort: "high",
+      isEmpty: () => false,
+    });
+    await expect(adapter.closeSession("any-sid")).resolves.toBeUndefined();
+  });
+
+  // -------------------------------------------------------------------------
+  // getSessionInfo 行为契约
+  //   - cwd 决定 /git 是否可用
+  //   - model 用于 /state、/sessions 显示
+  // -------------------------------------------------------------------------
+
+  it("getSessionInfo: store 中无该 sessionId 时只返回 sessionId", async () => {
+    const store = createInMemoryMetaStore();
+    const adapter = createClaudeAdapter({
+      model: "",
+      effort: "",
+      isEmpty: () => false,
+      metaStore: store,
+    });
+    const info = await adapter.getSessionInfo("unknown-sid");
+    expect(info).toEqual({ sessionId: "unknown-sid" });
+    expect(info?.cwd).toBeUndefined();
+    expect(info?.model).toBeUndefined();
+  });
+
+  it("getSessionInfo: store 仅有 cwd 时返回 cwd，model 仍为 undefined", async () => {
+    const store = createInMemoryMetaStore({ "sid-known": { cwd: "F:/proj/Foo" } });
+    const adapter = createClaudeAdapter({
+      model: "",
+      effort: "",
+      isEmpty: () => false,
+      metaStore: store,
+    });
+    const info = await adapter.getSessionInfo("sid-known");
+    expect(info).toEqual({ sessionId: "sid-known", cwd: "F:/proj/Foo" });
+    expect(info?.model).toBeUndefined();
+  });
+
+  it("getSessionInfo: store 同时有 cwd + model 时一并返回", async () => {
+    const store = createInMemoryMetaStore({
+      "sid-known": { cwd: "F:/proj/Foo", model: "claude-sonnet-4-6" },
+    });
+    const adapter = createClaudeAdapter({
+      model: "",
+      effort: "",
+      isEmpty: () => false,
+      metaStore: store,
+    });
+    const info = await adapter.getSessionInfo("sid-known");
+    expect(info).toEqual({
+      sessionId: "sid-known",
+      cwd: "F:/proj/Foo",
+      model: "claude-sonnet-4-6",
+    });
+  });
+
+  it("getSessionInfo: 不同 sessionId 互不影响", async () => {
+    const store = createInMemoryMetaStore({
+      "sid-A": { cwd: "/a", model: "mA" },
+      "sid-B": { cwd: "/b" },
+    });
+    const adapter = createClaudeAdapter({
+      model: "",
+      effort: "",
+      isEmpty: () => false,
+      metaStore: store,
+    });
+    expect(await adapter.getSessionInfo("sid-A")).toEqual({
+      sessionId: "sid-A",
+      cwd: "/a",
+      model: "mA",
+    });
+    expect(await adapter.getSessionInfo("sid-B")).toEqual({
+      sessionId: "sid-B",
+      cwd: "/b",
+    });
+    expect(await adapter.getSessionInfo("sid-C")).toEqual({ sessionId: "sid-C" });
+  });
 });

package/src/adapters/claude-adapter.ts

@@ -285,7 +285,7 @@ function buildCliArgs(
     "--setting-sources", "user,project,local",
     "--permission-mode", permMode,
     ...(skipPermissions ? ["--dangerously-skip-permissions"] : []),
-    "--settings", "{\"maxTurns\":0}",
+    "--settings", "{\"maxTurns\":0,\"autoCompact\":{\"enabled\":true}}",
   ];
 
   if (!isEmpty(model)) args.push("--model", model);

package/src/adapters/resource-monitor.ts

@@ -1,141 +1,141 @@
-// =============================================================================
-// resource-monitor.ts — CLI 进程资源监控（CPU + 内存）
-// =============================================================================
-// 对所有 chatccc 启动的 CLI 进程持续监控 CPU 和内存占用。
-// 若连续 3 分钟两项指标均无变化，判定为僵死，发出 "stuck" 事件。
-// =============================================================================
-
-import { exec } from "node:child_process";
-import { EventEmitter } from "node:events";
-
-const CHECK_INTERVAL_MS = 30_000; // 30 秒检查一次
-const STUCK_THRESHOLD = 6; // 连续 6 次无变化 = 3 分钟
-
-interface ProcessSnapshot {
-  cpu: number;
-  memory: number;
-  unchangedCount: number;
-}
-
-interface TrackedProcess {
-  pid: number;
-  sessionId: string;
-  snapshot: ProcessSnapshot;
-}
-
-export const resourceMonitor = new EventEmitter();
-
-const tracked = new Map<number, TrackedProcess>();
-
-let timer: ReturnType<typeof setInterval> | null = null;
-
-function startIfNeeded(): void {
-  if (timer) return;
-  timer = setInterval(checkAll, CHECK_INTERVAL_MS);
-  timer.unref?.();
-}
-
-function stopIfIdle(): void {
-  if (tracked.size > 0) return;
-  if (timer) { clearInterval(timer); timer = null; }
-}
-
-export function registerProcess(pid: number, sessionId: string): void {
-  tracked.set(pid, { pid, sessionId, snapshot: { cpu: -1, memory: -1, unchangedCount: 0 } });
-  startIfNeeded();
-}
-
-export function unregisterProcess(pid: number): void {
-  tracked.delete(pid);
-  stopIfIdle();
-}
-
-// ---------------------------------------------------------------------------
-// 批量查询进程指标（Windows PowerShell）
-// ---------------------------------------------------------------------------
-
-function execPowerShell(script: string, timeoutMs: number): Promise<string> {
-  return new Promise((resolve, reject) => {
-    exec(
-      `powershell -NoProfile -Command "${script}"`,
-      { timeout: timeoutMs, windowsHide: true },
-      (err, stdout) => {
-        if (err) reject(err);
-        else resolve(stdout);
-      },
-    );
-  });
-}
-
-async function getProcessMetrics(pids: number[]): Promise<Map<number, { cpu: number; memory: number }>> {
-  const result = new Map<number, { cpu: number; memory: number }>();
-  if (pids.length === 0) return result;
-
-  const psScript = `Get-Process -Id ${pids.join(",")} -ErrorAction SilentlyContinue | ForEach-Object { "$($_.Id)|$($_.CPU)|$($_.WorkingSet64)" }`;
-
-  try {
-    const stdout = await execPowerShell(psScript, 10_000);
-    for (const line of stdout.trim().split(/\r?\n/)) {
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      const [idStr, cpuStr, memStr] = trimmed.split("|");
-      const id = parseInt(idStr, 10);
-      const cpu = parseFloat(cpuStr);
-      const memory = parseInt(memStr, 10);
-      if (!isNaN(id) && !isNaN(cpu) && !isNaN(memory)) {
-        result.set(id, { cpu, memory });
-      }
-    }
-  } catch {
-    // PowerShell 查询失败时跳过本轮，下次重试
-  }
-
-  return result;
-}
-
-// ---------------------------------------------------------------------------
-// 定时检查
-// ---------------------------------------------------------------------------
-
-async function checkAll(): Promise<void> {
-  if (tracked.size === 0) return;
-
-  const pids = [...tracked.keys()];
-  const metrics = await getProcessMetrics(pids);
-
-  for (const [pid, tp] of tracked) {
-    const m = metrics.get(pid);
-    if (!m) {
-      // 进程已不存在，停止追踪
-      tracked.delete(pid);
-      continue;
-    }
-
-    const prev = tp.snapshot;
-    const cpuChanged = m.cpu !== prev.cpu;
-    // 内存允许 ±1% 波动，避免正常抖动触发误判
-    const memTolerance = prev.memory > 0 ? Math.max(prev.memory * 0.01, 1024 * 1024) : 1024 * 1024;
-    const memChanged = Math.abs(m.memory - prev.memory) > memTolerance;
-
-    if (!cpuChanged && !memChanged) {
-      tp.snapshot.unchangedCount++;
-      if (tp.snapshot.unchangedCount >= STUCK_THRESHOLD) {
-        const idleMinutes = Math.round(
-          (tp.snapshot.unchangedCount * CHECK_INTERVAL_MS) / 60_000,
-        );
-        resourceMonitor.emit("stuck", {
-          pid: tp.pid,
-          sessionId: tp.sessionId,
-          idleMinutes,
-        });
-        tracked.delete(pid);
-      }
-    } else {
-      tp.snapshot.unchangedCount = 0;
-    }
-    tp.snapshot.cpu = m.cpu;
-    tp.snapshot.memory = m.memory;
-  }
-
-  stopIfIdle();
+// =============================================================================
+// resource-monitor.ts — CLI 进程资源监控（CPU + 内存）
+// =============================================================================
+// 对所有 chatccc 启动的 CLI 进程持续监控 CPU 和内存占用。
+// 若连续 3 分钟两项指标均无变化，判定为僵死，发出 "stuck" 事件。
+// =============================================================================
+
+import { exec } from "node:child_process";
+import { EventEmitter } from "node:events";
+
+const CHECK_INTERVAL_MS = 30_000; // 30 秒检查一次
+const STUCK_THRESHOLD = 6; // 连续 6 次无变化 = 3 分钟
+
+interface ProcessSnapshot {
+  cpu: number;
+  memory: number;
+  unchangedCount: number;
+}
+
+interface TrackedProcess {
+  pid: number;
+  sessionId: string;
+  snapshot: ProcessSnapshot;
+}
+
+export const resourceMonitor = new EventEmitter();
+
+const tracked = new Map<number, TrackedProcess>();
+
+let timer: ReturnType<typeof setInterval> | null = null;
+
+function startIfNeeded(): void {
+  if (timer) return;
+  timer = setInterval(checkAll, CHECK_INTERVAL_MS);
+  timer.unref?.();
+}
+
+function stopIfIdle(): void {
+  if (tracked.size > 0) return;
+  if (timer) { clearInterval(timer); timer = null; }
+}
+
+export function registerProcess(pid: number, sessionId: string): void {
+  tracked.set(pid, { pid, sessionId, snapshot: { cpu: -1, memory: -1, unchangedCount: 0 } });
+  startIfNeeded();
+}
+
+export function unregisterProcess(pid: number): void {
+  tracked.delete(pid);
+  stopIfIdle();
+}
+
+// ---------------------------------------------------------------------------
+// 批量查询进程指标（Windows PowerShell）
+// ---------------------------------------------------------------------------
+
+function execPowerShell(script: string, timeoutMs: number): Promise<string> {
+  return new Promise((resolve, reject) => {
+    exec(
+      `powershell -NoProfile -Command "${script}"`,
+      { timeout: timeoutMs, windowsHide: true },
+      (err, stdout) => {
+        if (err) reject(err);
+        else resolve(stdout);
+      },
+    );
+  });
+}
+
+async function getProcessMetrics(pids: number[]): Promise<Map<number, { cpu: number; memory: number }>> {
+  const result = new Map<number, { cpu: number; memory: number }>();
+  if (pids.length === 0) return result;
+
+  const psScript = `Get-Process -Id ${pids.join(",")} -ErrorAction SilentlyContinue | ForEach-Object { "$($_.Id)|$($_.CPU)|$($_.WorkingSet64)" }`;
+
+  try {
+    const stdout = await execPowerShell(psScript, 10_000);
+    for (const line of stdout.trim().split(/\r?\n/)) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      const [idStr, cpuStr, memStr] = trimmed.split("|");
+      const id = parseInt(idStr, 10);
+      const cpu = parseFloat(cpuStr);
+      const memory = parseInt(memStr, 10);
+      if (!isNaN(id) && !isNaN(cpu) && !isNaN(memory)) {
+        result.set(id, { cpu, memory });
+      }
+    }
+  } catch {
+    // PowerShell 查询失败时跳过本轮，下次重试
+  }
+
+  return result;
+}
+
+// ---------------------------------------------------------------------------
+// 定时检查
+// ---------------------------------------------------------------------------
+
+async function checkAll(): Promise<void> {
+  if (tracked.size === 0) return;
+
+  const pids = [...tracked.keys()];
+  const metrics = await getProcessMetrics(pids);
+
+  for (const [pid, tp] of tracked) {
+    const m = metrics.get(pid);
+    if (!m) {
+      // 进程已不存在，停止追踪
+      tracked.delete(pid);
+      continue;
+    }
+
+    const prev = tp.snapshot;
+    const cpuChanged = m.cpu !== prev.cpu;
+    // 内存允许 ±1% 波动，避免正常抖动触发误判
+    const memTolerance = prev.memory > 0 ? Math.max(prev.memory * 0.01, 1024 * 1024) : 1024 * 1024;
+    const memChanged = Math.abs(m.memory - prev.memory) > memTolerance;
+
+    if (!cpuChanged && !memChanged) {
+      tp.snapshot.unchangedCount++;
+      if (tp.snapshot.unchangedCount >= STUCK_THRESHOLD) {
+        const idleMinutes = Math.round(
+          (tp.snapshot.unchangedCount * CHECK_INTERVAL_MS) / 60_000,
+        );
+        resourceMonitor.emit("stuck", {
+          pid: tp.pid,
+          sessionId: tp.sessionId,
+          idleMinutes,
+        });
+        tracked.delete(pid);
+      }
+    } else {
+      tp.snapshot.unchangedCount = 0;
+    }
+    tp.snapshot.cpu = m.cpu;
+    tp.snapshot.memory = m.memory;
+  }
+
+  stopIfIdle();
 }