chatccc 0.2.214 → 0.2.216

package/README.md

@@ -295,10 +295,11 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
   },
   "codex": {
     "enabled": false,
-    "defaultAgent": false,
-    "path": "",
-    "model": "",
-    "effort": ""
+    "defaultAgent": false,
+    "path": "",
+    "model": "",
+    "effort": "",
+    "fastMode": false
   }
 }
 ```
@@ -319,7 +320,8 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
 | `allowInterrupt` | 是否允许新消息中断正在运行的任务；默认 false |
 | `*.enabled` | 是否启用对应 AI Agent |
 | `*.defaultAgent` | `/new` 未指定 Agent 时使用哪个工具；飞书私聊会在下一条普通消息到达时跟随变化并创建新的空会话 |
-| `cursor.path` / `codex.path` | CLI 可执行文件路径；留空时自动探测或使用 PATH |
+| `cursor.path` / `codex.path` | CLI 可执行文件路径；留空时自动探测或使用 PATH |
+| `codex.fastMode` | Codex Fast 模式的全局默认值；默认 `false`，每次调用都会显式覆盖 Codex CLI 的 service tier |
 | `cursor.avatarBatteryMode` | Cursor 头像电量显示来源：`apiPercent` 或 `onDemandUse` |
 | `cursor.onDemandMonthlyBudget` | `avatarBatteryMode=onDemandUse` 时用于计算电量的月预算 |
 | `claude.model` / `claude.subagentModel` / `claude.effort` | 选填；设置后传给 Claude Agent SDK，留空以 `~/.claude/settings.json` 为准 |
@@ -345,8 +347,9 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
 | `/new cursor` | 创建 Cursor 会话；飞书中会创建新群 |
 | `/new codex` | 创建 Codex 会话；飞书中会创建新群 |
 | `/newh` | 在当前聊天原地重置会话；群聊保留工作目录，飞书私聊固定使用系统用户目录 |
-| `/model` | 查看或切换当前会话的模型 |
-| `/stop` | 停止当前回复 |
+| `/model` | 查看或切换当前会话的模型 |
+| `/fast` | 查看当前 Codex 会话的 Fast 模式；使用 `/fast on` 或 `/fast off` 切换 |
+| `/stop` | 停止当前回复 |
 | `/cancel` | 取消当前会话里排队等待处理的消息 |
 | `/state` | 查看当前会话状态 |
 | `/cd` | 查看或设置后续新建会话的默认工作目录，不改变当前会话；飞书私聊自身始终使用系统用户目录 |
@@ -364,6 +367,8 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
 `/update` 会在执行 npm 更新前把飞书消息或按钮事件 ID 原子写入 `~/.chatccc/state/update-command-guard.json`。同一 ID 跨重启重投时会静默忽略；用户主动发送的新 `/update` 因事件 ID 不同，仍可立即执行。该保护仅作用于 `/update`，普通消息与 `/restart` 的处理不变。
 
 > **模型切换**：`/model` 查看当前会话 Agent 的可选模型清单，`/model <名称>` 模糊匹配切换，`/model clear` 恢复默认。可选模型来自当前 Agent 的配置：Claude 使用 `claude.model` / `claude.subagentModel`，Cursor 使用 `cursor.model`，Codex 使用 `codex.model`。
+
+> **Codex Fast 模式**：Web UI 中的“Fast 模式”设置新 Codex 会话的全局默认值，默认关闭。进入 Codex 会话后，`/fast` 查询当前状态，`/fast on` 和 `/fast off` 只覆盖当前会话并从下一条消息生效。ChatCCC 会显式向 Codex CLI 传入 `service_tier="fast"` 或 `service_tier="default"`，因此关闭时不会继承用户 `config.toml` 中可能开启的 Fast。
 
 ---
 

package/config.sample.json

@@ -69,7 +69,8 @@
     "path": "",
     "model": "",
     "alternativeModel": "",
-    "effort": ""
+    "effort": "",
+    "fastMode": false
   },
   "ccc": {
     "DEEPSEEK_API_KEY": "",

package/package.json

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

package/src/__tests__/cards.test.ts

@@ -8,6 +8,8 @@ import {
   buildStatusCard,
   buildCodexUsageCard,
   buildCodexResetConfirmCard,
+  buildFastModeCard,
+  buildModelCard,
   buildButtons,
   truncateContent,
   getToolEmoji,
@@ -18,7 +20,7 @@ import { ABD_HELP_LINE } from "../shared-prefix.ts";
 // truncateContent
 // ---------------------------------------------------------------------------
 
-describe("truncateContent", () => {
+describe("truncateContent", () => {
   it("returns original text when under limits", () => {
     expect(truncateContent("hello")).toBe("hello");
   });
@@ -180,6 +182,40 @@ describe("buildHelpCard", () => {
     expect(text).not.toContain("CCC Agent");
   });
 });
+
+describe("Codex Fast mode cards", () => {
+  it("shows the current mode and exposes ON/OFF commands", () => {
+    const card = JSON.parse(buildFastModeCard(false)) as {
+      header: { title: { content: string } };
+      elements: Array<{
+        tag: string;
+        text?: { content: string };
+        actions?: Array<{ text: { content: string }; value: string }>;
+      }>;
+    };
+
+    expect(card.header.title.content).toBe("Codex Fast 模式");
+    expect(card.elements.find((element) => element.tag === "div")?.text?.content).toContain("OFF");
+    const actions = card.elements.find((element) => element.tag === "action")?.actions ?? [];
+    expect(actions.map((action) => JSON.parse(action.value).cmd)).toEqual([
+      "/fast on",
+      "/fast off",
+    ]);
+  });
+
+  it("places /fast help immediately after /model help for Codex", () => {
+    const card = JSON.parse(buildModelCard("gpt-5", ["gpt-5"], "codex")) as {
+      elements: Array<{ tag: string; text?: { content: string } }>;
+    };
+    const content = card.elements.find((element) => element.tag === "div")?.text?.content ?? "";
+    const modelHelpIndex = content.indexOf("/model");
+    const fastHelpIndex = content.indexOf("/fast");
+
+    expect(modelHelpIndex).toBeGreaterThanOrEqual(0);
+    expect(fastHelpIndex).toBeGreaterThan(modelHelpIndex);
+    expect(content.slice(modelHelpIndex, fastHelpIndex).split("\n")).toHaveLength(2);
+  });
+});
 
 // ---------------------------------------------------------------------------
 // buildCdContent

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

@@ -2,8 +2,9 @@ import { describe, it, expect } from "vitest";
 import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
-import {
-  normalizeCodexMessage,
+import {
+  buildCodexInvocationArgs,
+  normalizeCodexMessage,
   createCodexAdapter,
   type CreateCodexAdapterOptions,
 } from "../adapters/codex-adapter.ts";
@@ -14,7 +15,21 @@ import {
 } from "../adapters/codex-session-meta-store.ts";
 import { accumulateBlockContent, pickFinalReply, type AccumulatorState } from "../session.ts";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+describe("buildCodexInvocationArgs", () => {
+  it("forces the priority service tier when Fast mode is on", () => {
+    expect(buildCodexInvocationArgs(["exec", "--json"], "", "", true)).toContain(
+      'service_tier="fast"',
+    );
+  });
+
+  it("forces the standard service tier when Fast mode is off", () => {
+    const args = buildCodexInvocationArgs(["exec", "--json"], "", "", false);
+    expect(args).toContain('service_tier="default"');
+    expect(args).not.toContain('service_tier="fast"');
+  });
+});
 
 function readFixture(name: string): unknown[] {
   const raw = readFileSync(join(__dirname, "fixtures", name), "utf-8");

package/src/__tests__/config-reload.test.ts

@@ -71,7 +71,7 @@ const baseAppConfig: AppConfig = {
     avatarBatteryMode: "apiPercent",
     onDemandMonthlyBudget: 1000,
   },
-  codex: { enabled: true, defaultAgent: false, path: "/initial/codex", model: "initial-codex-model", alternativeModel: "initial-codex-alt-model", effort: "initial-codex-effort" },
+  codex: { enabled: true, defaultAgent: false, path: "/initial/codex", model: "initial-codex-model", alternativeModel: "initial-codex-alt-model", effort: "initial-codex-effort", fastMode: false },
   ccc: { DEEPSEEK_API_KEY: "initial-ccc-key", DEEPSEEK_BASE_URL: "https://initial.deepseek.test/v1", model: "initial-ccc-model" },
 };
 
@@ -207,15 +207,16 @@ describe("applyLoadedConfig — config 对象引用契约", () => {
     applyLoadedConfig({
       ...structuredClone(baseAppConfig),
       feishu: { appId: "REF_TEST_APP", appSecret: "REF_TEST_SECRET" },
-      codex: { enabled: true, defaultAgent: false, path: "/refresh/codex", model: "fresh-model", alternativeModel: "", effort: "low" },
+      codex: { enabled: true, defaultAgent: false, path: "/refresh/codex", model: "fresh-model", alternativeModel: "", effort: "low", fastMode: true },
     });
 
     // 必须是同一个引用：codex-adapter 等下游模块"直接 import config"，
     // 替换引用会破坏它们对 config.codex.* 的访问。
     expect(config).toBe(refBefore);
-    expect(config.feishu.appId).toBe("REF_TEST_APP");
-    expect(config.codex.path).toBe("/refresh/codex");
-  });
+    expect(config.feishu.appId).toBe("REF_TEST_APP");
+    expect(config.codex.path).toBe("/refresh/codex");
+    expect(config.codex.fastMode).toBe(true);
+  });
 
   it("刷新 chromeDevtools 配置但保持 config 引用", () => {
     const refBefore = config;

package/src/__tests__/config-sample.test.ts

@@ -28,15 +28,16 @@ describe("config.sample.json", () => {
     expect(sample.claude?.subagentModel).toBe("");
   });
 
-  it("leaves Cursor and Codex alternative models empty by default", () => {
-    const configSamplePath = join(process.cwd(), "config.sample.json");
-    const sample = JSON.parse(readFileSync(configSamplePath, "utf8")) as {
-      cursor?: { alternativeModel?: unknown };
-      codex?: { alternativeModel?: unknown };
-    };
-
+  it("leaves alternative models empty and Codex Fast mode off by default", () => {
+    const configSamplePath = join(process.cwd(), "config.sample.json");
+    const sample = JSON.parse(readFileSync(configSamplePath, "utf8")) as {
+      cursor?: { alternativeModel?: unknown };
+      codex?: { alternativeModel?: unknown; fastMode?: unknown };
+    };
+
     expect(sample.cursor?.alternativeModel).toBe("");
     expect(sample.codex?.alternativeModel).toBe("");
+    expect(sample.codex?.fastMode).toBe(false);
   });
 
   it("sets ccc agent DeepSeek defaults in the sample config", () => {

package/src/__tests__/feishu-message-ingress.test.ts

@@ -0,0 +1,138 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import {
+  FeishuMessageLedger,
+  createAckFirstEventHandler,
+} from "../feishu-message-ingress.ts";
+
+const tempDirs: string[] = [];
+
+async function createLedger(maxEntries = 5): Promise<FeishuMessageLedger> {
+  const dir = await mkdtemp(join(tmpdir(), "chatccc-feishu-ingress-"));
+  tempDirs.push(dir);
+  return new FeishuMessageLedger(join(dir, "messages.json"), maxEntries);
+}
+
+afterEach(async () => {
+  await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
+});
+
+describe("createAckFirstEventHandler", () => {
+  it("returns before starting the asynchronous event worker", async () => {
+    let scheduled: (() => void) | undefined;
+    const schedule = vi.fn((task: () => void) => {
+      scheduled = task;
+    });
+    const worker = vi.fn(async () => {});
+    const onError = vi.fn();
+    const handler = createAckFirstEventHandler(worker, onError, schedule);
+
+    await expect(handler({ message: "test" })).resolves.toBeUndefined();
+    expect(schedule).toHaveBeenCalledOnce();
+    expect(worker).not.toHaveBeenCalled();
+
+    scheduled?.();
+    await vi.waitFor(() => expect(worker).toHaveBeenCalledWith({ message: "test" }));
+    expect(onError).not.toHaveBeenCalled();
+  });
+
+  it("reports detached worker failures without rejecting the SDK callback", async () => {
+    const error = new Error("worker failed");
+    const onError = vi.fn();
+    const handler = createAckFirstEventHandler(
+      async () => {
+        throw error;
+      },
+      onError,
+      (task) => task(),
+    );
+
+    await expect(handler({})).resolves.toBeUndefined();
+    await vi.waitFor(() => expect(onError).toHaveBeenCalledWith(error));
+  });
+});
+
+describe("FeishuMessageLedger", () => {
+  it("rejects an already accepted message after a process restart", async () => {
+    const first = await createLedger();
+    await first.load();
+
+    expect(await first.accept({
+      messageId: "om_001",
+      chatId: "oc_chat",
+      createTime: 100,
+    })).toBe("accepted");
+
+    const restarted = new FeishuMessageLedger(first.filePath, 5);
+    await restarted.load();
+
+    expect(await restarted.accept({
+      messageId: "om_001",
+      chatId: "oc_chat",
+      createTime: 100,
+    })).toBe("duplicate");
+  });
+
+  it("rejects a unique old event after restoring the chat high-water mark", async () => {
+    const first = await createLedger();
+    await first.load();
+
+    expect(await first.accept({
+      messageId: "om_new",
+      chatId: "oc_chat",
+      createTime: 200,
+    })).toBe("accepted");
+
+    const restarted = new FeishuMessageLedger(first.filePath, 5);
+    await restarted.load();
+
+    expect(await restarted.accept({
+      messageId: "om_old",
+      chatId: "oc_chat",
+      createTime: 100,
+    })).toBe("stale");
+  });
+
+  it("accepts distinct messages with the same create timestamp", async () => {
+    const ledger = await createLedger();
+    await ledger.load();
+
+    expect(await ledger.accept({
+      messageId: "om_001",
+      chatId: "oc_chat",
+      createTime: 100,
+    })).toBe("accepted");
+    expect(await ledger.accept({
+      messageId: "om_002",
+      chatId: "oc_chat",
+      createTime: 100,
+    })).toBe("accepted");
+  });
+
+  it("keeps only the configured number of recent message IDs", async () => {
+    const ledger = await createLedger(2);
+    await ledger.load();
+
+    await ledger.accept({ messageId: "om_001", chatId: "oc_chat", createTime: 100 });
+    await ledger.accept({ messageId: "om_002", chatId: "oc_chat", createTime: 200 });
+    await ledger.accept({ messageId: "om_003", chatId: "oc_chat", createTime: 300 });
+
+    const restarted = new FeishuMessageLedger(ledger.filePath, 2);
+    await restarted.load();
+
+    expect(await restarted.accept({
+      messageId: "om_001",
+      chatId: "oc_other",
+      createTime: 100,
+    })).toBe("accepted");
+    expect(await restarted.accept({
+      messageId: "om_003",
+      chatId: "oc_chat",
+      createTime: 300,
+    })).toBe("duplicate");
+  });
+});

package/src/__tests__/orchestrator.test.ts

@@ -86,6 +86,7 @@ import {
   recordSessionRegistry,
   resetState,
   sessionInfoMap,
+  getEffectiveFastModeForTool,
 } from "../session.ts";
 import {
   activePrompts,
@@ -146,6 +147,7 @@ describe("handleCommand WeChat processing ack", () => {
     config.claude.defaultAgent = true;
     config.cursor.defaultAgent = false;
     config.codex.defaultAgent = false;
+    config.codex.fastMode = false;
     mockStreamStates.clear();
     mockGetCodexUsageSummary.mockReset();
     mockGetCursorUsageSummary.mockReset();
@@ -660,6 +662,55 @@ describe("handleCommand WeChat processing ack", () => {
     expect(registry["feishu-p2p"]?.sessionId).toBe("sid-feishu-private");
   });
 
+  it("queries and switches Fast mode for the current Codex session", async () => {
+    const platform = mockPlatform("feishu");
+    await recordSessionRegistry({
+      chatId: "feishu-codex",
+      sessionId: "sid-codex-fast",
+      tool: "codex",
+      chatType: "p2p",
+      chatName: "Codex",
+      running: false,
+    });
+
+    await handleCommand(platform, "/fast", "feishu-codex", "ou-user", Date.now(), "p2p");
+    let card = JSON.parse(
+      vi.mocked(platform.sendRawCard).mock.calls.at(-1)?.[1] ?? "{}",
+    ) as { elements?: Array<{ tag: string; text?: { content: string } }> };
+    expect(card.elements?.find((element) => element.tag === "div")?.text?.content).toContain("OFF");
+
+    await handleCommand(platform, "/fast on", "feishu-codex", "ou-user", Date.now(), "p2p");
+    expect(getEffectiveFastModeForTool("codex", "sid-codex-fast")).toBe(true);
+
+    await handleCommand(platform, "/fast off", "feishu-codex", "ou-user", Date.now(), "p2p");
+    expect(getEffectiveFastModeForTool("codex", "sid-codex-fast")).toBe(false);
+    card = JSON.parse(
+      vi.mocked(platform.sendRawCard).mock.calls.at(-1)?.[1] ?? "{}",
+    ) as { elements?: Array<{ tag: string; text?: { content: string } }> };
+    expect(card.elements?.find((element) => element.tag === "div")?.text?.content).toContain("OFF");
+  });
+
+  it("uses a text fallback for Fast mode commands on WeChat", async () => {
+    const platform = mockPlatform("wechat");
+    await recordSessionRegistry({
+      chatId: "wechat-codex",
+      sessionId: "sid-wechat-codex-fast",
+      tool: "codex",
+      chatType: "p2p",
+      chatName: "Codex",
+      running: false,
+    });
+
+    await handleCommand(platform, "/fast on", "wechat-codex", "wx-user", Date.now(), "p2p");
+
+    expect(getEffectiveFastModeForTool("codex", "sid-wechat-codex-fast")).toBe(true);
+    expect(platform.sendText).toHaveBeenCalledWith(
+      "wechat-codex",
+      expect.stringContaining("ON (Fast)"),
+    );
+    expect(platform.sendRawCard).not.toHaveBeenCalled();
+  });
+
   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" }));
@@ -1023,7 +1074,15 @@ describe("handleCommand WeChat processing ack", () => {
       "green",
     );
 
-    const cursorPlatform = mockPlatform("feishu");
+    const codexReadyCall = vi.mocked(codexPlatform.sendCard).mock.calls.find(
+      ([chatId, title]) => chatId === "feishu-group" && title === "Codex Session Ready",
+    );
+    const modelHelpIndex = codexReadyCall?.[2].indexOf("/model") ?? -1;
+    const fastHelpIndex = codexReadyCall?.[2].indexOf("/fast") ?? -1;
+    expect(modelHelpIndex).toBeGreaterThanOrEqual(0);
+    expect(fastHelpIndex).toBeGreaterThan(modelHelpIndex);
+
+    const cursorPlatform = mockPlatform("feishu");
     _setAdapterForToolForTest("cursor", mockAdapter("sid-cursor"));
 
     await handleCommand(cursorPlatform, "/new cursor", "feishu-p2p-cursor", "ou-user", Date.now(), "p2p");

package/src/__tests__/session.test.ts

@@ -126,9 +126,12 @@ import {
   _setFinalResponseCloseTimeoutForTest,
   _resetFinalResponseCloseTimeoutForTest,
   setSessionEffortOverride,
+  getEffectiveFastModeForTool,
+  setSessionFastModeOverride,
   RESPONSE_STALL_RECOVERY_PROMPT,
   RESPONSE_STALL_RECOVERY_EXHAUSTED_NOTICE,
 } from "../session.ts";
+import { config } from "../config.ts";
 import {
   activePrompts,
   bindChatToSession,
@@ -145,7 +148,26 @@ import {
 } from "../session-chat-binding.ts";
 import type { AccumulatorState } from "../session.ts";
 import type { ToolAdapter, ToolPromptOptions, UnifiedBlock, SessionInfo } from "../adapters/adapter-interface.ts";
-import type { PlatformAdapter } from "../platform-adapter.ts";
+import type { PlatformAdapter } from "../platform-adapter.ts";
+
+describe("Codex Fast mode overrides", () => {
+  it("uses the global default until the current session overrides it", () => {
+    const previousFastMode = config.codex.fastMode;
+    config.codex.fastMode = false;
+    resetState();
+
+    expect(getEffectiveFastModeForTool("codex", "sid-fast")).toBe(false);
+    setSessionFastModeOverride("sid-fast", true);
+    expect(getEffectiveFastModeForTool("codex", "sid-fast")).toBe(true);
+    setSessionFastModeOverride("sid-fast", false);
+    expect(getEffectiveFastModeForTool("codex", "sid-fast")).toBe(false);
+    expect(getEffectiveFastModeForTool("claude", "sid-fast")).toBe(false);
+
+    resetState();
+    expect(getEffectiveFastModeForTool("codex", "sid-fast")).toBe(false);
+    config.codex.fastMode = previousFastMode;
+  });
+});
 
 // Helper to create a mock active session entry
 function mockActiveSession(chatId: string, overrides: Partial<{

package/src/__tests__/sim-platform.test.ts

@@ -73,9 +73,10 @@ describe("SimulatedPlatform", () => {
   });
 
   it("纯函数 formatDelayNotice 正常工作", () => {
-    const notice = SimulatedPlatform.formatDelayNotice(Date.now() - 20 * 60 * 1000, "测试消息");
-    expect(notice).toBeDefined();
-    expect(notice).toContain("延迟送达");
+    const notice = SimulatedPlatform.formatDelayNotice(Date.now() - 20 * 60 * 1000, "测试消息");
+    expect(notice).toBeDefined();
+    expect(notice).toContain("延迟送达");
+    expect(notice).not.toContain("因服务离线");
     // 近期消息不触发
     expect(SimulatedPlatform.formatDelayNotice(Date.now(), "test")).toBeNull();
   });

package/src/__tests__/web-ui.test.ts

@@ -68,11 +68,12 @@ describe("unflattenConfig", () => {
     });
   });
 
-  it("maps Cursor and Codex alternative models into agent config", () => {
+  it("maps Cursor and Codex runtime settings into agent config", () => {
     expect(
       unflattenConfig({
         CHATCCC_CURSOR_ALTERNATIVE_MODEL: "gpt-5.5-high",
         CHATCCC_CODEX_ALTERNATIVE_MODEL: "gpt-5.3-codex",
+        CHATCCC_CODEX_FAST_MODE: true,
       }),
     ).toEqual({
       cursor: {
@@ -80,6 +81,7 @@ describe("unflattenConfig", () => {
       },
       codex: {
         alternativeModel: "gpt-5.3-codex",
+        fastMode: true,
       },
     });
   });
@@ -149,6 +151,7 @@ describe("getRestartRequiredReasons", () => {
       model: "",
       alternativeModel: "",
       effort: "",
+      fastMode: false,
     },
   };
 
@@ -159,7 +162,13 @@ describe("getRestartRequiredReasons", () => {
         chromeDevtools: { enabled: true, port: 15167, chromePath: "C:/Chrome/chrome.exe" },
         claude: { ...baseConfig.claude, model: "claude-sonnet", apiKey: "sk-test", maxTurn: 8 },
         cursor: { ...baseConfig.cursor, path: "C:/cursor-agent.cmd", model: "cursor-model" },
-        codex: { ...baseConfig.codex, path: "C:/codex.cmd", model: "gpt-5.3-codex", effort: "high" },
+        codex: {
+          ...baseConfig.codex,
+          path: "C:/codex.cmd",
+          model: "gpt-5.3-codex",
+          effort: "high",
+          fastMode: true,
+        },
       }),
     ).toEqual([]);
   });
@@ -211,6 +220,12 @@ describe("dashboard edit modal", () => {
     expect(PAGE_HTML).toContain("生效范围：飞书开关、App ID、App Secret 或平台类型变更需要重启 ChatCCC");
   });
 
+  it("shows the Codex Fast mode switch in both the wizard and dashboard", () => {
+    expect(PAGE_HTML).toContain('id="field-CHATCCC_CODEX_FAST_MODE"');
+    expect(PAGE_HTML).toContain('id="cfg-CODEX_FAST_MODE"');
+    expect(PAGE_HTML).toContain("Fast 模式");
+  });
+
   it("shows the Web UI startup switch in both the wizard and dashboard", () => {
     expect(PAGE_HTML).toContain('id="field-CHATCCC_WEB_UI_OPEN_ON_START"');
     expect(PAGE_HTML).toContain('id="cfg-WEB_UI_OPEN_ON_START"');

package/src/adapters/codex-adapter.ts

@@ -199,13 +199,12 @@ export function normalizeCodexMessage(
 // 子进程辅助函数
 // ---------------------------------------------------------------------------
 
-function spawnCodex(
+export function buildCodexInvocationArgs(
   args: string[],
-  cwd?: string,
-  stdinText?: string,
   modelOverride?: string,
   effortOverride?: string,
-): ChildProcess {
+  fastModeOverride?: boolean,
+): string[] {
   const allArgs = [...args];
   const model = modelOverride ?? resolveCodexModel();
   if (model) {
@@ -217,6 +216,25 @@ function spawnCodex(
   if (effort) {
     allArgs.push("-c", `model_reasoning_effort="${effort}"`);
   }
+  const fastMode = fastModeOverride ?? config.codex.fastMode;
+  allArgs.push("-c", `service_tier="${fastMode ? "fast" : "default"}"`);
+  return allArgs;
+}
+
+function spawnCodex(
+  args: string[],
+  cwd?: string,
+  stdinText?: string,
+  modelOverride?: string,
+  effortOverride?: string,
+  fastModeOverride?: boolean,
+): ChildProcess {
+  const allArgs = buildCodexInvocationArgs(
+    args,
+    modelOverride,
+    effortOverride,
+    fastModeOverride,
+  );
 
   const proc = spawn(detectCodexCommand(), allArgs, {
     cwd,
@@ -269,11 +287,18 @@ class CodexAdapter implements ToolAdapter {
   private metaStore: CodexSessionMetaStore;
   private modelOverride: string | undefined;
   private effortOverride: string | undefined;
+  private fastModeOverride: boolean | undefined;
 
-  constructor(metaStore: CodexSessionMetaStore, modelOverride?: string, effortOverride?: string) {
+  constructor(
+    metaStore: CodexSessionMetaStore,
+    modelOverride?: string,
+    effortOverride?: string,
+    fastModeOverride?: boolean,
+  ) {
     this.metaStore = metaStore;
     this.modelOverride = modelOverride;
     this.effortOverride = effortOverride;
+    this.fastModeOverride = fastModeOverride;
   }
 
   // createSession: 生成 sessionId，记录 cwd，不创建 Codex 线程（延迟到首次 prompt）
@@ -304,7 +329,14 @@ class CodexAdapter implements ToolAdapter {
       ? [...baseArgs, "-C", cwd, "-"]
       : [...baseArgs, "resume", threadId, "-"];
 
-    const proc = spawnCodex(args, cwd, buildCodexPromptText(userText), this.modelOverride, this.effortOverride);
+    const proc = spawnCodex(
+      args,
+      cwd,
+      buildCodexPromptText(userText),
+      this.modelOverride,
+      this.effortOverride,
+      this.fastModeOverride,
+    );
     if (proc.pid !== undefined) options?.onProcessStart?.({ pid: proc.pid });
 
     const rawLogConfig = config.rawStreamLogs.codex;
@@ -379,6 +411,7 @@ export interface CreateCodexAdapterOptions {
   /** per-session 模型覆盖（/model 命令）；传了就用，不传走全局 codex.model */
   model?: string;
   effort?: string;
+  fastMode?: boolean;
 }
 
 export function createCodexAdapter(
@@ -388,5 +421,6 @@ export function createCodexAdapter(
     options.metaStore ?? defaultCodexSessionMetaStore,
     options.model,
     options.effort,
+    options.fastMode,
   );
 }