chatccc 0.2.180 → 0.2.182

package/package.json

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

package/src/__tests__/cards.test.ts

@@ -5,9 +5,11 @@ import {
   buildCdContent,
   buildCdCard,
   buildSessionsCard,
-  buildStatusCard,
-  buildButtons,
-  truncateContent,
+  buildStatusCard,
+  buildCodexUsageCard,
+  buildCodexResetConfirmCard,
+  buildButtons,
+  truncateContent,
   getToolEmoji,
 } from "../cards.ts";
 import { ABD_HELP_LINE } from "../shared-prefix.ts";
@@ -165,6 +167,7 @@ describe("buildHelpCard", () => {
     const parsed = JSON.parse(card);
     const lines = parsed.elements[1].text.content.split("\n");
 
+    expect(lines).toContain("发送 **/usage** 查看 Codex 5h/周用量，以及查询/使用主动重置卡");
     expect(lines.at(-1)).toBe(ABD_HELP_LINE);
   });
 });
@@ -422,7 +425,7 @@ describe("buildSessionsCard", () => {
 // buildStatusCard
 // ---------------------------------------------------------------------------
 
-describe("buildStatusCard", () => {
+describe("buildStatusCard", () => {
   it("returns valid JSON with status text", () => {
     const card = buildStatusCard("一切正常");
     const parsed = JSON.parse(card);
@@ -442,11 +445,54 @@ describe("buildStatusCard", () => {
     const action = parsed.elements[2];
     expect(action.actions[0].text.content).toBe("收起");
   });
-});
-
-// ---------------------------------------------------------------------------
-// buildButtons
-// ---------------------------------------------------------------------------
+});
+
+// ---------------------------------------------------------------------------
+// buildCodexUsageCard / buildCodexResetConfirmCard
+// ---------------------------------------------------------------------------
+
+describe("Codex usage reset cards", () => {
+  it("shows the reset button only when reset credits are available", () => {
+    const card = buildCodexUsageCard("Codex 用量", 2);
+    const parsed = JSON.parse(card);
+    const action = parsed.elements.find((element: any) => element.tag === "action");
+    expect(action.actions[0].text.content).toBe("发起重置");
+    expect(action.actions[0].value).toEqual({ action: "codex_reset_request", availableCount: 2 });
+
+    const noCreditCard = buildCodexUsageCard("Codex 用量", 0);
+    const noCreditParsed = JSON.parse(noCreditCard);
+    expect(noCreditParsed.elements.some((element: any) => element.tag === "action")).toBe(false);
+  });
+
+  it("builds yes/no confirmation buttons tied to the parent usage card", () => {
+    const card = buildCodexResetConfirmCard({
+      availableCount: 2,
+      parentMessageId: "usage-message",
+      requestId: "request-1",
+    });
+    const parsed = JSON.parse(card);
+    const action = parsed.elements.find((element: any) => element.tag === "action");
+
+    expect(action.actions[0].text.content).toBe("是，发起重置");
+    expect(action.actions[0].value).toEqual({
+      action: "codex_reset_confirm",
+      decision: "yes",
+      parentMessageId: "usage-message",
+      requestId: "request-1",
+    });
+    expect(action.actions[1].text.content).toBe("否");
+    expect(action.actions[1].value).toEqual({
+      action: "codex_reset_confirm",
+      decision: "no",
+      parentMessageId: "usage-message",
+      requestId: "request-1",
+    });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// buildButtons
+// ---------------------------------------------------------------------------
 
 describe("buildButtons", () => {
   it("returns action with buttons", () => {

package/src/__tests__/codex-reset-actions.test.ts

@@ -0,0 +1,146 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import {
+  _resetCodexResetRequestsForTest,
+  handleCodexResetCardAction,
+  type CodexResetActionDeps,
+} from "../codex-reset-actions.ts";
+
+function deps(): CodexResetActionDeps & {
+  getTenantAccessToken: ReturnType<typeof vi.fn>;
+  sendRawCard: ReturnType<typeof vi.fn>;
+  sendTextReply: ReturnType<typeof vi.fn>;
+  sendCardReply: ReturnType<typeof vi.fn>;
+  updateCardMessage: ReturnType<typeof vi.fn>;
+  recallMessage: ReturnType<typeof vi.fn>;
+  consumeCodexRateLimitResetCredit: ReturnType<typeof vi.fn>;
+  createRequestId: ReturnType<typeof vi.fn>;
+} {
+  return {
+    getTenantAccessToken: vi.fn(async () => "tenant-token"),
+    sendRawCard: vi.fn(async () => true),
+    sendTextReply: vi.fn(async () => true),
+    sendCardReply: vi.fn(async () => true),
+    updateCardMessage: vi.fn(async () => true),
+    recallMessage: vi.fn(async () => true),
+    consumeCodexRateLimitResetCredit: vi.fn(async () => ({ code: "reset" as const, windowsReset: 2 })),
+    createRequestId: vi.fn(() => "request-1"),
+  };
+}
+
+function event(value: Record<string, unknown>, messageId: string) {
+  return {
+    event: {
+      open_message_id: messageId,
+      open_chat_id: "chat-1",
+      operator: { open_id: "ou-user" },
+      action: { value },
+    },
+  };
+}
+
+describe("Codex reset card actions", () => {
+  beforeEach(() => {
+    _resetCodexResetRequestsForTest();
+  });
+
+  it("sends a confirmation card tied to the clicked usage card", async () => {
+    const d = deps();
+
+    await expect(handleCodexResetCardAction(
+      event({ action: "codex_reset_request" }, "usage-message"),
+      d,
+    )).resolves.toBe(true);
+
+    expect(d.sendRawCard).toHaveBeenCalledTimes(1);
+    expect(d.sendRawCard.mock.calls[0][1]).toBe("chat-1");
+    const confirmCard = JSON.parse(d.sendRawCard.mock.calls[0][2]);
+    const action = confirmCard.elements.find((element: any) => element.tag === "action");
+    expect(action.actions[0].value).toEqual({
+      action: "codex_reset_confirm",
+      decision: "yes",
+      parentMessageId: "usage-message",
+      requestId: "request-1",
+    });
+  });
+
+  it("consumes a reset credit, sends the result, and collapses the confirmation card when user confirms", async () => {
+    const d = deps();
+    await handleCodexResetCardAction(event({ action: "codex_reset_request" }, "usage-message"), d);
+
+    await expect(handleCodexResetCardAction(
+      event({
+        action: "codex_reset_confirm",
+        decision: "yes",
+        parentMessageId: "usage-message",
+        requestId: "request-1",
+      }, "confirm-message"),
+      d,
+    )).resolves.toBe(true);
+
+    expect(d.consumeCodexRateLimitResetCredit).toHaveBeenCalledWith("request-1");
+    expect(d.updateCardMessage).toHaveBeenCalledTimes(1);
+    expect(d.updateCardMessage.mock.calls[0][1]).toBe("confirm-message");
+    expect(JSON.parse(d.updateCardMessage.mock.calls[0][2]).elements).toEqual([
+      { tag: "markdown", content: " " },
+    ]);
+    expect(d.recallMessage).toHaveBeenCalledWith("tenant-token", "confirm-message");
+    expect(d.sendTextReply).toHaveBeenCalledWith(
+      "tenant-token",
+      "chat-1",
+      expect.stringContaining("重置成功"),
+    );
+    expect(d.sendCardReply).not.toHaveBeenCalled();
+  });
+
+  it("does not consume a reset credit and sends a cancellation message when user declines", async () => {
+    const d = deps();
+    await handleCodexResetCardAction(event({ action: "codex_reset_request" }, "usage-message"), d);
+
+    await expect(handleCodexResetCardAction(
+      event({
+        action: "codex_reset_confirm",
+        decision: "no",
+        parentMessageId: "usage-message",
+        requestId: "request-1",
+      }, "confirm-message"),
+      d,
+    )).resolves.toBe(true);
+
+    expect(d.consumeCodexRateLimitResetCredit).not.toHaveBeenCalled();
+    expect(d.updateCardMessage).toHaveBeenCalledTimes(1);
+    expect(d.recallMessage).toHaveBeenCalledWith("tenant-token", "confirm-message");
+    expect(d.sendTextReply).toHaveBeenCalledWith(
+      "tenant-token",
+      "chat-1",
+      "Codex 主动重置：用户取消了重置。",
+    );
+    expect(d.sendCardReply).not.toHaveBeenCalled();
+  });
+
+  it("can collapse a confirmation card using context.message_id fallback", async () => {
+    const d = deps();
+    await handleCodexResetCardAction(event({ action: "codex_reset_request" }, "usage-message"), d);
+
+    await expect(handleCodexResetCardAction({
+      event: {
+        context: {
+          message_id: "confirm-message-from-context",
+          open_chat_id: "chat-1",
+        },
+        action: {
+          value: {
+            action: "codex_reset_confirm",
+            decision: "no",
+            parentMessageId: "usage-message",
+            requestId: "request-1",
+          },
+        },
+      },
+    }, d)).resolves.toBe(true);
+
+    expect(d.updateCardMessage).toHaveBeenCalledTimes(1);
+    expect(d.updateCardMessage.mock.calls[0][1]).toBe("confirm-message-from-context");
+    expect(d.recallMessage).toHaveBeenCalledWith("tenant-token", "confirm-message-from-context");
+  });
+});

package/src/__tests__/feishu-avatar.test.ts

@@ -39,20 +39,23 @@ async function loadFeishuApiWithHome(homeDir: string, userDataDir: string) {
 async function writeCodexAuth(homeDir: string): Promise<void> {
   const codexDir = join(homeDir, ".codex");
   await mkdir(codexDir, { recursive: true });
-  await writeFile(
-    join(codexDir, "auth.json"),
-    JSON.stringify({ tokens: { access_token: "codex-access-token" } }),
-    "utf-8",
-  );
-}
+  await writeFile(
+    join(codexDir, "auth.json"),
+    JSON.stringify({ tokens: { access_token: "codex-access-token", account_id: "codex-account-id" } }),
+    "utf-8",
+  );
+}
 
 function mockAvatarFetch(uploadedNames: string[], usageResponse: Response): void {
   vi.stubGlobal("fetch", vi.fn(async (url: string | URL | Request, init?: RequestInit) => {
     const urlText = String(url);
-    if (urlText === "https://chatgpt.com/backend-api/wham/usage") {
-      return usageResponse.clone();
-    }
-    if (urlText === "https://open.feishu.test/im/v1/images") {
+    if (urlText === "https://chatgpt.com/backend-api/wham/usage") {
+      return usageResponse.clone();
+    }
+    if (urlText === "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits") {
+      return new Response(JSON.stringify({ credits: [] }), { status: 200 });
+    }
+    if (urlText === "https://open.feishu.test/im/v1/images") {
       const form = init?.body as FormData;
       const image = form.get("image") as File;
       uploadedNames.push(image.name);
@@ -100,31 +103,109 @@ describe("Codex avatar usage battery", () => {
     }
   });
 
-  it("returns both 5h and weekly Codex usage windows", async () => {
-    const homeDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-home-"));
-    const userDataDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-data-"));
-    const uploadedNames: string[] = [];
-    await writeCodexAuth(homeDir);
-    mockAvatarFetch(uploadedNames, new Response(JSON.stringify({
-      rate_limit: {
-        primary_window: { used_percent: 37, reset_after_seconds: 10349, reset_at: 1781528212 },
-        secondary_window: { used_percent: 12, reset_after_seconds: 325063, reset_at: 1781842926 },
-      },
-    }), { status: 200 }));
-
-    try {
-      const { getCodexUsageSummary } = await loadFeishuApiWithHome(homeDir, userDataDir);
-      await expect(getCodexUsageSummary()).resolves.toEqual({
-        fiveHour: { usedPercent: 37, remainingPercent: 63, resetAfterSeconds: 10349, resetAtEpochSeconds: 1781528212 },
-        weekly: { usedPercent: 12, remainingPercent: 88, resetAfterSeconds: 325063, resetAtEpochSeconds: 1781842926 },
-      });
-    } finally {
-      await rm(homeDir, { recursive: true, force: true });
-      await rm(userDataDir, { recursive: true, force: true });
+  it("returns both usage windows and available reset credit expiries", async () => {
+    const homeDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-home-"));
+    const userDataDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-data-"));
+    await writeCodexAuth(homeDir);
+    const fetchMock = vi.fn(async (url: string | URL | Request) => {
+      const urlText = String(url);
+      if (urlText === "https://chatgpt.com/backend-api/wham/usage") {
+        return new Response(JSON.stringify({
+          rate_limit: {
+            primary_window: { used_percent: 37, reset_after_seconds: 10349, reset_at: 1781528212 },
+            secondary_window: { used_percent: 12, reset_after_seconds: 325063, reset_at: 1781842926 },
+          },
+          rate_limit_reset_credits: { available_count: 1 },
+        }), { status: 200 });
+      }
+      if (urlText === "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits") {
+        return new Response(JSON.stringify({
+          available_count: 2,
+          credits: [
+            {
+              status: "available",
+              granted_at: "2026-06-12T04:01:47.770016Z",
+              expires_at: "2026-07-12T04:01:47.770016Z",
+            },
+            {
+              status: "redeemed",
+              granted_at: "2026-06-13T04:01:47.770016Z",
+              expires_at: "2026-07-13T04:01:47.770016Z",
+            },
+            {
+              status: "available",
+              granted_at: "2026-06-18T00:44:23.904386Z",
+              expires_at: "2026-07-18T00:44:23.904386Z",
+            },
+          ],
+        }), { status: 200 });
+      }
+      throw new Error(`unexpected fetch: ${urlText}`);
+    });
+    vi.stubGlobal("fetch", fetchMock);
+
+    try {
+      const { getCodexUsageSummary } = await loadFeishuApiWithHome(homeDir, userDataDir);
+      await expect(getCodexUsageSummary()).resolves.toEqual({
+        fiveHour: { usedPercent: 37, remainingPercent: 63, resetAfterSeconds: 10349, resetAtEpochSeconds: 1781528212 },
+        weekly: { usedPercent: 12, remainingPercent: 88, resetAfterSeconds: 325063, resetAtEpochSeconds: 1781842926 },
+        rateLimitResetCreditsAvailable: 2,
+        rateLimitResetCredits: [
+          { grantedAt: "2026-06-12T04:01:47.770016Z", expiresAt: "2026-07-12T04:01:47.770016Z" },
+          { grantedAt: "2026-06-18T00:44:23.904386Z", expiresAt: "2026-07-18T00:44:23.904386Z" },
+        ],
+      });
+      expect(fetchMock).toHaveBeenCalledWith(
+        "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits",
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            Authorization: "Bearer codex-access-token",
+            "ChatGPT-Account-ID": "codex-account-id",
+            "OpenAI-Beta": "codex-1",
+            originator: "Codex Desktop",
+          }),
+        }),
+      );
+    } finally {
+      await rm(homeDir, { recursive: true, force: true });
+      await rm(userDataDir, { recursive: true, force: true });
     }
-  });
-
-  it("falls back to the pre-combined Codex avatar when usage lookup fails", async () => {
+  });
+
+  it("consumes a Codex rate-limit reset credit through the WHAM endpoint", async () => {
+    const homeDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-home-"));
+    const userDataDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-data-"));
+    await writeCodexAuth(homeDir);
+    const fetchMock = vi.fn(async () => new Response(JSON.stringify({
+      code: "reset",
+      windows_reset: 2,
+    }), { status: 200 }));
+    vi.stubGlobal("fetch", fetchMock);
+
+    try {
+      const { consumeCodexRateLimitResetCredit } = await loadFeishuApiWithHome(homeDir, userDataDir);
+      await expect(consumeCodexRateLimitResetCredit("request-1")).resolves.toEqual({
+        code: "reset",
+        windowsReset: 2,
+      });
+      expect(fetchMock).toHaveBeenCalledWith(
+        "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits/consume",
+        expect.objectContaining({
+          method: "POST",
+          headers: expect.objectContaining({
+            Authorization: "Bearer codex-access-token",
+            "Content-Type": "application/json",
+          }),
+          body: JSON.stringify({ redeem_request_id: "request-1" }),
+        }),
+      );
+    } finally {
+      await rm(homeDir, { recursive: true, force: true });
+      await rm(userDataDir, { recursive: true, force: true });
+    }
+  });
+
+  it("falls back to the pre-combined Codex avatar when usage lookup fails", async () => {
     const homeDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-home-"));
     const userDataDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-data-"));
     const uploadedNames: string[] = [];

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

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeAll, afterAll } from "vitest";
-import { getPlatform, setPlatform, getTenantAccessToken, getChatInfo, createGroupChat, updateChatInfo, sendTextReply, sendCardReply, sendRawCard, sendPostMessage, extractSessionInfo, formatDelayNotice, reportPermissionResults, verifyAllPermissions, addReaction, recallMessage, updateCardMessage, setChatAvatar, getCodexUsageSummary, disbandChat, sendRestartCard, getMergeForwardMessages } from "../feishu-platform.ts";
+import { getPlatform, setPlatform, getTenantAccessToken, getChatInfo, createGroupChat, updateChatInfo, sendTextReply, sendCardReply, sendRawCard, sendPostMessage, extractSessionInfo, formatDelayNotice, reportPermissionResults, verifyAllPermissions, addReaction, recallMessage, updateCardMessage, setChatAvatar, getCodexUsageSummary, consumeCodexRateLimitResetCredit, disbandChat, sendRestartCard, getMergeForwardMessages } from "../feishu-platform.ts";
 import type { FeishuPlatform } from "../feishu-platform.ts";
 
 const realPlatform = getPlatform();
@@ -31,7 +31,10 @@ describe("feishu-platform", () => {
       getCodexUsageSummary: async () => ({
         fiveHour: { usedPercent: 10, remainingPercent: 90, resetAtEpochSeconds: 1781528212, resetAfterSeconds: 10349 },
         weekly: { usedPercent: 20, remainingPercent: 80, resetAtEpochSeconds: 1781842926, resetAfterSeconds: 325063 },
+        rateLimitResetCreditsAvailable: 1,
+        rateLimitResetCredits: [{ grantedAt: null, expiresAt: "2026-07-12T04:01:47.770016Z" }],
       }),
+      consumeCodexRateLimitResetCredit: async () => ({ code: "reset", windowsReset: 2 }),
       getOrDownloadImage: async () => "/tmp/img.png",
       verifyAllPermissions: async () => [],
       reportPermissionResults: realPlatform.reportPermissionResults,
@@ -55,7 +58,10 @@ describe("feishu-platform", () => {
       expect(await getCodexUsageSummary()).toEqual({
         fiveHour: { usedPercent: 10, remainingPercent: 90, resetAtEpochSeconds: 1781528212, resetAfterSeconds: 10349 },
         weekly: { usedPercent: 20, remainingPercent: 80, resetAtEpochSeconds: 1781842926, resetAfterSeconds: 325063 },
+        rateLimitResetCreditsAvailable: 1,
+        rateLimitResetCredits: [{ grantedAt: null, expiresAt: "2026-07-12T04:01:47.770016Z" }],
       });
+      expect(await consumeCodexRateLimitResetCredit("request-1")).toEqual({ code: "reset", windowsReset: 2 });
     } finally {
       // 恢复到真实实现，避免影响后续测试
       setPlatform(realPlatform);

package/src/__tests__/orchestrator.test.ts

@@ -129,10 +129,12 @@ describe("handleCommand WeChat processing ack", () => {
     mockStreamStates.clear();
     mockGetCodexUsageSummary.mockReset();
     mockGetCursorUsageSummary.mockReset();
-    mockGetCodexUsageSummary.mockResolvedValue({
-      fiveHour: { usedPercent: 0, remainingPercent: 100, resetAtEpochSeconds: null, resetAfterSeconds: null },
-      weekly: { usedPercent: 0, remainingPercent: 100, resetAtEpochSeconds: null, resetAfterSeconds: null },
-    });
+    mockGetCodexUsageSummary.mockResolvedValue({
+      fiveHour: { usedPercent: 0, remainingPercent: 100, resetAtEpochSeconds: null, resetAfterSeconds: null },
+      weekly: { usedPercent: 0, remainingPercent: 100, resetAtEpochSeconds: null, resetAfterSeconds: null },
+      rateLimitResetCreditsAvailable: null,
+      rateLimitResetCredits: null,
+    });
     mockGetCursorUsageSummary.mockResolvedValue({
       billingCycleStart: "1779357999000",
       billingCycleEnd: "1782036399000",
@@ -368,51 +370,35 @@ describe("handleCommand WeChat processing ack", () => {
 
   it("handles /usage without creating a new Feishu group", async () => {
     const platform = mockPlatform("feishu");
-    mockGetCodexUsageSummary.mockResolvedValue({
-      fiveHour: { usedPercent: 37, remainingPercent: 63, resetAtEpochSeconds: 1781528212, resetAfterSeconds: 10349 },
-      weekly: { usedPercent: 12, remainingPercent: 88, resetAtEpochSeconds: 1781842926, resetAfterSeconds: 325063 },
-    });
-
-    await handleCommand(platform, "/usage", "feishu-p2p", "ou-user", Date.now(), "p2p");
+    mockGetCodexUsageSummary.mockResolvedValue({
+      fiveHour: { usedPercent: 37, remainingPercent: 63, resetAtEpochSeconds: 1781528212, resetAfterSeconds: 10349 },
+      weekly: { usedPercent: 12, remainingPercent: 88, resetAtEpochSeconds: 1781842926, resetAfterSeconds: 325063 },
+      rateLimitResetCreditsAvailable: 2,
+      rateLimitResetCredits: [
+        { grantedAt: "2026-06-12T04:01:47.770016Z", expiresAt: "2026-07-12T04:01:47.770016Z" },
+        { grantedAt: "2026-06-18T00:44:23.904386Z", expiresAt: "2026-07-18T00:44:23.904386Z" },
+      ],
+    });
 
-    expect(platform.createGroup).not.toHaveBeenCalled();
-    expect(platform.sendCard).toHaveBeenCalledWith(
-      "feishu-p2p",
-      "Codex Usage",
-      expect.stringContaining("**5h:** 已用 37%，剩余 63%，重置:"),
-      "blue",
-    );
-    expect(platform.sendCard).toHaveBeenCalledWith(
-      "feishu-p2p",
-      "Codex Usage",
-      expect.stringContaining("约 2小时52分钟后"),
-      "blue",
-    );
-    expect(platform.sendCard).toHaveBeenCalledWith(
-      "feishu-p2p",
-      "Codex Usage",
-      expect.stringContaining("[███████░░░░░░░░░░░░░]"),
-      "blue",
-    );
-    expect(platform.sendCard).toHaveBeenCalledWith(
-      "feishu-p2p",
-      "Codex Usage",
-      expect.stringContaining("**周:** 已用 12%，剩余 88%，重置:"),
-      "blue",
-    );
-    expect(platform.sendCard).toHaveBeenCalledWith(
-      "feishu-p2p",
-      "Codex Usage",
-      expect.stringContaining("约 3天18小时17分钟后"),
-      "blue",
-    );
-    expect(platform.sendCard).toHaveBeenCalledWith(
-      "feishu-p2p",
-      "Codex Usage",
-      expect.stringContaining("[██░░░░░░░░░░░░░░░░░░]"),
-      "blue",
-    );
-  });
+    await handleCommand(platform, "/usage", "feishu-p2p", "ou-user", Date.now(), "p2p");
+
+    expect(platform.createGroup).not.toHaveBeenCalled();
+    expect(platform.sendCard).not.toHaveBeenCalled();
+    expect(platform.sendRawCard).toHaveBeenCalledTimes(1);
+    const card = JSON.parse(vi.mocked(platform.sendRawCard).mock.calls[0][1]);
+    expect(card.header.title.content).toBe("Codex Usage");
+    expect(card.elements[0].text.content).toContain("2026-07-12");
+    expect(card.elements[0].text.content).toContain("2026-07-18");
+    expect(card.elements[0].text.content).toContain("**主动重置:** 剩余 2 次");
+    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("**周:** 已用 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 });
+  });
 
   it("handles /usage as Cursor usage in Cursor chats", async () => {
     const platform = mockPlatform("feishu");
@@ -452,7 +438,7 @@ describe("handleCommand WeChat processing ack", () => {
     expect(codexPlatform.sendCard).toHaveBeenCalledWith(
       "feishu-group",
       "Codex Session Ready",
-      expect.stringContaining("发送 **/usage** 查看 Codex 5h 和周用量。"),
+      expect.stringContaining("发送 **/usage** 查看 Codex 5h/周用量，以及查询/使用主动重置卡。"),
       "green",
     );
 

package/src/cards.ts

@@ -137,7 +137,7 @@ export function buildHelpCard(
     "发送 **/newh** 重置当前会话（沿用当前工作目录，不切换）",
     "发送 **/plan** 以规划模式提问（只读，不执行写操作）",
     "发送 **/ask** 以问答模式提问（只读，不执行写操作）",
-    "发送 **/usage** 查看 Codex 5h 和周用量",
+    "发送 **/usage** 查看 Codex 5h/周用量，以及查询/使用主动重置卡",
     "发送 **/restart** 重启 ChatCCC 进程",
     "发送 **/update** 更新并重启（仅 npm 全局安装可用）",
     ABD_HELP_LINE,
@@ -410,11 +410,11 @@ export function buildQueueFullCard(): string {
 }
 
 // 状态卡片（带关闭按钮）
-export function buildStatusCard(statusText: string, template = "blue"): string {
-  return JSON.stringify({
-    config: { wide_screen_mode: true },
-    header: { template, title: { content: "会话状态", tag: "plain_text" } },
-    elements: [
+export function buildStatusCard(statusText: string, template = "blue"): string {
+  return JSON.stringify({
+    config: { wide_screen_mode: true },
+    header: { template, title: { content: "会话状态", tag: "plain_text" } },
+    elements: [
       { tag: "div", text: { tag: "lark_md", content: statusText } },
       { tag: "hr" },
       {
@@ -426,12 +426,78 @@ export function buildStatusCard(statusText: string, template = "blue"): string {
           value: { action: "close" },
         }],
       },
-    ],
-  });
-}
-
-/** 模型切换卡片（/model 命令，飞书专用，含切换按钮） */
-export function buildModelCard(
+    ],
+  });
+}
+
+export function buildCodexUsageCard(content: string, resetCreditsAvailable: number | null): string {
+  const elements: object[] = [
+    { tag: "div", text: { tag: "lark_md", content } },
+  ];
+  if (resetCreditsAvailable !== null && resetCreditsAvailable > 0) {
+    elements.push({ tag: "hr" });
+    elements.push({
+      tag: "action",
+      actions: [{
+        tag: "button",
+        text: { tag: "plain_text", content: "发起重置" },
+        type: "primary",
+        value: { action: "codex_reset_request", availableCount: resetCreditsAvailable },
+      }],
+    });
+  }
+
+  return JSON.stringify({
+    config: { wide_screen_mode: true },
+    header: { template: "blue", title: { content: "Codex Usage", tag: "plain_text" } },
+    elements,
+  });
+}
+
+export function buildCodexResetConfirmCard(params: {
+  availableCount: number;
+  parentMessageId: string;
+  requestId: string;
+}): string {
+  const valueBase = {
+    parentMessageId: params.parentMessageId,
+    requestId: params.requestId,
+  };
+  return JSON.stringify({
+    config: { wide_screen_mode: true },
+    header: { template: "yellow", title: { content: "确认 Codex 主动重置", tag: "plain_text" } },
+    elements: [
+      {
+        tag: "div",
+        text: {
+          tag: "lark_md",
+          content: `当前可用主动重置次数：**${params.availableCount}**。\n\n确认后会消耗 1 次主动重置，并重置当前可重置的 Codex 用量窗口。`,
+        },
+      },
+      { tag: "hr" },
+      {
+        tag: "action",
+        actions: [
+          {
+            tag: "button",
+            text: { tag: "plain_text", content: "是，发起重置" },
+            type: "danger",
+            value: { action: "codex_reset_confirm", decision: "yes", ...valueBase },
+          },
+          {
+            tag: "button",
+            text: { tag: "plain_text", content: "否" },
+            type: "default",
+            value: { action: "codex_reset_confirm", decision: "no", ...valueBase },
+          },
+        ],
+      },
+    ],
+  });
+}
+
+/** 模型切换卡片（/model 命令，飞书专用，含切换按钮） */
+export function buildModelCard(
   currentModel: string,
   models: string[],
   tool?: string,

package/src/codex-reset-actions.ts

@@ -0,0 +1,184 @@
+import { randomUUID } from "node:crypto";
+
+import { buildCodexResetConfirmCard } from "./cards.ts";
+import type { CodexResetConsumeResult } from "./feishu-api.ts";
+
+type CodexResetDecision = "yes" | "no";
+
+interface PendingCodexResetRequest {
+  chatId: string;
+  parentMessageId: string;
+  status: "pending" | "handled";
+}
+
+export interface CodexResetActionDeps {
+  getTenantAccessToken(): Promise<string>;
+  sendRawCard(token: string, chatId: string, cardJson: string): Promise<boolean>;
+  sendTextReply(token: string, chatId: string, text: string): Promise<boolean>;
+  sendCardReply(token: string, chatId: string, title: string, content: string, template?: string): Promise<boolean>;
+  updateCardMessage(token: string, messageId: string, content: string): Promise<boolean>;
+  recallMessage(token: string, messageId: string): Promise<boolean>;
+  consumeCodexRateLimitResetCredit(redeemRequestId: string): Promise<CodexResetConsumeResult>;
+  createRequestId?: () => string;
+}
+
+const pendingCodexResetRequests = new Map<string, PendingCodexResetRequest>();
+
+function rawEvent(data: unknown): Record<string, unknown> {
+  return ((data as Record<string, unknown>)?.event ?? data) as Record<string, unknown>;
+}
+
+function actionValue(raw: Record<string, unknown>): Record<string, unknown> | null {
+  const action = raw.action as { value?: unknown } | undefined;
+  const value = action?.value;
+  if (!value || typeof value !== "object") return null;
+  return value as Record<string, unknown>;
+}
+
+function eventMessageId(raw: Record<string, unknown>): string {
+  return typeof raw.open_message_id === "string"
+    ? raw.open_message_id
+    : typeof (raw.context as Record<string, unknown> | undefined)?.open_message_id === "string"
+      ? (raw.context as Record<string, string>).open_message_id
+      : typeof raw.message_id === "string"
+        ? raw.message_id
+        : typeof (raw.context as Record<string, unknown> | undefined)?.message_id === "string"
+          ? (raw.context as Record<string, string>).message_id
+          : typeof (raw.message as Record<string, unknown> | undefined)?.message_id === "string"
+            ? (raw.message as Record<string, string>).message_id
+            : "";
+}
+
+function eventChatId(raw: Record<string, unknown>): string {
+  return typeof raw.open_chat_id === "string"
+    ? raw.open_chat_id
+    : typeof (raw.context as Record<string, unknown> | undefined)?.open_chat_id === "string"
+      ? (raw.context as Record<string, string>).open_chat_id
+      : typeof (raw.message as Record<string, unknown> | undefined)?.chat_id === "string"
+        ? (raw.message as Record<string, string>).chat_id
+        : "";
+}
+
+function collapsedCard(): string {
+  return JSON.stringify({
+    config: { wide_screen_mode: true },
+    elements: [{ tag: "markdown", content: " " }],
+  });
+}
+
+function resetResultMessage(result: CodexResetConsumeResult): { content: string; template: string } {
+  if (result.code === "reset") {
+    return {
+      content: `重置成功。已重置 ${result.windowsReset} 个 Codex 用量窗口。`,
+      template: "green",
+    };
+  }
+  if (result.code === "nothing_to_reset") {
+    return {
+      content: "没有需要重置的 Codex 用量窗口。",
+      template: "yellow",
+    };
+  }
+  if (result.code === "no_credit") {
+    return {
+      content: "没有可用的 Codex 主动重置次数。",
+      template: "red",
+    };
+  }
+  return {
+    content: "这次 Codex 主动重置请求已经处理过。",
+    template: "yellow",
+  };
+}
+
+async function sendResetRequestConfirmation(
+  raw: Record<string, unknown>,
+  value: Record<string, unknown>,
+  deps: CodexResetActionDeps,
+): Promise<boolean> {
+  const parentMessageId = eventMessageId(raw);
+  const chatId = eventChatId(raw);
+  if (!parentMessageId || !chatId) return true;
+  const availableCount = Number(value.availableCount);
+
+  const requestId = (deps.createRequestId ?? randomUUID)();
+  pendingCodexResetRequests.set(requestId, {
+    chatId,
+    parentMessageId,
+    status: "pending",
+  });
+
+  const token = await deps.getTenantAccessToken();
+  await deps.sendRawCard(token, chatId, buildCodexResetConfirmCard({
+    availableCount: Number.isFinite(availableCount) ? Math.max(1, Math.trunc(availableCount)) : 1,
+    parentMessageId,
+    requestId,
+  }));
+  return true;
+}
+
+async function handleResetConfirmation(
+  raw: Record<string, unknown>,
+  value: Record<string, unknown>,
+  deps: CodexResetActionDeps,
+): Promise<boolean> {
+  const decision = value.decision;
+  const requestId = value.requestId;
+  const parentMessageId = value.parentMessageId;
+  if ((decision !== "yes" && decision !== "no") || typeof requestId !== "string" || typeof parentMessageId !== "string") {
+    return true;
+  }
+
+  const token = await deps.getTenantAccessToken();
+  const confirmMessageId = eventMessageId(raw);
+  if (confirmMessageId) {
+    const collapsed = await deps.updateCardMessage(token, confirmMessageId, collapsedCard());
+    console.log(`[Codex Reset] collapse confirmation card ${collapsed ? "OK" : "FAILED"}: messageId=${confirmMessageId}`);
+    const recalled = await deps.recallMessage(token, confirmMessageId);
+    console.log(`[Codex Reset] recall confirmation card ${recalled ? "OK" : "FAILED"}: messageId=${confirmMessageId}`);
+  } else {
+    console.error("[Codex Reset] missing confirmation card message id; cannot collapse");
+  }
+
+  const pending = pendingCodexResetRequests.get(requestId);
+  const chatId = pending?.chatId ?? eventChatId(raw);
+  if (!chatId) return true;
+
+  if (!pending || pending.status !== "pending" || pending.parentMessageId !== parentMessageId) {
+    await deps.sendTextReply(token, chatId, "Codex 主动重置：这张确认卡片已经失效或已处理。");
+    return true;
+  }
+  pending.status = "handled";
+
+  if (decision === "no") {
+    await deps.sendTextReply(token, chatId, "Codex 主动重置：用户取消了重置。");
+    return true;
+  }
+
+  try {
+    const result = await deps.consumeCodexRateLimitResetCredit(requestId);
+    const message = resetResultMessage(result);
+    await deps.sendTextReply(token, chatId, `Codex 主动重置：${message.content}`);
+  } catch (err) {
+    await deps.sendTextReply(token, chatId, `Codex 主动重置失败：${(err as Error).message}`);
+  }
+  return true;
+}
+
+export async function handleCodexResetCardAction(data: unknown, deps: CodexResetActionDeps): Promise<boolean> {
+  const raw = rawEvent(data);
+  const value = actionValue(raw);
+  if (!value) return false;
+  const action = value?.action;
+  if (action === "codex_reset_request") {
+    return sendResetRequestConfirmation(raw, value, deps);
+  }
+  if (action === "codex_reset_confirm") {
+    return handleResetConfirmation(raw, value, deps);
+  }
+  return false;
+}
+
+export function _resetCodexResetRequestsForTest(): void {
+  pendingCodexResetRequests.clear();
+}

package/src/feishu-api.ts

@@ -302,8 +302,10 @@ const AVATAR_DIR = resolvePath(PROJECT_ROOT, "images", "avatars");
 const AVATAR_BADGE_DIR = resolvePath(AVATAR_DIR, "badges");
 const AVATAR_COMBINATIONS_DIR = resolvePath(AVATAR_DIR, "combinations");
 const AVATAR_KEY_CACHE_FILE = resolvePath(USER_DATA_DIR, "state", "avatar-image-keys.json");
-const CODEX_AUTH_FILE = resolvePath(homedir(), ".codex", "auth.json");
-const CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
+const CODEX_AUTH_FILE = resolvePath(homedir(), ".codex", "auth.json");
+const CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
+const CODEX_RESET_CREDITS_URL = "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits";
+const CODEX_RESET_CONSUME_URL = "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits/consume";
 const AVATAR_SOURCES: Record<string, string> = {
   new: resolvePath(AVATAR_DIR, "status_new.png"),
   busy: resolvePath(AVATAR_DIR, "status_busy.png"),
@@ -320,17 +322,31 @@ const AVATAR_BADGE_MARGIN = 10;
 const CODEX_AVATAR_USAGE_STYLE_VERSION = "usage-ring-gray-consumed-v13";
 const CURSOR_AVATAR_USAGE_STYLE_VERSION = "usage-battery-v1";
 
-export interface CodexUsageBalance {
-  usedPercent: number;
-  remainingPercent: number;
-  resetAtEpochSeconds: number | null;
-  resetAfterSeconds: number | null;
-}
-
-export interface CodexUsageSummary {
-  fiveHour: CodexUsageBalance;
-  weekly: CodexUsageBalance | null;
-}
+export interface CodexUsageBalance {
+  usedPercent: number;
+  remainingPercent: number;
+  resetAtEpochSeconds: number | null;
+  resetAfterSeconds: number | null;
+}
+
+export interface CodexRateLimitResetCredit {
+  grantedAt: string | null;
+  expiresAt: string;
+}
+
+export interface CodexUsageSummary {
+  fiveHour: CodexUsageBalance;
+  weekly: CodexUsageBalance | null;
+  rateLimitResetCreditsAvailable: number | null;
+  rateLimitResetCredits: CodexRateLimitResetCredit[] | null;
+}
+
+export type CodexResetConsumeCode = "reset" | "nothing_to_reset" | "no_credit" | "already_redeemed";
+
+export interface CodexResetConsumeResult {
+  code: CodexResetConsumeCode;
+  windowsReset: number;
+}
 
 const avatarKeyCache = new Map<string, string>();
 let avatarKeyCacheLoaded = false;
@@ -411,58 +427,167 @@ function usageBalanceFromWindow(raw: Record<string, unknown>, fieldName: string)
   };
 }
 
-function parseOptionalUsageWindow(rateLimit: Record<string, unknown>, keys: string[]): CodexUsageBalance | null {
+function parseOptionalUsageWindow(rateLimit: Record<string, unknown>, keys: string[]): CodexUsageBalance | null {
   for (const key of keys) {
     const raw = rateLimit[key];
     if (!raw || typeof raw !== "object") continue;
     if ((raw as { used_percent?: unknown }).used_percent === undefined) continue;
     return usageBalanceFromWindow(raw as Record<string, unknown>, `rate_limit.${key}`);
   }
-  return null;
-}
-
-async function getCodexAccessToken(): Promise<string | null> {
-  try {
-    const raw = await readFile(CODEX_AUTH_FILE, "utf-8");
-    const parsed = JSON.parse(raw) as { tokens?: { access_token?: unknown } };
-    const token = parsed.tokens?.access_token;
-    return typeof token === "string" && token.trim() ? token : null;
-  } catch {
-    return null;
-  }
-}
-
-export async function getCodexUsageSummary(): Promise<CodexUsageSummary> {
-  const token = await getCodexAccessToken();
-  if (!token) throw new Error("missing ~/.codex/auth.json access token");
-
-  const resp = await fetch(CODEX_USAGE_URL, {
-    headers: { Authorization: `Bearer ${token}` },
-  });
-  const text = await resp.text();
-  if (!resp.ok) throw new Error(`HTTP ${resp.status}: ${text.slice(0, 160)}`);
-
-  const data = JSON.parse(text) as {
-    rate_limit?: Record<string, unknown>;
-  };
-  const rateLimit = data.rate_limit;
-  if (!rateLimit || typeof rateLimit !== "object") throw new Error("missing rate_limit");
-
-  const fiveHour = parseOptionalUsageWindow(rateLimit, ["primary_window"]);
-  if (!fiveHour) throw new Error("missing rate_limit.primary_window.used_percent");
-
-  return {
-    fiveHour,
-    weekly: parseOptionalUsageWindow(rateLimit, [
-      "secondary_window",
-      "weekly_window",
-      "week_window",
-      "long_window",
-    ]),
-  };
-}
-
-async function fetchCodexAvatarUsage(): Promise<CodexUsageSummary | null> {
+  return null;
+}
+
+function parseRateLimitResetCredits(data: Record<string, unknown>): number | null {
+  const raw = data.rate_limit_reset_credits;
+  if (!raw || typeof raw !== "object") return null;
+  const availableCount = Number((raw as { available_count?: unknown }).available_count);
+  if (!Number.isFinite(availableCount)) return null;
+  return Math.max(0, Math.trunc(availableCount));
+}
+
+interface CodexAuth {
+  accessToken: string;
+  accountId?: string;
+}
+
+async function getCodexAuth(): Promise<CodexAuth | null> {
+  try {
+    const raw = await readFile(CODEX_AUTH_FILE, "utf-8");
+    const parsed = JSON.parse(raw) as { tokens?: { access_token?: unknown; account_id?: unknown } };
+    const token = parsed.tokens?.access_token;
+    if (typeof token !== "string" || !token.trim()) return null;
+    const accountId = parsed.tokens?.account_id;
+    return {
+      accessToken: token,
+      accountId: typeof accountId === "string" && accountId.trim() ? accountId : undefined,
+    };
+  } catch {
+    return null;
+  }
+}
+
+async function getCodexAccessToken(): Promise<string | null> {
+  return (await getCodexAuth())?.accessToken ?? null;
+}
+
+function codexAuthHeaders(auth: CodexAuth): Record<string, string> {
+  const headers: Record<string, string> = {
+    Authorization: `Bearer ${auth.accessToken}`,
+    "OpenAI-Beta": "codex-1",
+    originator: "Codex Desktop",
+  };
+  if (auth.accountId) headers["ChatGPT-Account-ID"] = auth.accountId;
+  return headers;
+}
+
+function parseCodexResetCreditDetails(data: Record<string, unknown>): {
+  availableCount: number | null;
+  availableCredits: CodexRateLimitResetCredit[];
+} {
+  const availableCount = Number(data.available_count);
+  const credits = Array.isArray(data.credits) ? data.credits : [];
+  return {
+    availableCount: Number.isFinite(availableCount) ? Math.max(0, Math.trunc(availableCount)) : null,
+    availableCredits: credits.flatMap((raw) => {
+      if (!raw || typeof raw !== "object") return [];
+      const credit = raw as { status?: unknown; granted_at?: unknown; expires_at?: unknown };
+      if (credit.status !== "available") return [];
+      if (typeof credit.expires_at !== "string" || !credit.expires_at.trim()) return [];
+      return [{
+        grantedAt: typeof credit.granted_at === "string" && credit.granted_at.trim() ? credit.granted_at : null,
+        expiresAt: credit.expires_at,
+      }];
+    }),
+  };
+}
+
+async function fetchCodexRateLimitResetCredits(auth: CodexAuth): Promise<{
+  availableCount: number | null;
+  availableCredits: CodexRateLimitResetCredit[];
+} | null> {
+  try {
+    const resp = await fetch(CODEX_RESET_CREDITS_URL, {
+      headers: codexAuthHeaders(auth),
+    });
+    const text = await resp.text();
+    if (!resp.ok) throw new Error(`HTTP ${resp.status}: ${text.slice(0, 160)}`);
+    return parseCodexResetCreditDetails(JSON.parse(text) as Record<string, unknown>);
+  } catch (err) {
+    console.warn(`[Codex] reset credits lookup failed: ${(err as Error).message}`);
+    return null;
+  }
+}
+
+export async function getCodexUsageSummary(): Promise<CodexUsageSummary> {
+  const auth = await getCodexAuth();
+  if (!auth) throw new Error("missing ~/.codex/auth.json access token");
+
+  const resetCreditsPromise = fetchCodexRateLimitResetCredits(auth);
+
+  const resp = await fetch(CODEX_USAGE_URL, {
+    headers: { Authorization: `Bearer ${auth.accessToken}` },
+  });
+  const text = await resp.text();
+  if (!resp.ok) throw new Error(`HTTP ${resp.status}: ${text.slice(0, 160)}`);
+
+  const data = JSON.parse(text) as {
+    rate_limit?: Record<string, unknown>;
+    rate_limit_reset_credits?: unknown;
+  };
+  const rateLimit = data.rate_limit;
+  if (!rateLimit || typeof rateLimit !== "object") throw new Error("missing rate_limit");
+
+  const fiveHour = parseOptionalUsageWindow(rateLimit, ["primary_window"]);
+  if (!fiveHour) throw new Error("missing rate_limit.primary_window.used_percent");
+  const resetCredits = await resetCreditsPromise;
+
+  return {
+    fiveHour,
+    weekly: parseOptionalUsageWindow(rateLimit, [
+      "secondary_window",
+      "weekly_window",
+      "week_window",
+      "long_window",
+    ]),
+    rateLimitResetCreditsAvailable: resetCredits?.availableCount ?? parseRateLimitResetCredits(data),
+    rateLimitResetCredits: resetCredits?.availableCredits ?? null,
+  };
+}
+
+export async function consumeCodexRateLimitResetCredit(redeemRequestId: string): Promise<CodexResetConsumeResult> {
+  if (!redeemRequestId.trim()) throw new Error("missing redeem_request_id");
+  const token = await getCodexAccessToken();
+  if (!token) throw new Error("missing ~/.codex/auth.json access token");
+
+  const resp = await fetch(CODEX_RESET_CONSUME_URL, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({ redeem_request_id: redeemRequestId }),
+  });
+  const text = await resp.text();
+  if (!resp.ok) throw new Error(`HTTP ${resp.status}: ${text.slice(0, 160)}`);
+
+  const data = JSON.parse(text) as { code?: unknown; windows_reset?: unknown };
+  const code = data.code;
+  if (
+    code !== "reset"
+    && code !== "nothing_to_reset"
+    && code !== "no_credit"
+    && code !== "already_redeemed"
+  ) {
+    throw new Error("missing or unknown reset result code");
+  }
+  const windowsReset = Number(data.windows_reset);
+  return {
+    code,
+    windowsReset: Number.isFinite(windowsReset) ? Math.max(0, Math.trunc(windowsReset)) : 0,
+  };
+}
+
+async function fetchCodexAvatarUsage(): Promise<CodexUsageSummary | null> {
   try {
     const summary = await getCodexUsageSummary();
     if (!summary.weekly) throw new Error("missing weekly usage window");

package/src/feishu-platform.ts

@@ -31,6 +31,7 @@ export interface FeishuPlatform {
   disbandChat: typeof realApi.disbandChat;
   setChatAvatar: typeof realApi.setChatAvatar;
   getCodexUsageSummary: typeof realApi.getCodexUsageSummary;
+  consumeCodexRateLimitResetCredit: typeof realApi.consumeCodexRateLimitResetCredit;
   getOrDownloadImage: typeof realApi.getOrDownloadImage;
   verifyAllPermissions: typeof realApi.verifyAllPermissions;
   reportPermissionResults: typeof realApi.reportPermissionResults;
@@ -117,6 +118,10 @@ export function getCodexUsageSummary(...args: Parameters<typeof realApi.getCodex
   return _impl.getCodexUsageSummary(...args);
 }
 
+export function consumeCodexRateLimitResetCredit(...args: Parameters<typeof realApi.consumeCodexRateLimitResetCredit>): ReturnType<typeof realApi.consumeCodexRateLimitResetCredit> {
+  return _impl.consumeCodexRateLimitResetCredit(...args);
+}
+
 export function getOrDownloadImage(...args: Parameters<typeof realApi.getOrDownloadImage>): ReturnType<typeof realApi.getOrDownloadImage> {
   return _impl.getOrDownloadImage(...args);
 }

package/src/index.ts

@@ -74,6 +74,7 @@ import {
   verifyAllPermissions,
   reportPermissionResults,
   setPlatform,
+  consumeCodexRateLimitResetCredit,
 } from "./feishu-platform.ts";
 import { SimulatedPlatform, SIM_DEFAULT_CHAT_ID } from "./sim-platform.ts";
 import { setMessageHandler } from "./sim-store.ts";
@@ -103,6 +104,7 @@ import {
 import { fixStaleStreamStates } from "./stream-state.ts";
 import { handleCommand, type PlatformAdapter } from "./orchestrator.ts";
 import { createWechatAdapter, startWechatPlatform } from "./wechat-platform.ts";
+import { handleCodexResetCardAction } from "./codex-reset-actions.ts";
 
 // ---------------------------------------------------------------------------
 // Feishu 平台适配器
@@ -464,6 +466,17 @@ async function startBotServiceCore(): Promise<void> {
         return;
       }
 
+      const handledCodexReset = await handleCodexResetCardAction(data, {
+        getTenantAccessToken,
+        sendRawCard,
+        sendTextReply,
+        sendCardReply,
+        updateCardMessage,
+        recallMessage,
+        consumeCodexRateLimitResetCredit,
+      });
+      if (handledCodexReset) return;
+
       const result = parseCardAction(data);
       if (!result) return;
       console.log(`[BTN] chat=${result.chatId} text="${result.text}"`);

package/src/orchestrator.ts

@@ -38,13 +38,14 @@ import {
 import {
   buildHelpCard,
   buildModelCard,
-  buildStatusCard,
-  buildCdContent,
-  buildCdCard,
-  buildSessionsCard,
-  buildQueuedCard,
-  buildQueueFullCard,
-} from "./cards.ts";
+  buildStatusCard,
+  buildCdContent,
+  buildCdCard,
+  buildSessionsCard,
+  buildQueuedCard,
+  buildQueueFullCard,
+  buildCodexUsageCard,
+} from "./cards.ts";
 import {
   formatGitResult,
   gitResultHeaderTemplate,
@@ -113,7 +114,7 @@ function findModelMatch(input: string, models: string[]): string | null {
   return candidates[0] ?? null;
 }
 
-function formatCodexUsageSummary(usage: CodexUsageSummary): string {
+function formatCodexUsageSummary(usage: CodexUsageSummary): string {
   const progressBar = (usedPercent: number) => {
     const width = 20;
     const usedBlocks = Math.max(0, Math.min(width, Math.round((usedPercent / 100) * width)));
@@ -152,21 +153,54 @@ function formatCodexUsageSummary(usage: CodexUsageSummary): string {
     return `${absolute}${formatDuration(balance.resetAfterSeconds)}`;
   };
 
-  const formatWindow = (label: string, balance: CodexUsageSummary["fiveHour"] | null) => {
-    if (!balance) return `**${label}:** 暂无数据`;
-    return [
-      `**${label}:** 已用 ${balance.usedPercent}%，剩余 ${balance.remainingPercent}%，重置: ${formatResetTime(balance)}`,
-      progressBar(balance.usedPercent),
-    ].join("\n");
-  };
-
-  return [
-    "Codex 用量：",
-    "",
-    formatWindow("5h", usage.fiveHour),
-    formatWindow("周", usage.weekly),
-  ].join("\n");
-}
+  const formatWindow = (label: string, balance: CodexUsageSummary["fiveHour"] | null) => {
+    if (!balance) return `**${label}:** 暂无数据`;
+    return [
+      `**${label}:** 已用 ${balance.usedPercent}%，剩余 ${balance.remainingPercent}%，重置: ${formatResetTime(balance)}`,
+      progressBar(balance.usedPercent),
+    ].join("\n");
+  };
+
+  const formatResetCredits = () => {
+    if (usage.rateLimitResetCreditsAvailable === null) return "**主动重置:** 暂无数据";
+    const lines = [`**主动重置:** 剩余 ${usage.rateLimitResetCreditsAvailable} 次`];
+    const credits = usage.rateLimitResetCredits ?? [];
+    if (credits.length > 0) {
+      const pad = (value: number) => String(value).padStart(2, "0");
+      const formatExpiresAt = (value: string) => {
+        const date = new Date(value);
+        if (!Number.isFinite(date.getTime())) return value;
+        return [
+          date.getFullYear(),
+          "-",
+          pad(date.getMonth() + 1),
+          "-",
+          pad(date.getDate()),
+          " ",
+          pad(date.getHours()),
+          ":",
+          pad(date.getMinutes()),
+          ":",
+          pad(date.getSeconds()),
+        ].join("");
+      };
+      lines.push("**过期时间:**");
+      for (const credit of credits) {
+        lines.push(`- ${formatExpiresAt(credit.expiresAt)}`);
+      }
+    }
+    return lines.join("\n");
+  };
+
+  return [
+    "Codex 用量：",
+    "",
+    formatResetCredits(),
+    "",
+    formatWindow("5h", usage.fiveHour),
+    formatWindow("周", usage.weekly),
+  ].join("\n");
+}
 
 function formatCursorUsageSummary(usage: CursorUsageSummary): string {
   const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
@@ -225,7 +259,7 @@ function formatCursorUsageSummary(usage: CursorUsageSummary): string {
 }
 
 function usageHelpLine(tool: string): string {
-  if (tool === "codex") return "\n发送 **/usage** 查看 Codex 5h 和周用量。";
+  if (tool === "codex") return "\n发送 **/usage** 查看 Codex 5h/周用量，以及查询/使用主动重置卡。";
   if (tool === "cursor") return "\n发送 **/usage** 查看 Cursor 用量。";
   return "";
 }
@@ -250,13 +284,16 @@ async function sendUsageSummary(platform: PlatformAdapter, chatId: string, tool:
     return;
   }
 
-  const content = formatCodexUsageSummary(await getCodexUsageSummary());
-  if (platform.kind === "wechat") {
-    await platform.sendText(chatId, content).catch(() => {});
-  } else {
-    await platform.sendCard(chatId, "Codex Usage", content, "blue");
-  }
-}
+  const usage = await getCodexUsageSummary();
+  const content = formatCodexUsageSummary(usage);
+  if (platform.kind === "wechat") {
+    await platform.sendText(chatId, content).catch(() => {});
+  } else if (platform.kind === "feishu") {
+    await platform.sendRawCard(chatId, buildCodexUsageCard(content, usage.rateLimitResetCreditsAvailable));
+  } else {
+    await platform.sendCard(chatId, "Codex Usage", content, "blue");
+  }
+}
 
 async function sendUsageError(platform: PlatformAdapter, chatId: string, tool: "codex" | "cursor", err: unknown): Promise<void> {
   const toolLabel = tool === "cursor" ? "Cursor" : "Codex";

package/src/sim-platform.ts

@@ -131,9 +131,15 @@ export const SimulatedPlatform: FeishuPlatform = {
     return {
       fiveHour: { usedPercent: 0, remainingPercent: 100, resetAtEpochSeconds: null, resetAfterSeconds: null },
       weekly: { usedPercent: 0, remainingPercent: 100, resetAtEpochSeconds: null, resetAfterSeconds: null },
+      rateLimitResetCreditsAvailable: null,
+      rateLimitResetCredits: null,
     };
   },
 
+  async consumeCodexRateLimitResetCredit(_redeemRequestId) {
+    return { code: "no_credit" as const, windowsReset: 0 };
+  },
+
   // ---- 图片下载 ----
   async getOrDownloadImage(_token, _messageId, fileKey) {
     return join(SIM_DIR, "images", fileKey);