@narumitw/pi-usage 0.63.1 → 0.64.1

package/docs/providers.md

@@ -17,6 +17,7 @@ The README contains the capability overview and shared security requirements.
 - [Vercel AI Gateway](#vercel-ai-gateway-credits)
 - [Baseten](#baseten-model-apis-spend)
 - [OpenCode Go](#opencode-go-zen)
+- [Command Code](#command-code)
 - [xAI](#xai-consumer-subscriptions)
 - [Z.AI](#zai-glm-coding-plan)
 
@@ -265,6 +266,24 @@ The fixed endpoint is queried only when the OpenCode Go model uses the official
 When resolved provider auth includes a base URL, that URL must use the same origin.
 Other origins fail before the credential is sent.
 
+### Command Code
+
+- Provider ID: `command-code`
+- Semantics: plan credits plus rolling 5-hour and weekly spending caps
+- Account route: `GET https://api.commandcode.ai/alpha/whoami`
+- Credits route: `GET https://api.commandcode.ai/alpha/billing/credits`
+- Plan route: `GET https://api.commandcode.ai/alpha/billing/subscriptions`
+- Period route: `GET https://api.commandcode.ai/alpha/usage/summary`
+- Displayed data: five-hour and weekly spend caps in USD with reset times, the billing-period credit pool and remaining balance, plan name and status, request and token totals, and purchased or free credits when present
+- Statusline examples: `cmd 99% 5h 92% wk 96% mo`
+
+The official `@commandcode/pi-commandcode-provider` extension registers this provider through `pi.registerProvider()`, so `command-code` is not a Pi built-in provider.
+Pi still resolves its stored `/login` API key through the normal provider registry, and the extension sends it as Bearer authorization only when the selected model and resolved auth share the official `https://api.commandcode.ai` origin.
+`credits.monthlyCredits`, `purchasedCredits`, and `freeCredits` are remaining amounts, so the billing-period pool is their sum plus `usage/summary.totalCost`, and `windowLimits.*.resetAt` is a millisecond epoch.
+The account response is required; the credits, plan, and period responses degrade to individual notes when unavailable, and a plan without rolling limits reports that instead of inventing windows.
+These are undocumented Command Code endpoints pinned on 2026-09-29 against live responses and the same routes the Command Code CLI `/usage` command reads.
+They may change without notice, and this paragraph is the contract evidence for the reviewed behavior.
+
 ### xAI consumer subscriptions
 
 - Provider ID: `xai`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@narumitw/pi-usage",
-  "version": "0.63.1",
+  "version": "0.64.1",
   "description": "Pi extension that shows current-account usage and DeepSeek API balance for supported providers.",
   "type": "module",
   "license": "MIT",
@@ -17,6 +17,7 @@
     "baseten",
     "vercel-ai-gateway",
     "codex",
+    "command-code",
     "kimi",
     "kimi-coding",
     "moonshot",

package/src/format.ts

@@ -37,6 +37,7 @@ export function formatUsageReport(report: UsageReport, displayState: UsageDispla
   else if (report.providerId === "github-copilot") formatGitHubCopilotReport(lines, report);
   else if (report.providerId === "openrouter") formatOpenRouterReport(lines, report);
   else if (report.providerId === "opencode-go") formatOpenCodeZenReport(lines, report);
+  else if (report.providerId === "command-code") formatCommandCodeReport(lines, report);
   else if (report.providerId === "kimi-coding") formatKimiCodingReport(lines, report);
   else if (report.providerId === "moonshotai" || report.providerId === "moonshotai-cn") {
     formatMoonshotReport(lines, report);
@@ -86,6 +87,7 @@ export function formatUsageStatusline(
     if (typeof total?.value === "number") return `openrouter ${formatUsd(total.value)} used`;
   }
   if (report.providerId === "opencode-go") return formatOpenCodeZenStatusline(report);
+  if (report.providerId === "command-code") return formatCommandCodeStatusline(report);
   if (report.providerId === "kimi-coding") return formatKimiCodingStatusline(report);
   if (report.providerId === "moonshotai" || report.providerId === "moonshotai-cn") {
     return formatMoonshotStatusline(report);
@@ -293,6 +295,36 @@ function formatOpenCodeZenStatusline(report: UsageReport): string | undefined {
   return parts.length > 1 ? parts.join(" ") : undefined;
 }
 
+function formatCommandCodeReport(lines: string[], report: UsageReport): void {
+  for (const bucket of report.buckets) {
+    const reset = bucket.resetsAt ? ` (resets ${formatReset(bucket.resetsAt)})` : "";
+    if (bucket.used === undefined || bucket.limit === undefined) {
+      lines.push(`${`${bucket.label}:`.padEnd(VALUE_COLUMN)}unavailable${reset}`);
+      continue;
+    }
+    lines.push(
+      `${`${bucket.label}:`.padEnd(VALUE_COLUMN)}${formatUsd(bucket.used)} of ${formatUsd(bucket.limit)} used · ${percentRemaining(bucket)}% left${reset}`,
+    );
+  }
+  for (const metric of report.metrics) {
+    lines.push(`${`${metric.label}:`.padEnd(VALUE_COLUMN)}${formatMetricValue(metric.value, metric.unit)}`);
+  }
+}
+
+function formatCommandCodeStatusline(report: UsageReport): string | undefined {
+  const parts = ["cmd"];
+  for (const [id, label] of [
+    ["five-hour", "5h"],
+    ["weekly", "wk"],
+    ["monthly", "mo"],
+  ] as const) {
+    const bucket = report.buckets.find((candidate) => candidate.id === id);
+    if (bucket?.unit !== "usd" || bucket.limit === undefined || bucket.remaining === undefined) continue;
+    parts.push(`${percentRemaining(bucket)}% ${label}`);
+  }
+  return parts.length > 1 ? parts.join(" ") : undefined;
+}
+
 function formatKimiCodingReport(lines: string[], report: UsageReport): void {
   for (const bucket of report.buckets) {
     const reset = bucket.resetsAt ? ` (resets ${formatReset(bucket.resetsAt)})` : "";

package/src/index.ts

@@ -34,6 +34,7 @@ export {
 export { formatProviderStates, formatUsageReport, formatUsageStatusline } from "./format.js";
 export { normalizeBasetenBillingUsagePayload } from "./providers/baseten.js";
 export { normalizeCodexBackendPayload } from "./providers/codex.js";
+export { commandCodeOrgId, normalizeCommandCodeUsagePayload } from "./providers/command-code.js";
 export { normalizeDeepSeekBalancePayload } from "./providers/deepseek.js";
 export {
   createFireworksAdapter,
@@ -80,6 +81,11 @@ export {
 } from "./settings.js";
 export type {
   BasetenBillingUsagePayload,
+  CommandCodeAccountPayload,
+  CommandCodeCreditsPayload,
+  CommandCodeSubscriptionPayload,
+  CommandCodeUsageBundle,
+  CommandCodeUsageSummaryPayload,
   DeepSeekBalancePayload,
   FireworksAccountsPayload,
   FireworksBillingSummaryPayload,

package/src/providers/command-code.ts

@@ -0,0 +1,228 @@
+import { sanitizeDisplayText } from "../core.js";
+import type {
+  CommandCodeAccountPayload,
+  CommandCodeUsageBundle,
+  UsageBucket,
+  UsageMetric,
+  UsageReport,
+} from "../types.js";
+
+const FIVE_HOUR_WINDOW_MINUTES = 300;
+const WEEKLY_WINDOW_MINUTES = 10_080;
+const IDENTIFIER_PATTERN = /^[A-Za-z0-9._~-]{1,128}$/u;
+const MILLISECOND_EPOCH_FLOOR = 1e12;
+const WINDOWS = [
+  { key: "fiveHour", id: "five-hour", label: "Five-hour window", windowMinutes: FIVE_HOUR_WINDOW_MINUTES },
+  { key: "weekly", id: "weekly", label: "Weekly window", windowMinutes: WEEKLY_WINDOW_MINUTES },
+] as const;
+const PLAN_LABELS: Readonly<Record<string, string>> = {
+  "individual-go": "Go",
+  "individual-goat": "GOAT",
+  "individual-pro": "Pro",
+  "individual-provider": "Provider",
+  "individual-max": "Max",
+  "individual-ultra": "Ultra",
+};
+
+export function commandCodeOrgId(account: CommandCodeAccountPayload): string | undefined {
+  const id = asObject(account.org)?.id;
+  return typeof id === "string" && IDENTIFIER_PATTERN.test(id) ? id : undefined;
+}
+
+/**
+ * Source contract observed live on 2026-09-29. Command Code serves the account, credits, plan,
+ * and billing-period usage that its CLI `/usage` command displays from the undocumented
+ * `https://api.commandcode.ai/alpha/*` endpoints, authenticated with the same Bearer API key Pi
+ * stores for the `command-code` provider. `resetAt` is a millisecond epoch, plan credits and
+ * rolling-window caps are USD-denominated, and `org` may be `null` for a personal account.
+ * `credits.monthlyCredits`, `purchasedCredits`, and `freeCredits` are remaining amounts, so the
+ * billing-period pool is their sum plus `usage/summary.totalCost`.
+ */
+export function normalizeCommandCodeUsagePayload(bundle: CommandCodeUsageBundle, capturedAt: number): UsageReport {
+  const account = asObject(bundle.account);
+  const user = asObject(account?.user);
+  const accountLabel = asString(user?.userName) ?? asString(user?.name);
+  if (!accountLabel) {
+    throw new Error("Command Code account response omitted a safe account name.");
+  }
+
+  const creditsPayload = asObject(bundle.credits);
+  const credits = asObject(creditsPayload?.credits);
+  const windowLimits = asObject(creditsPayload?.windowLimits);
+  const subscription = asObject(asObject(bundle.subscription)?.data);
+  const usage = asObject(bundle.usage);
+
+  const buckets: UsageBucket[] = [];
+  for (const window of WINDOWS) {
+    const bucket = parseWindow(windowLimits?.[window.key], window);
+    if (bucket) buckets.push(bucket);
+  }
+
+  const totalCost = asNonnegativeNumber(usage?.totalCost);
+  const remainingCredits = commandCodeRemainingCredits(credits);
+  const monthlyReset = asIsoEpochSeconds(subscription?.currentPeriodEnd);
+  if (totalCost !== undefined && remainingCredits !== undefined) {
+    const pool = totalCost + remainingCredits;
+    if (pool > 0) {
+      buckets.push({
+        id: "monthly",
+        label: "Monthly credits",
+        used: totalCost,
+        remaining: remainingCredits,
+        limit: pool,
+        unit: "usd",
+        period: "billing-period",
+        ...(monthlyReset !== undefined ? { resetsAt: monthlyReset } : {}),
+      });
+    }
+  }
+
+  const metrics: UsageMetric[] = [];
+  const plan = planLabel(subscription?.planId);
+  const planStatus = asString(subscription?.status, 40);
+  if (plan || planStatus) {
+    metrics.push({
+      id: "plan",
+      label: "Plan",
+      value: [plan, planStatus ? `(${planStatus})` : undefined].filter(Boolean).join(" "),
+    });
+  }
+  if (buckets.every((bucket) => bucket.id !== "monthly")) {
+    if (remainingCredits !== undefined) {
+      metrics.push({
+        id: "monthly-credits",
+        label: "Monthly credits remaining",
+        value: remainingCredits,
+        unit: "usd",
+      });
+    } else if (totalCost !== undefined) {
+      metrics.push({ id: "period-cost", label: "Cost this billing period", value: totalCost, unit: "usd" });
+    }
+  }
+  const purchased = asNonnegativeNumber(credits?.purchasedCredits);
+  if (purchased) {
+    metrics.push({ id: "purchased-credits", label: "Purchased credits remaining", value: purchased, unit: "usd" });
+  }
+  const free = asNonnegativeNumber(credits?.freeCredits);
+  if (free) {
+    metrics.push({ id: "free-credits", label: "Free credits remaining", value: free, unit: "usd" });
+  }
+  const totalCount = asNonnegativeNumber(usage?.totalCount);
+  if (totalCount !== undefined) {
+    metrics.push({ id: "requests", label: "Requests this period", value: totalCount, unit: "count" });
+  }
+  const totalTokens = asNonnegativeNumber(usage?.totalTokens);
+  if (totalTokens !== undefined) {
+    metrics.push({ id: "tokens", label: "Tokens this period", value: totalTokens, unit: "count" });
+  } else {
+    const tokensIn = asNonnegativeNumber(usage?.totalTokensIn);
+    const tokensOut = asNonnegativeNumber(usage?.totalTokensOut);
+    if (tokensIn !== undefined) {
+      metrics.push({ id: "tokens-in", label: "Input tokens", value: tokensIn, unit: "count" });
+    }
+    if (tokensOut !== undefined) {
+      metrics.push({ id: "tokens-out", label: "Output tokens", value: tokensOut, unit: "count" });
+    }
+  }
+
+  const notes: string[] = [];
+  if (!creditsPayload) notes.push("Command Code credits were unavailable.");
+  else if (windowLimits?.limited === false) {
+    notes.push("Rolling 5-hour and weekly limits are not enabled for this plan.");
+  }
+  if (!subscription) notes.push("Command Code plan details were unavailable.");
+  if (!usage) notes.push("Command Code billing-period usage was unavailable.");
+
+  if (buckets.length === 0 && metrics.length === 0) {
+    throw new Error("Command Code usage response returned no displayable usage data.");
+  }
+
+  return {
+    providerId: "command-code",
+    providerName: "Command Code",
+    capturedAt,
+    source: "command-code-alpha-usage",
+    semantics: { kind: "consumer-subscription", label: "Command Code plan credits and rolling limits" },
+    accountLabel,
+    buckets,
+    metrics,
+    ...(notes.length > 0 ? { notes } : {}),
+  };
+}
+
+function parseWindow(value: unknown, window: (typeof WINDOWS)[number]): UsageBucket | undefined {
+  const row = asObject(value);
+  if (!row) return undefined;
+  const used = asNonnegativeNumber(row.used);
+  const cap = asNonnegativeNumber(row.cap);
+  if (used === undefined || cap === undefined || cap <= 0) return undefined;
+  const resetsAt = asMillisecondEpochSeconds(row.resetAt);
+  return {
+    id: window.id,
+    label: window.label,
+    used,
+    remaining: Math.max(0, cap - used),
+    limit: cap,
+    unit: "usd",
+    windowMinutes: window.windowMinutes,
+    ...(resetsAt !== undefined ? { resetsAt } : {}),
+  };
+}
+
+function commandCodeRemainingCredits(credits: Record<string, unknown> | undefined): number | undefined {
+  if (!credits) return undefined;
+  const parts = ["monthlyCredits", "purchasedCredits", "freeCredits"]
+    .map((key) => asNonnegativeNumber(credits[key]))
+    .filter((value): value is number => value !== undefined);
+  if (parts.length === 0) return undefined;
+  return parts.reduce((total, value) => total + value, 0);
+}
+
+function planLabel(value: unknown): string | undefined {
+  const raw = asString(value, 40);
+  if (!raw) return undefined;
+  const known = PLAN_LABELS[raw];
+  if (known) return known;
+  const words = raw
+    .replace(/^individual[-_]/u, "")
+    .replace(/[-_]+/gu, " ")
+    .trim();
+  return words ? capitalize(words) : raw;
+}
+
+function asObject(value: unknown): Record<string, unknown> | undefined {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+  return value as Record<string, unknown>;
+}
+
+function asString(value: unknown, maxLength = 80): string | undefined {
+  if (typeof value !== "string") return undefined;
+  return sanitizeDisplayText(value, maxLength) || undefined;
+}
+
+function asNonnegativeNumber(value: unknown): number | undefined {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return undefined;
+  return value;
+}
+
+function asIsoEpochSeconds(value: unknown): number | undefined {
+  if (typeof value !== "string" || !value.trim()) return undefined;
+  const parsed = Date.parse(value);
+  if (Number.isNaN(parsed)) return undefined;
+  return Math.floor(parsed / 1000);
+}
+
+function asMillisecondEpochSeconds(value: unknown): number | undefined {
+  const raw =
+    typeof value === "number" && Number.isFinite(value)
+      ? value
+      : typeof value === "string" && /^\d+$/u.test(value.trim())
+        ? Number(value.trim())
+        : undefined;
+  if (raw === undefined || raw < 0) return undefined;
+  return Math.floor(raw >= MILLISECOND_EPOCH_FLOOR ? raw / 1000 : raw);
+}
+
+function capitalize(value: string): string {
+  return `${value[0]?.toUpperCase() ?? ""}${value.slice(1)}`;
+}

package/src/query.ts

@@ -2,10 +2,11 @@
 // separating that security boundary would duplicate request and redaction policy across providers.
 import { randomBytes } from "node:crypto";
 import { type ExtensionContext, readStoredCredential } from "@earendil-works/pi-coding-agent";
-import { errorMessage, fingerprintResolvedAuth, redactUsageError } from "./core.js";
+import { abortError, errorMessage, fingerprintResolvedAuth, redactUsageError } from "./core.js";
 import { fallbackOAuthCredentialCandidates, type OAuthCredentialCandidateReader } from "./oauth-credential-source.js";
 import { normalizeBasetenBillingUsagePayload } from "./providers/baseten.js";
 import { normalizeCodexBackendPayload } from "./providers/codex.js";
+import { commandCodeOrgId, normalizeCommandCodeUsagePayload } from "./providers/command-code.js";
 import { normalizeDeepSeekBalancePayload } from "./providers/deepseek.js";
 import { createFireworksAdapter } from "./providers/fireworks.js";
 import { normalizeGitHubCopilotUsagePayload } from "./providers/github-copilot.js";
@@ -26,6 +27,11 @@ import { zaiResponseError } from "./providers/zai-errors.js";
 import type {
   BasetenBillingUsagePayload,
   CodexBackendPayload,
+  CommandCodeAccountPayload,
+  CommandCodeCreditsPayload,
+  CommandCodeSubscriptionPayload,
+  CommandCodeUsageBundle,
+  CommandCodeUsageSummaryPayload,
   DeepSeekBalancePayload,
   GitHubCopilotUsagePayload,
   KimiCodingUsagePayload,
@@ -51,6 +57,11 @@ import { resolveUsageTarget } from "./usage-targets.js";
 const BASETEN_BILLING_USAGE_URL = "https://api.baseten.co/v1/billing/usage_summary";
 const BASETEN_USAGE_WINDOW_DAYS = 30;
 const CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
+const COMMAND_CODE_API_ORIGIN = "https://api.commandcode.ai";
+const COMMAND_CODE_ACCOUNT_URL = `${COMMAND_CODE_API_ORIGIN}/alpha/whoami`;
+const COMMAND_CODE_CREDITS_URL = `${COMMAND_CODE_API_ORIGIN}/alpha/billing/credits`;
+const COMMAND_CODE_SUBSCRIPTIONS_URL = `${COMMAND_CODE_API_ORIGIN}/alpha/billing/subscriptions`;
+const COMMAND_CODE_USAGE_SUMMARY_URL = `${COMMAND_CODE_API_ORIGIN}/alpha/usage/summary`;
 const DEEPSEEK_BALANCE_URL = "https://api.deepseek.com/user/balance";
 const GITHUB_COPILOT_USAGE_URL = "https://api.github.com/copilot_internal/user";
 const OPENROUTER_KEY_URL = "https://openrouter.ai/api/v1/key";
@@ -181,6 +192,63 @@ export const SUPPORTED_ADAPTERS: readonly UsageProviderAdapter[] = [
       return normalizeVercelAIGatewayCreditsPayload(payload, Date.now());
     },
   },
+  {
+    id: "command-code",
+    displayName: "Command Code",
+    semantics: { kind: "consumer-subscription", label: "Command Code plan credits and rolling limits" },
+    async query(auth, signal, timeoutMs, guard) {
+      if (!guard) throw new Error("Command Code usage requires request-boundary revalidation.");
+      const startedAt = Date.now();
+      await guard();
+      const account = (await fetchProviderJson(
+        COMMAND_CODE_ACCOUNT_URL,
+        auth,
+        signal,
+        remainingTimeout(timeoutMs, startedAt, "fetching the Command Code account"),
+        "Command Code account endpoint",
+        { redirect: "error" },
+      )) as CommandCodeAccountPayload;
+      await guard();
+      const orgId = commandCodeOrgId(account);
+      const [credits, subscription] = await Promise.all([
+        fetchCommandCodeOptional(
+          commandCodeUrl(COMMAND_CODE_CREDITS_URL, { orgId }),
+          auth,
+          signal,
+          timeoutMs - (Date.now() - startedAt),
+          "Command Code credits endpoint",
+        ),
+        fetchCommandCodeOptional(
+          commandCodeUrl(COMMAND_CODE_SUBSCRIPTIONS_URL, { orgId }),
+          auth,
+          signal,
+          timeoutMs - (Date.now() - startedAt),
+          "Command Code plan endpoint",
+        ),
+      ]);
+      await guard();
+      const usage = await fetchCommandCodeOptional(
+        commandCodeUrl(COMMAND_CODE_USAGE_SUMMARY_URL, {
+          orgId,
+          since: commandCodeSubscriptionStart(subscription),
+        }),
+        auth,
+        signal,
+        timeoutMs - (Date.now() - startedAt),
+        "Command Code usage summary endpoint",
+      );
+      await guard();
+      if (signal.aborted) throw abortError();
+      // The account response is mandatory; the credits, plan, and period payloads degrade to notes.
+      const bundle: CommandCodeUsageBundle = {
+        account,
+        ...(credits ? { credits: credits as CommandCodeCreditsPayload } : {}),
+        ...(subscription ? { subscription: subscription as CommandCodeSubscriptionPayload } : {}),
+        ...(usage ? { usage: usage as CommandCodeUsageSummaryPayload } : {}),
+      };
+      return normalizeCommandCodeUsagePayload(bundle, Date.now());
+    },
+  },
   createFireworksAdapter(fetchProviderJson),
   {
     id: "opencode-go",
@@ -923,6 +991,7 @@ function hasOfficialUrlOrigin(value: string, providerId: string): boolean {
     }
     if (providerId === "openai") return url.origin === "https://api.openai.com";
     if (providerId === "openai-codex") return url.origin === "https://chatgpt.com";
+    if (providerId === "command-code") return url.origin === COMMAND_CODE_API_ORIGIN;
     if (providerId === "deepseek") return url.origin === "https://api.deepseek.com";
     if (providerId === "fireworks") return url.origin === "https://api.fireworks.ai";
     if (providerId === "openrouter") return url.origin === "https://openrouter.ai";
@@ -1096,3 +1165,40 @@ async function fetchZaiPlan(
 function isAbortError(error: unknown): boolean {
   return error instanceof Error && error.name === "AbortError";
 }
+
+async function fetchCommandCodeOptional(
+  url: string,
+  auth: ResolvedUsageAuth,
+  signal: AbortSignal,
+  timeoutMs: number,
+  description: string,
+): Promise<Record<string, unknown> | undefined> {
+  if (signal.aborted) throw abortError();
+  // Optional sections must not discard collected data when an earlier request used the budget.
+  if (timeoutMs <= 0) return undefined;
+  try {
+    const payload = await fetchProviderJson(url, auth, signal, timeoutMs, description, { redirect: "error" });
+    if (signal.aborted) throw abortError();
+    return payload;
+  } catch (error) {
+    if (signal.aborted) throw abortError();
+    if (isAbortError(error) || isStaleExtensionContextError(error)) throw error;
+    return undefined;
+  }
+}
+
+function commandCodeUrl(base: string, params: Record<string, string | undefined>): string {
+  const query = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value) query.set(key, value);
+  }
+  const search = query.toString();
+  return search ? `${base}?${search}` : base;
+}
+
+function commandCodeSubscriptionStart(subscription: Record<string, unknown> | undefined): string | undefined {
+  const data = subscription?.data;
+  if (!data || typeof data !== "object" || Array.isArray(data)) return undefined;
+  const value = (data as Record<string, unknown>).currentPeriodStart;
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}

package/src/types.ts

@@ -238,3 +238,32 @@ export type CodexBackendPayload = {
   credits?: unknown;
   rate_limit_reset_credits?: unknown;
 };
+
+export type CommandCodeAccountPayload = {
+  user?: unknown;
+  org?: unknown;
+};
+
+export type CommandCodeCreditsPayload = {
+  credits?: unknown;
+  windowLimits?: unknown;
+};
+
+export type CommandCodeSubscriptionPayload = {
+  data?: unknown;
+};
+
+export type CommandCodeUsageSummaryPayload = {
+  totalCost?: unknown;
+  totalCount?: unknown;
+  totalTokens?: unknown;
+  totalTokensIn?: unknown;
+  totalTokensOut?: unknown;
+};
+
+export interface CommandCodeUsageBundle {
+  account: CommandCodeAccountPayload;
+  credits?: CommandCodeCreditsPayload;
+  subscription?: CommandCodeSubscriptionPayload;
+  usage?: CommandCodeUsageSummaryPayload;
+}

package/src/usage.ts

@@ -50,6 +50,7 @@ import { createUsageTargetSelectOptions, listUsageTargets, resolveUsageTarget }
 const CACHE_TTL_MS = 5 * 60 * 1000;
 const STATUS_COUNTDOWN_REFRESH_MS = 60 * 1000;
 const DEFAULT_TIMEOUT_MS = 15_000;
+const COMMAND_CODE_REVALIDATION_RESERVE_MS = 1_000;
 const ALL_PROVIDER_CONCURRENCY = 2;
 const FAILURE_BACKOFF_MS = 30_000;
 const MAX_ACCOUNT_STATES = 32;
@@ -177,6 +178,7 @@ export default function usageExtension(pi: ExtensionAPI, dependencies: UsageExte
     const settings = settingsRuntime.get().settings;
     const showCodexResetCountdown =
       outcome.state.report.providerId === "openai-codex" && settings.codexStatusResetCountdown;
+    const isCompanionReport = outcome.state.report.source === "openai-chatgpt-companion";
     const now = Date.now();
     const rawValue = formatUsageStatusline(
       outcome.state.report,
@@ -190,9 +192,13 @@ export default function usageExtension(pi: ExtensionAPI, dependencies: UsageExte
     if (shouldSchedule && sessionActive) scheduleStatusRefresh(ctx, model);
     if (
       sessionActive &&
-      (showCodexResetCountdown || outcome.state.report.source === "openai-chatgpt-companion") &&
+      (showCodexResetCountdown || isCompanionReport) &&
       outcome.state.report.buckets.some(
-        (bucket) => bucket.resetsAt !== undefined && Number.isFinite(bucket.resetsAt) && bucket.resetsAt * 1_000 > now,
+        (bucket) =>
+          (!isCompanionReport || bucket.groupId === "chatgpt-plan") &&
+          bucket.resetsAt !== undefined &&
+          Number.isFinite(bucket.resetsAt) &&
+          bucket.resetsAt * 1_000 > now,
       )
     ) {
       const generation = statusGeneration;
@@ -277,6 +283,7 @@ export default function usageExtension(pi: ExtensionAPI, dependencies: UsageExte
       adapter.targets !== undefined ||
       [
         "baseten",
+        "command-code",
         "deepseek",
         "minimax",
         "minimax-cn",
@@ -414,11 +421,17 @@ export default function usageExtension(pi: ExtensionAPI, dependencies: UsageExte
       querySequence += 1;
       queryId = querySequence;
       setBoundedMap(latestQueries, failureKey, queryId, MAX_ACCOUNT_STATES);
+      // Command Code can retain partial data after an optional transport timeout. Keep time
+      // inside the overall deadline for its remaining auth guards and publication guard.
+      const queryTimeoutMs = Math.max(
+        1,
+        deadlineAt - Date.now() - (adapter.id === "command-code" ? COMMAND_CODE_REVALIDATION_RESERVE_MS : 0),
+      );
       const report = await queryProviderUsage(
         adapter,
         auth,
         signal,
-        Math.max(1, deadlineAt - Date.now()),
+        queryTimeoutMs,
         requiresRequestBoundaryGuard ? guard : undefined,
         target.targetId,
       );