chatccc 0.2.179 → 0.2.181

package/src/__tests__/orchestrator.test.ts

@@ -77,6 +77,7 @@ import {
   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 {
@@ -131,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",
@@ -212,6 +215,41 @@ describe("handleCommand WeChat processing ack", () => {
     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();
     await recordSessionRegistry({
@@ -280,6 +318,38 @@ describe("handleCommand WeChat processing ack", () => {
     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");
     await recordSessionRegistry({
@@ -303,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 () => {
@@ -384,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

@@ -0,0 +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}`);
+  });
+});

package/src/cards.ts

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

package/src/feishu-api.ts

@@ -304,6 +304,8 @@ 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_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"),
@@ -327,9 +329,23 @@ export interface CodexUsageBalance {
   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>();
@@ -421,35 +437,109 @@ function parseOptionalUsageWindow(rateLimit: Record<string, unknown>, keys: stri
   return null;
 }
 
-async function getCodexAccessToken(): Promise<string | 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 } };
+    const parsed = JSON.parse(raw) as { tokens?: { access_token?: unknown; account_id?: unknown } };
     const token = parsed.tokens?.access_token;
-    return typeof token === "string" && token.trim() ? token : null;
+    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 token = await getCodexAccessToken();
-  if (!token) throw new Error("missing ~/.codex/auth.json access token");
+  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 ${token}` },
+    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,
@@ -459,6 +549,41 @@ export async function getCodexUsageSummary(): Promise<CodexUsageSummary> {
       "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,
   };
 }