chatccc 0.2.180 → 0.2.181

package/src/__tests__/orchestrator.test.ts

@@ -65,8 +65,8 @@ vi.mock("../cursor-usage.ts", () => ({
 }));
 
 import { handleCommand } from "../orchestrator.ts";
-import {
-  _clearAdapterCacheForTest,
+import {
+  _clearAdapterCacheForTest,
   _resetSessionRegistryFileForTest,
   _resetSessionToolsFileForTest,
   _setAdapterForToolForTest,
@@ -74,10 +74,10 @@ import {
   _setSessionToolsFileForTest,
   loadSessionRegistryForBinding,
   recordSessionRegistry,
-  resetState,
-} from "../session.ts";
-import { activePrompts, resetBindingState } from "../session-chat-binding.ts";
-import { ABD_APPEND_PROMPT } from "../shared-prefix.ts";
+  resetState,
+} from "../session.ts";
+import { activePrompts, resetBindingState } from "../session-chat-binding.ts";
+import { ABD_APPEND_PROMPT } from "../shared-prefix.ts";
 
 function mockPlatform(kind: "wechat" | "feishu" = "wechat"): PlatformAdapter {
   return {
@@ -132,6 +132,8 @@ describe("handleCommand WeChat processing ack", () => {
     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",
@@ -198,8 +200,8 @@ describe("handleCommand WeChat processing ack", () => {
     expect(platform.sendCard).not.toHaveBeenCalled();
   });
 
-  it("sends the WeChat processing ack after the busy check for normal prompts", async () => {
-    const platform = mockPlatform();
+  it("sends the WeChat processing ack after the busy check for normal prompts", async () => {
+    const platform = mockPlatform();
     await recordSessionRegistry({
       chatId: "wx-chat",
       sessionId: "sid-wechat",
@@ -209,44 +211,44 @@ describe("handleCommand WeChat processing ack", () => {
     });
 
     await handleCommand(platform, "继续说明", "wx-chat", "wx-user", Date.now(), "p2p");
-
-    expect(platform.sendText).toHaveBeenCalledWith("wx-chat", "生成中...");
-  });
-
-  it("treats /abd as a shared prompt prefix in an existing session", async () => {
-    const platform = mockPlatform();
-    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-wechat" })),
-      prompt,
-      getSessionInfo: async (sessionId: string): Promise<SessionInfo> => ({
-        sessionId,
-        cwd: "F:\\repo",
-      }),
-      closeSession: async () => {},
-    });
-    await recordSessionRegistry({
-      chatId: "wx-chat",
-      sessionId: "sid-wechat",
-      tool: "claude",
-      chatName: "ready-session",
-      running: false,
-    });
-
-    await handleCommand(platform, "/abd帮我分析", "wx-chat", "wx-user", Date.now(), "p2p");
-
-    expect(platform.sendText).toHaveBeenCalledWith("wx-chat", "生成中...");
-    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");
-  });
+
+    expect(platform.sendText).toHaveBeenCalledWith("wx-chat", "生成中...");
+  });
+
+  it("treats /abd as a shared prompt prefix in an existing session", async () => {
+    const platform = mockPlatform();
+    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-wechat" })),
+      prompt,
+      getSessionInfo: async (sessionId: string): Promise<SessionInfo> => ({
+        sessionId,
+        cwd: "F:\\repo",
+      }),
+      closeSession: async () => {},
+    });
+    await recordSessionRegistry({
+      chatId: "wx-chat",
+      sessionId: "sid-wechat",
+      tool: "claude",
+      chatName: "ready-session",
+      running: false,
+    });
+
+    await handleCommand(platform, "/abd帮我分析", "wx-chat", "wx-user", Date.now(), "p2p");
+
+    expect(platform.sendText).toHaveBeenCalledWith("wx-chat", "生成中...");
+    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("does not send the stopped success text until the running prompt really exits", async () => {
     const platform = mockPlatform();
@@ -268,7 +270,7 @@ 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 () => {
+  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) {
       yield {
@@ -313,40 +315,40 @@ describe("handleCommand WeChat processing ack", () => {
 
     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) {
-      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" })),
-      prompt,
-      getSessionInfo: async (sessionId: string): Promise<SessionInfo> => ({
-        sessionId,
-        cwd: "F:\\repo",
-      }),
-      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");
-  });
+    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) {
+      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" })),
+      prompt,
+      getSessionInfo: async (sessionId: string): Promise<SessionInfo> => ({
+        sessionId,
+        cwd: "F:\\repo",
+      }),
+      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");
@@ -371,47 +373,31 @@ describe("handleCommand WeChat processing ack", () => {
     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" },
+      ],
     });
 
     await handleCommand(platform, "/usage", "feishu-p2p", "ou-user", Date.now(), "p2p");
 
     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",
-    );
+    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 () => {
@@ -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/__tests__/shared-prefix.test.ts

@@ -1,36 +1,36 @@
-import { describe, expect, it } from "vitest";
-
-import {
-  ABD_APPEND_PROMPT,
-  applySharedPrefix,
-} from "../shared-prefix.ts";
-
-describe("applySharedPrefix", () => {
-  it("leaves normal messages unchanged", () => {
-    expect(applySharedPrefix("帮我分析")).toEqual({
-      matched: false,
-      text: "帮我分析",
-      body: "帮我分析",
-    });
-  });
-
-  it("removes /abd without requiring a space", () => {
-    const result = applySharedPrefix("/abd帮我分析");
-
-    expect(result.matched).toBe(true);
-    expect(result.body).toBe("帮我分析");
-    expect(result.text).toBe(`帮我分析\n\n---\n${ABD_APPEND_PROMPT}`);
-  });
-
-  it("removes whitespace after /abd", () => {
-    const result = applySharedPrefix("/abd   帮我分析");
-
-    expect(result.text).toBe(`帮我分析\n\n---\n${ABD_APPEND_PROMPT}`);
-  });
-
-  it("keeps the appendix when the user body is empty", () => {
-    const result = applySharedPrefix("/abd   ");
-
-    expect(result.text).toBe(`---\n${ABD_APPEND_PROMPT}`);
-  });
-});
+import { describe, expect, it } from "vitest";
+
+import {
+  ABD_APPEND_PROMPT,
+  applySharedPrefix,
+} from "../shared-prefix.ts";
+
+describe("applySharedPrefix", () => {
+  it("leaves normal messages unchanged", () => {
+    expect(applySharedPrefix("帮我分析")).toEqual({
+      matched: false,
+      text: "帮我分析",
+      body: "帮我分析",
+    });
+  });
+
+  it("removes /abd without requiring a space", () => {
+    const result = applySharedPrefix("/abd帮我分析");
+
+    expect(result.matched).toBe(true);
+    expect(result.body).toBe("帮我分析");
+    expect(result.text).toBe(`帮我分析\n\n---\n${ABD_APPEND_PROMPT}`);
+  });
+
+  it("removes whitespace after /abd", () => {
+    const result = applySharedPrefix("/abd   帮我分析");
+
+    expect(result.text).toBe(`帮我分析\n\n---\n${ABD_APPEND_PROMPT}`);
+  });
+
+  it("keeps the appendix when the user body is empty", () => {
+    const result = applySharedPrefix("/abd   ");
+
+    expect(result.text).toBe(`---\n${ABD_APPEND_PROMPT}`);
+  });
+});

package/src/cards.ts

@@ -1,10 +1,10 @@
-// ---------------------------------------------------------------------------
-// Button helpers
-// ---------------------------------------------------------------------------
-
-import { ABD_HELP_LINE } from "./shared-prefix.ts";
-
-export interface ButtonDef {
+// ---------------------------------------------------------------------------
+// Button helpers
+// ---------------------------------------------------------------------------
+
+import { ABD_HELP_LINE } from "./shared-prefix.ts";
+
+export interface ButtonDef {
   text: string;
   value: string;
   type?: "primary" | "default" | "danger";
@@ -137,11 +137,11 @@ export function buildHelpCard(
     "发送 **/newh** 重置当前会话（沿用当前工作目录，不切换）",
     "发送 **/plan** 以规划模式提问（只读，不执行写操作）",
     "发送 **/ask** 以问答模式提问（只读，不执行写操作）",
-    "发送 **/usage** 查看 Codex 5h 和周用量",
-    "发送 **/restart** 重启 ChatCCC 进程",
-    "发送 **/update** 更新并重启（仅 npm 全局安装可用）",
-    ABD_HELP_LINE,
-  ].join("\n");
+    "发送 **/usage** 查看 Codex 5h/周用量，以及查询/使用主动重置卡",
+    "发送 **/restart** 重启 ChatCCC 进程",
+    "发送 **/update** 更新并重启（仅 npm 全局安装可用）",
+    ABD_HELP_LINE,
+  ].join("\n");
   return JSON.stringify({
     config: { wide_screen_mode: true },
     header: { template: "blue", title: { content: "ChatCCC", tag: "plain_text" } },
@@ -430,6 +430,72 @@ export function buildStatusCard(statusText: string, template = "blue"): string {
   });
 }
 
+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,

package/src/codex-reset-actions.ts

@@ -0,0 +1,171 @@
+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>;
+  sendCardReply(token: string, chatId: string, title: string, content: string, template?: string): Promise<boolean>;
+  updateCardMessage(token: string, messageId: string, content: 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
+      : "";
+}
+
+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) {
+    await deps.updateCardMessage(token, confirmMessageId, collapsedCard());
+  }
+
+  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.sendCardReply(token, chatId, "Codex 主动重置", "这张确认卡片已经失效或已处理。", "yellow");
+    return true;
+  }
+  pending.status = "handled";
+
+  if (decision === "no") {
+    await deps.sendCardReply(token, chatId, "Codex 主动重置", "用户取消了重置。", "grey");
+    return true;
+  }
+
+  try {
+    const result = await deps.consumeCodexRateLimitResetCredit(requestId);
+    const message = resetResultMessage(result);
+    await deps.sendCardReply(token, chatId, "Codex 主动重置", message.content, message.template);
+  } catch (err) {
+    await deps.sendCardReply(token, chatId, "Codex 主动重置", `重置失败：${(err as Error).message}`, "red");
+  }
+  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();
+}