chatccc 0.2.200 → 0.2.202

package/src/__tests__/orchestrator.test.ts

@@ -1,16 +1,16 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
+import { homedir, tmpdir } from "node:os";
 import { join } from "node:path";
 
 import type { PlatformAdapter } from "../platform-adapter.ts";
 import type { SessionInfo, ToolAdapter } from "../adapters/adapter-interface.ts";
 
 const mockStreamStates = new Map<string, { status: "running" | "done" | "stopped"; finalReply: string }>();
-const mockGetCodexUsageSummary = vi.hoisted(() => vi.fn());
-const mockGetCursorUsageSummary = vi.hoisted(() => vi.fn());
-const mockGetChatGptSubscriptionStatus = vi.hoisted(() => vi.fn());
-const mockReloadRuntimeConfig = vi.hoisted(() => vi.fn());
+const mockGetCodexUsageSummary = vi.hoisted(() => vi.fn());
+const mockGetCursorUsageSummary = vi.hoisted(() => vi.fn());
+const mockGetChatGptSubscriptionStatus = vi.hoisted(() => vi.fn());
+const mockReloadRuntimeConfig = vi.hoisted(() => vi.fn());
 
 vi.mock("../im-skills.ts", () => ({
   buildImSkillsPrompt: async () => "",
@@ -66,15 +66,15 @@ vi.mock("../cursor-usage.ts", () => ({
   getCursorUsageSummary: mockGetCursorUsageSummary,
 }));
 
-vi.mock("../chatgpt-subscription.ts", () => ({
-  getChatGptSubscriptionStatus: mockGetChatGptSubscriptionStatus,
-}));
-
-vi.mock("../runtime-reload.ts", () => ({
-  reloadRuntimeConfig: mockReloadRuntimeConfig,
-}));
-
-import { handleCommand } from "../orchestrator.ts";
+vi.mock("../chatgpt-subscription.ts", () => ({
+  getChatGptSubscriptionStatus: mockGetChatGptSubscriptionStatus,
+}));
+
+vi.mock("../runtime-reload.ts", () => ({
+  reloadRuntimeConfig: mockReloadRuntimeConfig,
+}));
+
+import { handleCommand } from "../orchestrator.ts";
 import {
   _clearAdapterCacheForTest,
   _resetSessionRegistryFileForTest,
@@ -82,14 +82,14 @@ import {
   _setAdapterForToolForTest,
   _setSessionRegistryFileForTest,
   _setSessionToolsFileForTest,
-  loadSessionRegistryForBinding,
-  recordSessionRegistry,
-  resetState,
-  sessionInfoMap,
-} from "../session.ts";
+  loadSessionRegistryForBinding,
+  recordSessionRegistry,
+  resetState,
+  sessionInfoMap,
+} from "../session.ts";
 import { activePrompts, resetBindingState } from "../session-chat-binding.ts";
-import { ABD_APPEND_PROMPT } from "../shared-prefix.ts";
-import { config } from "../config.ts";
+import { ABD_APPEND_PROMPT } from "../shared-prefix.ts";
+import { config } from "../config.ts";
 
 function mockPlatform(kind: "wechat" | "feishu" = "wechat"): PlatformAdapter {
   return {
@@ -136,16 +136,16 @@ describe("handleCommand WeChat processing ack", () => {
     tempDir = await mkdtemp(join(tmpdir(), "chatccc-orchestrator-"));
     _setSessionRegistryFileForTest(join(tempDir, "session-registry.json"));
     _setSessionToolsFileForTest(join(tempDir, "sessions.json"));
-    resetState();
-    resetBindingState();
-    config.claude.defaultAgent = true;
-    config.cursor.defaultAgent = false;
-    config.codex.defaultAgent = false;
-    mockStreamStates.clear();
-    mockGetCodexUsageSummary.mockReset();
-    mockGetCursorUsageSummary.mockReset();
-    mockGetChatGptSubscriptionStatus.mockReset();
-    mockReloadRuntimeConfig.mockReset();
+    resetState();
+    resetBindingState();
+    config.claude.defaultAgent = true;
+    config.cursor.defaultAgent = false;
+    config.codex.defaultAgent = false;
+    mockStreamStates.clear();
+    mockGetCodexUsageSummary.mockReset();
+    mockGetCursorUsageSummary.mockReset();
+    mockGetChatGptSubscriptionStatus.mockReset();
+    mockReloadRuntimeConfig.mockReset();
     mockGetCodexUsageSummary.mockResolvedValue({
       fiveHour: { usedPercent: 0, remainingPercent: 100, resetAtEpochSeconds: null, resetAfterSeconds: null },
       weekly: { usedPercent: 0, remainingPercent: 100, resetAtEpochSeconds: null, resetAfterSeconds: null },
@@ -177,19 +177,19 @@ describe("handleCommand WeChat processing ack", () => {
       displayMessage: "You've hit your usage limit",
       autoBucketModels: ["default"],
     });
-    mockGetChatGptSubscriptionStatus.mockResolvedValue({
-      ok: false,
-      code: "chrome_cdp_disabled",
-      reason: "Chrome CDP guard is disabled in ChatCCC config.",
-      chromeCdp: { enabled: false, port: 15166, status: "skipped" },
-    });
-    mockReloadRuntimeConfig.mockResolvedValue({
-      configPath: "C:\\Users\\me\\.chatccc\\config.json",
-      defaultAgent: "codex",
-      reloadedAt: "2026-07-02T05:00:00.000Z",
-    });
-    _setAdapterForToolForTest("claude", mockAdapter());
-  });
+    mockGetChatGptSubscriptionStatus.mockResolvedValue({
+      ok: false,
+      code: "chrome_cdp_disabled",
+      reason: "Chrome CDP guard is disabled in ChatCCC config.",
+      chromeCdp: { enabled: false, port: 15166, status: "skipped" },
+    });
+    mockReloadRuntimeConfig.mockResolvedValue({
+      configPath: "C:\\Users\\me\\.chatccc\\config.json",
+      defaultAgent: "codex",
+      reloadedAt: "2026-07-02T05:00:00.000Z",
+    });
+    _setAdapterForToolForTest("claude", mockAdapter());
+  });
 
   afterEach(async () => {
     resetState();
@@ -254,12 +254,12 @@ describe("handleCommand WeChat processing ack", () => {
     _setAdapterForToolForTest("claude", {
       displayName: "Claude",
       sessionDescPrefix: "Claude Session:",
-      createSession: vi.fn(async () => ({ sessionId: "sid-wechat" })),
-      prompt,
-      getSessionInfo: async (sessionId: string): Promise<SessionInfo> => ({
-        sessionId,
-        cwd: "F:\\repo",
-      }),
+      createSession: vi.fn(async () => ({ sessionId: "sid-wechat" })),
+      prompt,
+      getSessionInfo: async (sessionId: string): Promise<SessionInfo> => ({
+        sessionId,
+        cwd: "F:\\repo",
+      }),
       closeSession: async () => {},
     });
     await recordSessionRegistry({
@@ -298,9 +298,9 @@ describe("handleCommand WeChat processing ack", () => {
     expect(platform.sendText).not.toHaveBeenCalledWith("wx-chat", "会话已停止。");
   });
 
-  it("cleans stale Feishu p2p binding, creates a group, and sends the private message as first prompt", async () => {
-    const platform = mockPlatform("feishu");
-    const prompt = vi.fn(async function* (_sessionId: string, userText: string) {
+  it("resumes the Feishu p2p session in place instead of creating a group", async () => {
+    const platform = mockPlatform("feishu");
+    const prompt = vi.fn(async function* (_sessionId: string, userText: string) {
       yield {
         type: "assistant" as const,
         blocks: [{ type: "text" as const, text: `收到: ${userText}` }],
@@ -309,191 +309,354 @@ describe("handleCommand WeChat processing ack", () => {
     _setAdapterForToolForTest("claude", {
       displayName: "Claude",
       sessionDescPrefix: "Claude Session:",
-      createSession: vi.fn(async () => ({ sessionId: "sid-feishu-new" })),
-      prompt,
-      getSessionInfo: async (sessionId: string): Promise<SessionInfo> => ({
-        sessionId,
-        cwd: "F:\\repo",
-      }),
+      createSession: vi.fn(async () => ({ sessionId: "sid-feishu-new" })),
+      prompt,
+      getSessionInfo: async (sessionId: string): Promise<SessionInfo> => ({
+        sessionId,
+        cwd: homedir(),
+      }),
       closeSession: async () => {},
     });
-    await recordSessionRegistry({
-      chatId: "feishu-p2p",
-      sessionId: "stale-sid",
-      tool: "claude",
-      chatName: "旧私聊绑定",
-      running: false,
-    });
-
-    await handleCommand(platform, "帮我看一下日志", "feishu-p2p", "ou-user", Date.now(), "p2p");
-
-    expect(platform.createGroup).toHaveBeenCalledWith(expect.stringContaining("帮我看一下日志"), ["ou-user"]);
-    expect(platform.updateChatInfo).toHaveBeenCalledWith(
-      "feishu-group",
-      expect.stringContaining("帮我看一下日志"),
-      expect.stringContaining("sid-feishu-new"),
-    );
-    expect(prompt).toHaveBeenCalledWith(
-      "sid-feishu-new",
-      expect.stringContaining("帮我看一下日志"),
-      "F:\\repo",
-      expect.any(AbortSignal),
+    await recordSessionRegistry({
+      chatId: "feishu-p2p",
+      sessionId: "sid-feishu-private",
+      tool: "claude",
+      chatType: "p2p",
+      chatName: "飞书私聊",
+      running: false,
+    });
+
+    await handleCommand(platform, "帮我看一下日志", "feishu-p2p", "ou-user", Date.now(), "p2p");
+
+    expect(platform.createGroup).not.toHaveBeenCalled();
+    expect(platform.updateChatInfo).not.toHaveBeenCalled();
+    expect(prompt).toHaveBeenCalledWith(
+      "sid-feishu-private",
+      expect.stringContaining("帮我看一下日志"),
+      homedir(),
+      expect.any(AbortSignal),
       expect.any(Object),
     );
-
-    const registry = await loadSessionRegistryForBinding();
-    expect(registry["feishu-p2p"]).toBeUndefined();
-    expect(registry["feishu-group"]?.sessionId).toBe("sid-feishu-new");
-  });
-
-  it("auto-creates a Feishu group for /abd private messages and sends the transformed prompt", async () => {
-    const platform = mockPlatform("feishu");
-    const prompt = vi.fn(async function* (_sessionId: string, userText: string) {
+
+    const registry = await loadSessionRegistryForBinding();
+    expect(registry["feishu-p2p"]?.sessionId).toBe("sid-feishu-private");
+  });
+
+  it("creates the first Feishu p2p session in the OS user directory and sends the first prompt in place", async () => {
+    const platform = mockPlatform("feishu");
+    const createSession = vi.fn(async () => ({ sessionId: "sid-feishu-private" }));
+    const prompt = vi.fn(async function* (_sessionId: string, userText: string) {
+      yield {
+        type: "assistant" as const,
+        blocks: [{ type: "text" as const, text: `收到: ${userText}` }],
+      };
+    });
+    _setAdapterForToolForTest("claude", {
+      displayName: "Claude",
+      sessionDescPrefix: "Claude Session:",
+      createSession,
+      prompt,
+      getSessionInfo: async (sessionId: string): Promise<SessionInfo> => ({
+        sessionId,
+        cwd: homedir(),
+      }),
+      closeSession: async () => {},
+    });
+
+    await handleCommand(platform, "帮我看一下日志", "feishu-p2p", "ou-user", Date.now(), "p2p");
+
+    expect(createSession).toHaveBeenCalledWith(homedir());
+    expect(platform.createGroup).not.toHaveBeenCalled();
+    expect(platform.updateChatInfo).not.toHaveBeenCalled();
+    expect(prompt).toHaveBeenCalledWith(
+      "sid-feishu-private",
+      expect.stringContaining("帮我看一下日志"),
+      homedir(),
+      expect.any(AbortSignal),
+      expect.any(Object),
+    );
+
+    const registry = await loadSessionRegistryForBinding();
+    expect(registry["feishu-p2p"]?.sessionId).toBe("sid-feishu-private");
+    expect(registry["feishu-p2p"]?.tool).toBe("claude");
+    expect(registry["feishu-p2p"]?.chatType).toBe("p2p");
+  });
+
+  it("replaces an unmarked legacy Feishu p2p binding with a home-directory session", async () => {
+    const platform = mockPlatform("feishu");
+    const createSession = vi.fn(async () => ({ sessionId: "sid-feishu-migrated" }));
+    const prompt = vi.fn(async function* () {
+      yield {
+        type: "assistant" as const,
+        blocks: [{ type: "text" as const, text: "done" }],
+      };
+    });
+    _setAdapterForToolForTest("claude", {
+      displayName: "Claude",
+      sessionDescPrefix: "Claude Session:",
+      createSession,
+      prompt,
+      getSessionInfo: async (sessionId: string): Promise<SessionInfo> => ({
+        sessionId,
+        cwd: homedir(),
+      }),
+      closeSession: async () => {},
+    });
+    await recordSessionRegistry({
+      chatId: "feishu-p2p",
+      sessionId: "sid-feishu-legacy",
+      tool: "claude",
+      chatName: "旧私聊绑定",
+      running: false,
+    });
+
+    await handleCommand(platform, "继续", "feishu-p2p", "ou-user", Date.now(), "p2p");
+
+    expect(createSession).toHaveBeenCalledWith(homedir());
+    expect(prompt).toHaveBeenCalledWith(
+      "sid-feishu-migrated",
+      expect.stringContaining("继续"),
+      homedir(),
+      expect.any(AbortSignal),
+      expect.any(Object),
+    );
+    expect(platform.createGroup).not.toHaveBeenCalled();
+    const registry = await loadSessionRegistryForBinding();
+    expect(registry["feishu-p2p"]?.sessionId).toBe("sid-feishu-migrated");
+    expect(registry["feishu-p2p"]?.chatType).toBe("p2p");
+  });
+
+  it("creates a Feishu p2p session for /abd and sends the transformed prompt without creating a group", async () => {
+    const platform = mockPlatform("feishu");
+    const createSession = vi.fn(async () => ({ sessionId: "sid-feishu-abd" }));
+    const prompt = vi.fn(async function* (_sessionId: string, userText: string) {
       yield {
         type: "assistant" as const,
         blocks: [{ type: "text" as const, text: "done" }],
       };
     });
     _setAdapterForToolForTest("claude", {
-      displayName: "Claude",
-      sessionDescPrefix: "Claude Session:",
-      createSession: vi.fn(async () => ({ sessionId: "sid-feishu-abd" })),
+      displayName: "Claude",
+      sessionDescPrefix: "Claude Session:",
+      createSession,
       prompt,
       getSessionInfo: async (sessionId: string): Promise<SessionInfo> => ({
         sessionId,
-        cwd: "F:\\repo",
+        cwd: homedir(),
       }),
       closeSession: async () => {},
     });
-
-    await handleCommand(platform, "/abd帮我看一下日志", "feishu-p2p", "ou-user", Date.now(), "p2p");
-
-    expect(platform.createGroup).toHaveBeenCalledWith(expect.stringContaining("帮我看一下日志"), ["ou-user"]);
-    expect(platform.createGroup).not.toHaveBeenCalledWith(expect.stringContaining("---"), expect.anything());
-    const updateCall = vi.mocked(platform.updateChatInfo).mock.calls[0];
-    expect(updateCall[1]).not.toContain("---");
-    expect(updateCall[1]).not.toContain(ABD_APPEND_PROMPT);
-    const userText = prompt.mock.calls[0][1];
-    expect(userText).toContain(`[User message]\n帮我看一下日志\n\n---\n${ABD_APPEND_PROMPT}\n[/User message]`);
-    expect(userText).not.toContain("/abd");
-  });
-
-  it("cleans stale Feishu p2p binding but keeps valid commands from auto-creating a group", async () => {
-    const platform = mockPlatform("feishu");
-    await recordSessionRegistry({
-      chatId: "feishu-p2p",
-      sessionId: "stale-sid",
-      tool: "claude",
-      chatName: "旧私聊绑定",
-      running: false,
-    });
-
-    await handleCommand(platform, "/model", "feishu-p2p", "ou-user", Date.now(), "p2p");
-
-    expect(platform.createGroup).not.toHaveBeenCalled();
-    expect(platform.sendRawCard).toHaveBeenCalled();
-    const registry = await loadSessionRegistryForBinding();
-    expect(registry["feishu-p2p"]).toBeUndefined();
-  });
-
-  it("shows Claude effort switch card in an active Feishu session", async () => {
-    const platform = mockPlatform("feishu");
-    vi.mocked(platform.getChatInfo).mockResolvedValue({ name: "claude-session", description: "Claude Session: sid-claude-effort" });
-    vi.mocked(platform.extractSessionInfo).mockReturnValue({ sessionId: "sid-claude-effort", tool: "claude" });
-    await recordSessionRegistry({
-      chatId: "feishu-chat",
-      sessionId: "sid-claude-effort",
-      tool: "claude",
-      chatName: "claude-session",
-      running: false,
-    });
-    sessionInfoMap.set("feishu-chat", {
-      sessionId: "sid-claude-effort",
-      tool: "claude",
-      turnCount: 0,
-      lastContextTokens: 0,
-      startTime: Date.now(),
-    });
-
-    await handleCommand(platform, "/effort", "feishu-chat", "ou-user", Date.now(), "group");
-
-    expect(platform.sendRawCard).toHaveBeenCalled();
-    const card = JSON.parse(vi.mocked(platform.sendRawCard).mock.calls[0][1]);
-    const raw = JSON.stringify(card);
-    expect(raw).toContain("/effort low");
-    expect(raw).toContain("/effort xhigh");
-    expect(raw).toContain("/effort max");
-  });
-
-  it("switches Codex effort for the current session and reflects it in /state", async () => {
-    const platform = mockPlatform("feishu");
-    vi.mocked(platform.getChatInfo).mockResolvedValue({ name: "codex-session", description: "Codex Session: sid-codex-effort" });
-    vi.mocked(platform.extractSessionInfo).mockReturnValue({ sessionId: "sid-codex-effort", tool: "codex" });
-    _setAdapterForToolForTest("codex", mockAdapter("sid-codex-effort"));
-    await recordSessionRegistry({
-      chatId: "codex-chat",
-      sessionId: "sid-codex-effort",
-      tool: "codex",
-      chatName: "codex-session",
-      running: false,
-    });
-    sessionInfoMap.set("codex-chat", {
-      sessionId: "sid-codex-effort",
-      tool: "codex",
-      turnCount: 0,
-      lastContextTokens: 0,
-      startTime: Date.now(),
-    });
-
-    await handleCommand(platform, "/effort xhigh", "codex-chat", "ou-user", Date.now(), "group");
-    expect(platform.sendCard).toHaveBeenCalledWith(
-      "codex-chat",
-      "Effort 切换",
-      expect.stringContaining("xhigh"),
-      "green",
-    );
-
-    vi.mocked(platform.sendCard).mockClear();
-    vi.mocked(platform.sendRawCard).mockClear();
-    await handleCommand(platform, "/state", "codex-chat", "ou-user", Date.now() + 1, "group");
-
-    expect(platform.sendRawCard).toHaveBeenCalled();
-    const card = JSON.parse(vi.mocked(platform.sendRawCard).mock.calls[0][1]);
-    expect(JSON.stringify(card)).toContain("xhigh");
-  });
-
-  it("rejects /effort in Cursor sessions", async () => {
-    const platform = mockPlatform("feishu");
-    vi.mocked(platform.getChatInfo).mockResolvedValue({ name: "cursor-session", description: "Cursor Session: sid-cursor-effort" });
-    vi.mocked(platform.extractSessionInfo).mockReturnValue({ sessionId: "sid-cursor-effort", tool: "cursor" });
-    _setAdapterForToolForTest("cursor", mockAdapter("sid-cursor-effort"));
-    await recordSessionRegistry({
-      chatId: "cursor-chat",
-      sessionId: "sid-cursor-effort",
-      tool: "cursor",
-      chatName: "cursor-session",
-      running: false,
-    });
-    sessionInfoMap.set("cursor-chat", {
-      sessionId: "sid-cursor-effort",
-      tool: "cursor",
-      turnCount: 0,
-      lastContextTokens: 0,
-      startTime: Date.now(),
-    });
-
-    await handleCommand(platform, "/effort high", "cursor-chat", "ou-user", Date.now(), "group");
-
-    expect(platform.sendCard).toHaveBeenCalledWith(
-      "cursor-chat",
-      "Effort 切换",
-      expect.stringContaining("不支持 effort"),
-      "red",
-    );
-  });
-
-  it("handles /usage without creating a new Feishu group", async () => {
-    const platform = mockPlatform("feishu");
+
+    await handleCommand(platform, "/abd帮我看一下日志", "feishu-p2p", "ou-user", Date.now(), "p2p");
+
+    expect(createSession).toHaveBeenCalledWith(homedir());
+    expect(platform.createGroup).not.toHaveBeenCalled();
+    expect(platform.updateChatInfo).not.toHaveBeenCalled();
+    const userText = prompt.mock.calls[0][1];
+    expect(userText).toContain(`[User message]\n帮我看一下日志\n\n---\n${ABD_APPEND_PROMPT}\n[/User message]`);
+    expect(userText).not.toContain("/abd");
+  });
+
+  it("keeps the Feishu p2p binding when handling commands", async () => {
+    const platform = mockPlatform("feishu");
+    await recordSessionRegistry({
+      chatId: "feishu-p2p",
+      sessionId: "sid-feishu-private",
+      tool: "claude",
+      chatType: "p2p",
+      chatName: "飞书私聊",
+      running: false,
+    });
+
+    await handleCommand(platform, "/model", "feishu-p2p", "ou-user", Date.now(), "p2p");
+
+    expect(platform.createGroup).not.toHaveBeenCalled();
+    expect(platform.sendRawCard).toHaveBeenCalled();
+    const registry = await loadSessionRegistryForBinding();
+    expect(registry["feishu-p2p"]?.sessionId).toBe("sid-feishu-private");
+  });
+
+  it("keeps the Feishu p2p session bound when /new creates a separate group", async () => {
+    const platform = mockPlatform("feishu");
+    const createSession = vi.fn(async () => ({ sessionId: "sid-feishu-group" }));
+    _setAdapterForToolForTest("claude", {
+      ...mockAdapter("sid-feishu-group"),
+      createSession,
+    });
+    await recordSessionRegistry({
+      chatId: "feishu-p2p",
+      sessionId: "sid-feishu-private",
+      tool: "claude",
+      chatType: "p2p",
+      chatName: "飞书私聊",
+      running: false,
+    });
+
+    await handleCommand(platform, "/new", "feishu-p2p", "ou-user", Date.now(), "p2p");
+
+    expect(platform.createGroup).toHaveBeenCalledWith(expect.any(String), ["ou-user"]);
+    const registry = await loadSessionRegistryForBinding();
+    expect(registry["feishu-p2p"]?.sessionId).toBe("sid-feishu-private");
+    expect(registry["feishu-group"]?.sessionId).toBe("sid-feishu-group");
+  });
+
+  it("resets a Feishu p2p session in place with /newh and forces the OS user directory", async () => {
+    const platform = mockPlatform("feishu");
+    const createSession = vi.fn(async () => ({ sessionId: "sid-feishu-private-reset" }));
+    _setAdapterForToolForTest("claude", {
+      ...mockAdapter("sid-feishu-private-reset"),
+      createSession,
+      getSessionInfo: async (sessionId: string): Promise<SessionInfo> => ({
+        sessionId,
+        cwd: "F:\\some-project",
+      }),
+    });
+    await recordSessionRegistry({
+      chatId: "feishu-p2p",
+      sessionId: "sid-feishu-private",
+      tool: "claude",
+      chatType: "p2p",
+      chatName: "飞书私聊",
+      running: false,
+    });
+
+    await handleCommand(platform, "/newh", "feishu-p2p", "ou-user", Date.now(), "p2p");
+
+    expect(createSession).toHaveBeenCalledWith(homedir());
+    expect(platform.createGroup).not.toHaveBeenCalled();
+    expect(platform.updateChatInfo).not.toHaveBeenCalled();
+    const registry = await loadSessionRegistryForBinding();
+    expect(registry["feishu-p2p"]?.sessionId).toBe("sid-feishu-private-reset");
+    expect(platform.sendCard).toHaveBeenCalledWith(
+      "feishu-p2p",
+      "Claude Code Session Reset",
+      expect.stringContaining(`${homedir()}\`（飞书私聊固定使用系统用户目录）`),
+      "green",
+    );
+  });
+
+  it("does not allow /session to replace the dedicated Feishu p2p session", async () => {
+    const platform = mockPlatform("feishu");
+    await recordSessionRegistry({
+      chatId: "feishu-p2p",
+      sessionId: "sid-feishu-private",
+      tool: "claude",
+      chatType: "p2p",
+      chatName: "飞书私聊",
+      running: false,
+    });
+
+    await handleCommand(platform, "/session 1", "feishu-p2p", "ou-user", Date.now(), "p2p");
+
+    expect(platform.sendCard).toHaveBeenCalledWith(
+      "feishu-p2p",
+      "/session",
+      expect.stringContaining("飞书私聊使用固定的专属会话"),
+      "yellow",
+    );
+    expect(platform.updateChatInfo).not.toHaveBeenCalled();
+    const registry = await loadSessionRegistryForBinding();
+    expect(registry["feishu-p2p"]?.sessionId).toBe("sid-feishu-private");
+  });
+
+  it("shows Claude effort switch card in an active Feishu session", async () => {
+    const platform = mockPlatform("feishu");
+    vi.mocked(platform.getChatInfo).mockResolvedValue({ name: "claude-session", description: "Claude Session: sid-claude-effort" });
+    vi.mocked(platform.extractSessionInfo).mockReturnValue({ sessionId: "sid-claude-effort", tool: "claude" });
+    await recordSessionRegistry({
+      chatId: "feishu-chat",
+      sessionId: "sid-claude-effort",
+      tool: "claude",
+      chatName: "claude-session",
+      running: false,
+    });
+    sessionInfoMap.set("feishu-chat", {
+      sessionId: "sid-claude-effort",
+      tool: "claude",
+      turnCount: 0,
+      lastContextTokens: 0,
+      startTime: Date.now(),
+    });
+
+    await handleCommand(platform, "/effort", "feishu-chat", "ou-user", Date.now(), "group");
+
+    expect(platform.sendRawCard).toHaveBeenCalled();
+    const card = JSON.parse(vi.mocked(platform.sendRawCard).mock.calls[0][1]);
+    const raw = JSON.stringify(card);
+    expect(raw).toContain("/effort low");
+    expect(raw).toContain("/effort xhigh");
+    expect(raw).toContain("/effort max");
+  });
+
+  it("switches Codex effort for the current session and reflects it in /state", async () => {
+    const platform = mockPlatform("feishu");
+    vi.mocked(platform.getChatInfo).mockResolvedValue({ name: "codex-session", description: "Codex Session: sid-codex-effort" });
+    vi.mocked(platform.extractSessionInfo).mockReturnValue({ sessionId: "sid-codex-effort", tool: "codex" });
+    _setAdapterForToolForTest("codex", mockAdapter("sid-codex-effort"));
+    await recordSessionRegistry({
+      chatId: "codex-chat",
+      sessionId: "sid-codex-effort",
+      tool: "codex",
+      chatName: "codex-session",
+      running: false,
+    });
+    sessionInfoMap.set("codex-chat", {
+      sessionId: "sid-codex-effort",
+      tool: "codex",
+      turnCount: 0,
+      lastContextTokens: 0,
+      startTime: Date.now(),
+    });
+
+    await handleCommand(platform, "/effort xhigh", "codex-chat", "ou-user", Date.now(), "group");
+    expect(platform.sendCard).toHaveBeenCalledWith(
+      "codex-chat",
+      "Effort 切换",
+      expect.stringContaining("xhigh"),
+      "green",
+    );
+
+    vi.mocked(platform.sendCard).mockClear();
+    vi.mocked(platform.sendRawCard).mockClear();
+    await handleCommand(platform, "/state", "codex-chat", "ou-user", Date.now() + 1, "group");
+
+    expect(platform.sendRawCard).toHaveBeenCalled();
+    const card = JSON.parse(vi.mocked(platform.sendRawCard).mock.calls[0][1]);
+    expect(JSON.stringify(card)).toContain("xhigh");
+  });
+
+  it("rejects /effort in Cursor sessions", async () => {
+    const platform = mockPlatform("feishu");
+    vi.mocked(platform.getChatInfo).mockResolvedValue({ name: "cursor-session", description: "Cursor Session: sid-cursor-effort" });
+    vi.mocked(platform.extractSessionInfo).mockReturnValue({ sessionId: "sid-cursor-effort", tool: "cursor" });
+    _setAdapterForToolForTest("cursor", mockAdapter("sid-cursor-effort"));
+    await recordSessionRegistry({
+      chatId: "cursor-chat",
+      sessionId: "sid-cursor-effort",
+      tool: "cursor",
+      chatName: "cursor-session",
+      running: false,
+    });
+    sessionInfoMap.set("cursor-chat", {
+      sessionId: "sid-cursor-effort",
+      tool: "cursor",
+      turnCount: 0,
+      lastContextTokens: 0,
+      startTime: Date.now(),
+    });
+
+    await handleCommand(platform, "/effort high", "cursor-chat", "ou-user", Date.now(), "group");
+
+    expect(platform.sendCard).toHaveBeenCalledWith(
+      "cursor-chat",
+      "Effort 切换",
+      expect.stringContaining("不支持 effort"),
+      "red",
+    );
+  });
+
+  it("handles /usage without creating a new Feishu group", async () => {
+    const platform = mockPlatform("feishu");
     const usage = {
       fiveHour: { usedPercent: 37, remainingPercent: 63, resetAtEpochSeconds: 1781528212, resetAfterSeconds: 10349 },
       weekly: { usedPercent: 12, remainingPercent: 88, resetAtEpochSeconds: 1781842926, resetAfterSeconds: 325063 },
@@ -519,38 +682,38 @@ describe("handleCommand WeChat processing ack", () => {
     expect(card.elements[0].text.content).toContain("**5h:** 已用 37%，剩余 63%，重置:");
     expect(card.elements[0].text.content).toContain("约 2小时52分钟后");
     expect(card.elements[0].text.content).toContain("[███████░░░░░░░░░░░░░]");
-    expect(card.elements[0].text.content).toContain("**7天:** 已用 12%，剩余 88%，重置:");
+    expect(card.elements[0].text.content).toContain("**7天:** 已用 12%，剩余 88%，重置:");
     expect(card.elements[0].text.content).toContain("约 3天18小时17分钟后");
     expect(card.elements[0].text.content).toContain("[██░░░░░░░░░░░░░░░░░░]");
     expect(card.elements[2].actions[0].text.content).toBe("发起重置");
     expect(card.elements[2].actions[0].value).toEqual({ action: "codex_reset_request", availableCount: 2 });
-    expect(platform.setChatAvatar).toHaveBeenCalledWith("feishu-p2p", "codex", "idle", { codexUsage: usage });
-  });
-
-  it("shows only the 7-day window when the 5h window is absent", async () => {
-    const platform = mockPlatform("feishu");
-    const usage = {
-      fiveHour: null,
-      weekly: {
-        usedPercent: 23,
-        remainingPercent: 77,
-        resetAtEpochSeconds: 1784510226,
-        resetAfterSeconds: 500000,
-        limitWindowSeconds: 604800,
-      },
-      rateLimitResetCreditsAvailable: 0,
-      rateLimitResetCredits: [],
-    };
-    mockGetCodexUsageSummary.mockResolvedValue(usage);
-
-    await handleCommand(platform, "/usage", "feishu-p2p", "ou-user", Date.now(), "p2p");
-
-    const card = JSON.parse(vi.mocked(platform.sendRawCard).mock.calls[0][1]);
-    const content = card.elements[0].text.content as string;
-    expect(content).not.toContain("**5h:**");
-    expect(content).toContain("**7天:** 已用 23%，剩余 77%，重置:");
-    expect(platform.setChatAvatar).toHaveBeenCalledWith("feishu-p2p", "codex", "idle", { codexUsage: usage });
-  });
+    expect(platform.setChatAvatar).toHaveBeenCalledWith("feishu-p2p", "codex", "idle", { codexUsage: usage });
+  });
+
+  it("shows only the 7-day window when the 5h window is absent", async () => {
+    const platform = mockPlatform("feishu");
+    const usage = {
+      fiveHour: null,
+      weekly: {
+        usedPercent: 23,
+        remainingPercent: 77,
+        resetAtEpochSeconds: 1784510226,
+        resetAfterSeconds: 500000,
+        limitWindowSeconds: 604800,
+      },
+      rateLimitResetCreditsAvailable: 0,
+      rateLimitResetCredits: [],
+    };
+    mockGetCodexUsageSummary.mockResolvedValue(usage);
+
+    await handleCommand(platform, "/usage", "feishu-p2p", "ou-user", Date.now(), "p2p");
+
+    const card = JSON.parse(vi.mocked(platform.sendRawCard).mock.calls[0][1]);
+    const content = card.elements[0].text.content as string;
+    expect(content).not.toContain("**5h:**");
+    expect(content).toContain("**7天:** 已用 23%，剩余 77%，重置:");
+    expect(platform.setChatAvatar).toHaveBeenCalledWith("feishu-p2p", "codex", "idle", { codexUsage: usage });
+  });
 
   it("adds ChatGPT subscription expiry to Codex /usage when CDP lookup succeeds", async () => {
     const platform = mockPlatform("feishu");
@@ -662,16 +825,16 @@ 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");
 
     expect(codexPlatform.sendCard).toHaveBeenCalledWith(
       "feishu-group",
       "Codex Session Ready",
-      expect.stringContaining("发送 **/usage** 查看 Codex 实际存在的 5h/7天用量窗口，以及查询/使用主动重置卡。"),
+      expect.stringContaining("发送 **/usage** 查看 Codex 实际存在的 5h/7天用量窗口，以及查询/使用主动重置卡。"),
       "green",
     );
 
@@ -688,50 +851,50 @@ 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");
-  });
-
-  it("reloads runtime config for the exact /reload command", async () => {
-    const platform = mockPlatform("feishu");
-
-    await handleCommand(platform, "/reload", "feishu-chat", "open-1", Date.now(), "group");
-
-    expect(mockReloadRuntimeConfig).toHaveBeenCalledWith("chat-command");
-    expect(platform.sendText).toHaveBeenCalledWith(
-      "feishu-chat",
-      expect.stringContaining("配置已重新加载"),
-    );
-    expect(platform.sendText).toHaveBeenCalledWith(
-      "feishu-chat",
-      expect.stringContaining("默认 Agent: Codex"),
-    );
-  });
-
-  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");
-  });
-});
+    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("reloads runtime config for the exact /reload command", async () => {
+    const platform = mockPlatform("feishu");
+
+    await handleCommand(platform, "/reload", "feishu-chat", "open-1", Date.now(), "group");
+
+    expect(mockReloadRuntimeConfig).toHaveBeenCalledWith("chat-command");
+    expect(platform.sendText).toHaveBeenCalledWith(
+      "feishu-chat",
+      expect.stringContaining("配置已重新加载"),
+    );
+    expect(platform.sendText).toHaveBeenCalledWith(
+      "feishu-chat",
+      expect.stringContaining("默认 Agent: Codex"),
+    );
+  });
+
+  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");
+  });
+});