chatccc 0.2.191 → 0.2.193

package/bin/cccagent.mjs

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+
+const require = createRequire(import.meta.url);
+const pkgRoot = dirname(require.resolve("../package.json"));
+const cliTs = join(pkgRoot, "src", "builtin", "cli.ts");
+const tsxCli = require.resolve("tsx/cli");
+
+const result = spawnSync(process.execPath, [tsxCli, cliTs, ...process.argv.slice(2)], {
+  stdio: "inherit",
+  cwd: process.cwd(),
+  env: process.env,
+});
+
+process.exit(result.status === null ? 1 : result.status);

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "chatccc",
-  "version": "0.2.191",
+  "version": "0.2.193",
   "description": "Feishu bot bridge for Claude Code",
   "license": "Apache-2.0",
   "type": "module",
   "main": "./src/index.ts",
   "bin": {
-    "chatccc": "bin/chatccc.mjs"
+    "chatccc": "bin/chatccc.mjs",
+    "cccagent": "bin/cccagent.mjs"
   },
   "files": [
     "src/",

package/src/__tests__/builtin-chat-session.test.ts

@@ -0,0 +1,76 @@
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const streamTextMock = vi.fn();
+const generateTextMock = vi.fn();
+
+vi.mock("@ai-sdk/openai-compatible", () => ({
+  createOpenAICompatible: vi.fn(() => (modelId: string) => ({ modelId })),
+}));
+
+vi.mock("ai", () => ({
+  streamText: streamTextMock,
+  generateText: generateTextMock,
+}));
+
+async function collect(iterable: AsyncIterable<unknown>): Promise<unknown[]> {
+  const events: unknown[] = [];
+  for await (const event of iterable) events.push(event);
+  return events;
+}
+
+async function* textStream(...chunks: string[]): AsyncIterable<string> {
+  for (const chunk of chunks) yield chunk;
+}
+
+afterEach(() => {
+  streamTextMock.mockReset();
+  generateTextMock.mockReset();
+});
+
+describe("ChatSession context management", () => {
+  it("loads persisted context, compacts older messages, and persists the new assistant reply", async () => {
+    const { ChatSession } = await import("../builtin/index.ts");
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-session-context-"));
+
+    const seed = new ChatSession(
+      { apiKey: "sk-test" },
+      {
+        persist: true,
+        contextDir: dir,
+        sessionId: "integration",
+        compactAtTokens: 10_000,
+      },
+    );
+    streamTextMock.mockReturnValueOnce({ textStream: textStream("old answer") });
+    await collect(seed.chat("old question"));
+
+    generateTextMock.mockResolvedValueOnce({ text: "## 当前任务状态\n- 旧问题已总结" });
+    streamTextMock.mockReturnValueOnce({ textStream: textStream("new answer") });
+
+    const restored = new ChatSession(
+      { apiKey: "sk-test" },
+      {
+        persist: true,
+        contextDir: dir,
+        sessionId: "integration",
+        compactAtTokens: 1,
+        keepRecentMessages: 1,
+      },
+    );
+    const events = await collect(restored.chat("new question"));
+
+    expect(generateTextMock).toHaveBeenCalledOnce();
+    expect(streamTextMock).toHaveBeenLastCalledWith(expect.objectContaining({
+      messages: expect.arrayContaining([
+        expect.objectContaining({ content: expect.stringContaining("旧问题已总结") }),
+        expect.objectContaining({ role: "user", content: "new question" }),
+      ]),
+    }));
+    expect(events).toContainEqual({ type: "compact", compactedMessages: 2 });
+    expect(restored.history.map((m) => m.content).join("\n")).toContain("new answer");
+  });
+});

package/src/__tests__/builtin-cli-json.test.ts

@@ -0,0 +1,39 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+import { describe, expect, it } from "vitest";
+
+const execFileAsync = promisify(execFile);
+
+describe("builtin cli --stream-json", () => {
+  it("writes only JSON lines to stdout when startup fails", async () => {
+    let caught: unknown;
+    try {
+      await execFileAsync(process.execPath, [
+        "bin/cccagent.mjs",
+        "--stream-json",
+        "--prompt",
+        "hello",
+        "--api-key",
+        "",
+      ], {
+        cwd: process.cwd(),
+        timeout: 10_000,
+        windowsHide: true,
+      });
+    } catch (err) {
+      caught = err;
+    }
+
+    expect(caught).toMatchObject({ code: 1 });
+    const stdout = (caught as { stdout?: string }).stdout ?? "";
+    const lines = stdout.trim().split(/\r?\n/).filter(Boolean);
+    expect(lines.length).toBeGreaterThan(0);
+    for (const line of lines) {
+      expect(() => JSON.parse(line)).not.toThrow();
+    }
+    expect(JSON.parse(lines.at(-1)!)).toEqual(expect.objectContaining({
+      type: "error",
+    }));
+  });
+});

package/src/__tests__/builtin-context.test.ts

@@ -0,0 +1,163 @@
+import { mkdtemp, readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { describe, expect, it } from "vitest";
+
+import {
+  BuiltinContextManager,
+  estimateBuiltinContextTokens,
+  listBuiltinContextSessions,
+  newBuiltinSessionId,
+  serializeMessagesForSummary,
+} from "../builtin/context.ts";
+
+describe("BuiltinContextManager", () => {
+  it("persists and restores summary, messages, and total message count", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-builtin-context-"));
+
+    const first = new BuiltinContextManager({
+      persist: true,
+      contextDir: dir,
+      sessionId: "persisted",
+    });
+    first.setSummary("## 用户目标\n- 保留这个摘要");
+    first.appendMessage({ role: "user", content: "第一轮" });
+    first.appendMessage({ role: "assistant", content: "第一轮回复" });
+    first.save();
+
+    const restored = new BuiltinContextManager({
+      persist: true,
+      contextDir: dir,
+      sessionId: "persisted",
+    });
+
+    expect(restored.summary).toContain("保留这个摘要");
+    expect(restored.messages).toEqual([
+      { role: "user", content: "第一轮" },
+      { role: "assistant", content: "第一轮回复" },
+    ]);
+    expect(restored.totalMessages).toBe(2);
+  });
+
+  it("selects only older messages for compaction and keeps recent messages raw", () => {
+    const context = new BuiltinContextManager({
+      compactAtTokens: 1,
+      keepRecentMessages: 2,
+      persist: false,
+    });
+    context.appendMessage({ role: "user", content: "旧用户消息" });
+    context.appendMessage({ role: "assistant", content: "旧助手回复" });
+    context.appendMessage({ role: "user", content: "近期用户消息" });
+    context.appendMessage({ role: "assistant", content: "近期助手回复" });
+
+    const plan = context.planCompaction();
+
+    expect(plan).not.toBeNull();
+    expect(plan?.oldMessages).toEqual([
+      { role: "user", content: "旧用户消息" },
+      { role: "assistant", content: "旧助手回复" },
+    ]);
+    expect(plan?.recentMessages).toEqual([
+      { role: "user", content: "近期用户消息" },
+      { role: "assistant", content: "近期助手回复" },
+    ]);
+  });
+
+  it("applies a compacted summary and builds model messages with summary plus recent raw turns", () => {
+    const context = new BuiltinContextManager({
+      compactAtTokens: 1,
+      keepRecentMessages: 1,
+      persist: false,
+    });
+    context.appendMessage({ role: "user", content: "old" });
+    context.appendMessage({ role: "assistant", content: "recent" });
+
+    const plan = context.planCompaction();
+    expect(plan).not.toBeNull();
+    context.applyCompaction("## 当前任务状态\n- 已压缩旧上下文", plan!);
+
+    expect(context.summary).toContain("已压缩旧上下文");
+    expect(context.messages).toEqual([{ role: "assistant", content: "recent" }]);
+    expect(context.buildModelMessages()).toEqual([
+      {
+        role: "user",
+        content: expect.stringContaining("较早对话摘要"),
+      },
+      { role: "assistant", content: "recent" },
+    ]);
+  });
+
+  it("reset clears memory and the persisted context file", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-builtin-context-reset-"));
+    const context = new BuiltinContextManager({
+      persist: true,
+      contextDir: dir,
+      sessionId: "reset",
+    });
+    context.setSummary("summary");
+    context.appendMessage({ role: "user", content: "hello" });
+    context.save();
+
+    context.reset();
+
+    expect(context.summary).toBe("");
+    expect(context.messages).toEqual([]);
+    expect(context.totalMessages).toBe(0);
+
+    const raw = await readFile(join(dir, "reset", "context.json"), "utf8");
+    const persisted = JSON.parse(raw) as { summary: string; messages: unknown[]; totalMessages: number };
+    expect(persisted.summary).toBe("");
+    expect(persisted.messages).toEqual([]);
+    expect(persisted.totalMessages).toBe(0);
+  });
+
+  it("persists cwd metadata and lists saved sessions newest first", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-builtin-context-list-"));
+
+    const first = new BuiltinContextManager({
+      persist: true,
+      contextDir: dir,
+      sessionId: "older",
+      cwd: "C:\\repo-a",
+    });
+    first.appendMessage({ role: "user", content: "old" });
+
+    const second = new BuiltinContextManager({
+      persist: true,
+      contextDir: dir,
+      sessionId: "newer",
+      cwd: "C:\\repo-b",
+    });
+    second.appendMessage({ role: "user", content: "new" });
+
+    const sessions = listBuiltinContextSessions(dir);
+
+    expect(sessions.map((s) => s.sessionId)).toEqual(["newer", "older"]);
+    expect(sessions[0]).toEqual(expect.objectContaining({
+      cwd: "C:\\repo-b",
+      totalMessages: 1,
+      hasSummary: false,
+    }));
+  });
+});
+
+describe("builtin context helpers", () => {
+  it("creates readable timestamp-based session ids", () => {
+    const id = newBuiltinSessionId(new Date(2026, 6, 2, 12, 15, 30), "a1b2c3");
+
+    expect(id).toBe("session-20260702-121530-a1b2c3");
+  });
+
+  it("estimates tokens from summary and messages", () => {
+    expect(estimateBuiltinContextTokens("abc", [{ role: "user", content: "abcdef" }]))
+      .toBeGreaterThanOrEqual(3);
+  });
+
+  it("serializes messages for summarization with stable role labels", () => {
+    expect(serializeMessagesForSummary([
+      { role: "user", content: "你好" },
+      { role: "assistant", content: "收到" },
+    ])).toContain("user");
+  });
+});

package/src/__tests__/builtin-session-select.test.ts

@@ -0,0 +1,116 @@
+import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { describe, expect, it } from "vitest";
+
+import { defaultBuiltinSessionId } from "../builtin/context.ts";
+import { resolveBuiltinSession } from "../builtin/session-select.ts";
+
+async function writeSession(
+  contextDir: string,
+  sessionId: string,
+  options: { cwd?: string; updatedAt: number; totalMessages?: number },
+): Promise<void> {
+  const dir = join(contextDir, sessionId);
+  await mkdir(dir, { recursive: true });
+  await writeFile(
+    join(dir, "context.json"),
+    JSON.stringify({
+      version: 1,
+      createdAt: options.updatedAt,
+      updatedAt: options.updatedAt,
+      sessionId,
+      ...(options.cwd ? { cwd: options.cwd } : {}),
+      summary: "",
+      messages: [],
+      totalMessages: options.totalMessages ?? 0,
+      compactedMessages: 0,
+    }),
+    "utf8",
+  );
+}
+
+describe("resolveBuiltinSession", () => {
+  it("creates a fresh timestamp session by default", async () => {
+    const contextDir = await mkdtemp(join(tmpdir(), "chatccc-session-select-new-"));
+
+    const result = resolveBuiltinSession({
+      cwd: "C:\\repo",
+      contextDir,
+      now: new Date(2026, 6, 2, 12, 15, 30),
+      randomSuffix: "a1b2c3",
+    });
+
+    expect(result).toEqual({
+      mode: "new",
+      sessionId: "session-20260702-121530-a1b2c3",
+    });
+  });
+
+  it("resumes an explicit existing session id", async () => {
+    const contextDir = join(tmpdir(), `chatccc-session-select-explicit-${Date.now()}`);
+    await writeSession(contextDir, "manual-session", { updatedAt: 1 });
+
+    expect(resolveBuiltinSession({
+      cwd: "C:\\repo",
+      contextDir,
+      resume: "manual-session",
+    })).toEqual({
+      mode: "resumed",
+      sessionId: "manual-session",
+    });
+  });
+
+  it("fails when an explicit session id does not exist", async () => {
+    const contextDir = join(tmpdir(), `chatccc-session-select-missing-${Date.now()}`);
+
+    expect(() => resolveBuiltinSession({
+      cwd: "C:\\repo",
+      contextDir,
+      resume: "missing",
+    })).toThrow("未找到 ccc 会话: missing");
+  });
+
+  it("resumes the newest session for cwd when resume has no id", async () => {
+    const contextDir = join(tmpdir(), `chatccc-session-select-cwd-${Date.now()}`);
+    await writeSession(contextDir, "old-match", { cwd: "C:\\repo", updatedAt: 1_000 });
+    await writeSession(contextDir, "new-match", { cwd: "C:\\repo", updatedAt: 2_000 });
+    await writeSession(contextDir, "other-cwd", { cwd: "C:\\other", updatedAt: 3_000 });
+
+    expect(resolveBuiltinSession({
+      cwd: "C:\\repo",
+      contextDir,
+      resume: true,
+    })).toEqual({
+      mode: "resumed",
+      sessionId: "new-match",
+    });
+  });
+
+  it("resumes legacy cwd-hash sessions when resume has no id", async () => {
+    const contextDir = join(tmpdir(), `chatccc-session-select-legacy-${Date.now()}`);
+    const cwd = "C:\\repo";
+    const legacySessionId = defaultBuiltinSessionId(cwd);
+    await writeSession(contextDir, legacySessionId, { updatedAt: 1_000 });
+
+    expect(resolveBuiltinSession({
+      cwd,
+      contextDir,
+      resume: true,
+    })).toEqual({
+      mode: "resumed",
+      sessionId: legacySessionId,
+    });
+  });
+
+  it("fails when there is no cwd session to resume", async () => {
+    const contextDir = join(tmpdir(), `chatccc-session-select-empty-${Date.now()}`);
+
+    expect(() => resolveBuiltinSession({
+      cwd: "C:\\repo",
+      contextDir,
+      resume: true,
+    })).toThrow("未找到当前目录可恢复的 ccc 会话");
+  });
+});

package/src/__tests__/builtin-sigint.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it } from "vitest";
+
+import { createCtrlCState } from "../builtin/sigint.ts";
+
+describe("builtin CLI Ctrl+C state", () => {
+  it("requires two presses to interrupt an active generation", () => {
+    let now = 1_000;
+    const state = createCtrlCState({ windowMs: 2_000, now: () => now });
+
+    expect(state.press(true)).toBe("arm-interrupt");
+    expect(state.press(true)).toBe("interrupt");
+  });
+
+  it("requires two presses to exit while idle", () => {
+    let now = 1_000;
+    const state = createCtrlCState({ windowMs: 2_000, now: () => now });
+
+    expect(state.press(false)).toBe("arm-exit");
+    expect(state.press(false)).toBe("exit");
+  });
+
+  it("expires the pending confirmation after the window", () => {
+    let now = 1_000;
+    const state = createCtrlCState({ windowMs: 2_000, now: () => now });
+
+    expect(state.press(true)).toBe("arm-interrupt");
+
+    now += 2_001;
+
+    expect(state.press(true)).toBe("arm-interrupt");
+    expect(state.press(true)).toBe("interrupt");
+  });
+
+  it("does not convert a pending interrupt into an idle exit after reset", () => {
+    let now = 1_000;
+    const state = createCtrlCState({ windowMs: 2_000, now: () => now });
+
+    expect(state.press(true)).toBe("arm-interrupt");
+
+    state.reset();
+    now += 1_000;
+
+    expect(state.press(false)).toBe("arm-exit");
+  });
+
+  it("does not confirm a different action with the second press", () => {
+    let now = 1_000;
+    const state = createCtrlCState({ windowMs: 2_000, now: () => now });
+
+    expect(state.press(true)).toBe("arm-interrupt");
+    now += 500;
+
+    expect(state.press(false)).toBe("arm-exit");
+    expect(state.press(false)).toBe("exit");
+  });
+});

package/src/__tests__/cards.test.ts

@@ -170,6 +170,15 @@ describe("buildHelpCard", () => {
     expect(lines).toContain("发送 **/usage** 查看 Codex 5h/周用量，以及查询/使用主动重置卡");
     expect(lines.at(-1)).toBe(ABD_HELP_LINE);
   });
+
+  it("does not advertise the hidden ccc agent", () => {
+    const card = buildHelpCard("test");
+    const parsed = JSON.parse(card);
+    const text = JSON.stringify(parsed);
+
+    expect(text).not.toContain("/new ccc");
+    expect(text).not.toContain("CCC Agent");
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -364,17 +373,29 @@ describe("buildSessionsCard", () => {
     expect(content).toContain("Cursor 会话");
   });
 
-  it("omits Cursor section when no Cursor sessions", () => {
-    const card = buildSessionsCard([
-      { sessionId: "c1", chatName: "", chatId: "oc_c1", active: false, turnCount: 1, elapsedSeconds: null, model: "(留空)", tool: "claude" },
-    ]);
-    const parsed = JSON.parse(card);
-    const content: string = parsed.elements[0].text.content;
-    expect(content).toContain("Claude Code 会话");
-    expect(content).not.toContain("Cursor 会话");
-  });
-
-  it("displays chatName when provided", () => {
+  it("omits Cursor section when no Cursor sessions", () => {
+    const card = buildSessionsCard([
+      { sessionId: "c1", chatName: "", chatId: "oc_c1", active: false, turnCount: 1, elapsedSeconds: null, model: "(留空)", tool: "claude" },
+    ]);
+    const parsed = JSON.parse(card);
+    const content: string = parsed.elements[0].text.content;
+    expect(content).toContain("Claude Code 会话");
+    expect(content).not.toContain("Cursor 会话");
+  });
+
+  it("labels hidden ccc sessions without grouping them as Claude Code", () => {
+    const card = buildSessionsCard([
+      { sessionId: "session-20260702-121530-a1b2c3", chatName: "", chatId: "oc_ccc", active: false, turnCount: 1, elapsedSeconds: null, model: "deepseek-v4-pro", tool: "ccc" },
+    ]);
+    const parsed = JSON.parse(card);
+    const content: string = parsed.elements[0].text.content;
+
+    expect(content).toContain("CCC Agent 会话");
+    expect(content).toContain("工具: CCC Agent");
+    expect(content).not.toContain("Claude Code 会话");
+  });
+
+  it("displays chatName when provided", () => {
     const card = buildSessionsCard([
       { sessionId: "abc123", chatName: "帮我写代码-src", chatId: "oc_abc123", active: false, turnCount: 2, elapsedSeconds: null, model: "Claude Opus 4.7", tool: "claude" },
     ]);

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

@@ -0,0 +1,73 @@
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const streamTextMock = vi.fn();
+const generateTextMock = vi.fn();
+
+vi.mock("@ai-sdk/openai-compatible", () => ({
+  createOpenAICompatible: vi.fn(() => (modelId: string) => ({ modelId })),
+}));
+
+vi.mock("ai", () => ({
+  streamText: streamTextMock,
+  generateText: generateTextMock,
+}));
+
+async function* textStream(...chunks: string[]): AsyncIterable<string> {
+  for (const chunk of chunks) yield chunk;
+}
+
+afterEach(() => {
+  streamTextMock.mockReset();
+  generateTextMock.mockReset();
+});
+
+describe("createCccAdapter", () => {
+  it("creates a persisted ccc session and exposes model/cwd metadata", async () => {
+    const { createCccAdapter } = await import("../adapters/ccc-adapter.ts");
+    const contextDir = await mkdtemp(join(tmpdir(), "chatccc-ccc-adapter-meta-"));
+    const adapter = createCccAdapter({
+      apiKey: "sk-test",
+      contextDir,
+      model: "deepseek-v4-pro",
+    });
+
+    const created = await adapter.createSession("F:\\repo");
+    const info = await adapter.getSessionInfo(created.sessionId);
+
+    expect(created.sessionId).toMatch(/^session-\d{8}-\d{6}-[a-f0-9]{6}$/);
+    expect(info).toEqual(expect.objectContaining({
+      sessionId: created.sessionId,
+      cwd: "F:\\repo",
+      model: "deepseek-v4-pro",
+    }));
+  });
+
+  it("maps ChatSession text chunks to unified assistant text blocks", async () => {
+    const { createCccAdapter } = await import("../adapters/ccc-adapter.ts");
+    const contextDir = await mkdtemp(join(tmpdir(), "chatccc-ccc-adapter-stream-"));
+    const adapter = createCccAdapter({
+      apiKey: "sk-test",
+      contextDir,
+      model: "deepseek-v4-flash",
+    });
+    const { sessionId } = await adapter.createSession("F:\\repo");
+    streamTextMock.mockReturnValueOnce({ textStream: textStream("hello", " world") });
+
+    const messages = [];
+    for await (const message of adapter.prompt(sessionId, "hi", "F:\\repo")) {
+      messages.push(message);
+    }
+
+    expect(messages).toEqual([
+      { type: "assistant", blocks: [{ type: "text", text: "hello" }] },
+      { type: "assistant", blocks: [{ type: "text", text: " world" }] },
+    ]);
+    expect(streamTextMock).toHaveBeenCalledWith(expect.objectContaining({
+      model: { modelId: "deepseek-v4-flash" },
+    }));
+  });
+});

package/src/__tests__/orchestrator.test.ts

@@ -626,9 +626,9 @@ describe("handleCommand WeChat processing ack", () => {
     );
   });
 
-  it("advertises /usage in new Codex and Cursor session ready messages", async () => {
-    const codexPlatform = mockPlatform("feishu");
-    _setAdapterForToolForTest("codex", mockAdapter("sid-codex"));
+  it("advertises /usage in new Codex and Cursor session ready messages", async () => {
+    const codexPlatform = mockPlatform("feishu");
+    _setAdapterForToolForTest("codex", mockAdapter("sid-codex"));
 
     await handleCommand(codexPlatform, "/new codex", "feishu-p2p", "ou-user", Date.now(), "p2p");
 
@@ -652,9 +652,34 @@ describe("handleCommand WeChat processing ack", () => {
     const claudePlatform = mockPlatform("feishu");
     await handleCommand(claudePlatform, "/new claude", "feishu-p2p-2", "ou-user", Date.now(), "p2p");
 
-    const claudeReadyCall = vi.mocked(claudePlatform.sendCard).mock.calls.find(
-      ([chatId, title]) => chatId === "feishu-group" && title === "Claude Code Session Ready",
-    );
-    expect(claudeReadyCall?.[2]).not.toContain("/usage");
-  });
-});
+    const claudeReadyCall = vi.mocked(claudePlatform.sendCard).mock.calls.find(
+      ([chatId, title]) => chatId === "feishu-group" && title === "Claude Code Session Ready",
+    );
+    expect(claudeReadyCall?.[2]).not.toContain("/usage");
+  });
+
+  it("allows the hidden /new ccc entry without advertising it in normal help", async () => {
+    const platform = mockPlatform("feishu");
+    _setAdapterForToolForTest("ccc", mockAdapter("session-20260702-121530-a1b2c3"));
+
+    await handleCommand(platform, "/new ccc", "feishu-p2p-ccc", "ou-user", Date.now(), "p2p");
+
+    expect(platform.updateChatInfo).toHaveBeenCalledWith(
+      "feishu-group",
+      expect.any(String),
+      "CCC Session: session-20260702-121530-a1b2c3",
+    );
+    expect(platform.sendCard).toHaveBeenCalledWith(
+      "feishu-group",
+      "CCC Agent Session Ready",
+      expect.stringContaining("CCC Agent"),
+      "green",
+    );
+
+    const helpPlatform = mockPlatform("feishu");
+    await handleCommand(helpPlatform, "hello", "feishu-group-help", "ou-user", Date.now(), "group");
+    const helpCard = vi.mocked(helpPlatform.sendRawCard).mock.calls.at(-1)?.[1] as string;
+    expect(helpCard).not.toContain("/new ccc");
+    expect(helpCard).not.toContain("CCC Agent");
+  });
+});