@oh-my-pi/pi-ai 17.2.11 → 17.2.13

package/src/usage/claude.ts

@@ -17,10 +17,9 @@ import {
 	type UsageWindow,
 } from "../usage";
 import { isRecord } from "../utils";
+import { HOUR_MS, parseIsoTimestamp, WEEK_MS } from "./shared";
 
 const DEFAULT_ENDPOINT = "https://api.anthropic.com/api/oauth";
-const FIVE_HOURS_MS = 5 * 60 * 60 * 1000;
-const SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
 const MAX_ATTEMPTS = 3;
 const BASE_RETRY_DELAY_MS = 500;
 
@@ -123,16 +122,10 @@ interface ParsedApiLimitEntry {
 	displayName?: string;
 }
 
-function parseIsoTime(value: string | undefined): number | undefined {
-	if (!value) return undefined;
-	const parsed = Date.parse(value);
-	return Number.isFinite(parsed) ? parsed : undefined;
-}
-
 function parseBucket(bucket: unknown): ParsedUsageBucket | undefined {
 	if (!isRecord(bucket)) return undefined;
 	const utilization = toNumber(bucket.utilization);
-	const resetsAt = parseIsoTime(typeof bucket.resets_at === "string" ? bucket.resets_at : undefined);
+	const resetsAt = parseIsoTimestamp(typeof bucket.resets_at === "string" ? bucket.resets_at : undefined);
 	if (utilization === undefined && resetsAt === undefined) {
 		return undefined;
 	}
@@ -168,7 +161,7 @@ function parseApiLimitEntries(raw: unknown): ParsedApiLimitEntry[] {
 		const entry = rawEntry as ClaudeApiLimitEntry;
 		if (typeof entry.kind !== "string") continue;
 		const utilization = toNumber(entry.percent);
-		const resetsAt = parseIsoTime(typeof entry.resets_at === "string" ? entry.resets_at : undefined);
+		const resetsAt = parseIsoTimestamp(typeof entry.resets_at === "string" ? entry.resets_at : undefined);
 		if (utilization === undefined && resetsAt === undefined) continue;
 		const displayName = getApiLimitDisplayName(entry.scope);
 		entries.push({
@@ -554,7 +547,7 @@ function buildScopedWeeklyUsageLimits(entries: readonly ParsedApiLimitEntry[]):
 			label: `Claude 7 Day (${entry.displayName})`,
 			windowId: "7d",
 			windowLabel: "7 Day",
-			durationMs: SEVEN_DAYS_MS,
+			durationMs: WEEK_MS,
 			bucket: entry.bucket,
 			provider: "anthropic",
 			tier: slug,
@@ -574,7 +567,7 @@ export function parseClaudeRateLimitHeaders(headers: Record<string, string>, now
 			label: "Claude 5 Hour",
 			windowId: "5h",
 			windowLabel: "5 Hour",
-			durationMs: FIVE_HOURS_MS,
+			durationMs: 5 * HOUR_MS,
 			bucket: fiveHour,
 			provider: "anthropic",
 			shared: true,
@@ -584,7 +577,7 @@ export function parseClaudeRateLimitHeaders(headers: Record<string, string>, now
 			label: "Claude 7 Day",
 			windowId: "7d",
 			windowLabel: "7 Day",
-			durationMs: SEVEN_DAYS_MS,
+			durationMs: WEEK_MS,
 			bucket: sevenDay,
 			provider: "anthropic",
 			shared: true,
@@ -594,7 +587,7 @@ export function parseClaudeRateLimitHeaders(headers: Record<string, string>, now
 			label: "Claude 7 Day (Fable)",
 			windowId: "7d",
 			windowLabel: "7 Day",
-			durationMs: SEVEN_DAYS_MS,
+			durationMs: WEEK_MS,
 			bucket: modelScopedSevenDay,
 			provider: "anthropic",
 			tier: "fable",
@@ -638,7 +631,7 @@ async function fetchClaudeUsage(params: UsageFetchParams, ctx: UsageFetchContext
 			label: "Claude 5 Hour",
 			windowId: "5h",
 			windowLabel: "5 Hour",
-			durationMs: FIVE_HOURS_MS,
+			durationMs: 5 * HOUR_MS,
 			bucket: fiveHour,
 			provider: "anthropic",
 			shared: true,
@@ -648,7 +641,7 @@ async function fetchClaudeUsage(params: UsageFetchParams, ctx: UsageFetchContext
 			label: "Claude 7 Day",
 			windowId: "7d",
 			windowLabel: "7 Day",
-			durationMs: SEVEN_DAYS_MS,
+			durationMs: WEEK_MS,
 			bucket: sevenDay,
 			provider: "anthropic",
 			shared: true,
@@ -658,7 +651,7 @@ async function fetchClaudeUsage(params: UsageFetchParams, ctx: UsageFetchContext
 			label: "Claude 7 Day (Opus)",
 			windowId: "7d",
 			windowLabel: "7 Day",
-			durationMs: SEVEN_DAYS_MS,
+			durationMs: WEEK_MS,
 			bucket: sevenDayOpus,
 			provider: "anthropic",
 			tier: "opus",
@@ -668,7 +661,7 @@ async function fetchClaudeUsage(params: UsageFetchParams, ctx: UsageFetchContext
 			label: "Claude 7 Day (Sonnet)",
 			windowId: "7d",
 			windowLabel: "7 Day",
-			durationMs: SEVEN_DAYS_MS,
+			durationMs: WEEK_MS,
 			bucket: sevenDaySonnet,
 			provider: "anthropic",
 			tier: "sonnet",
@@ -774,7 +767,7 @@ function rankingUsedFraction(limit: UsageLimit): number {
 
 function rankingDrainRate(limit: UsageLimit, nowMs: number): number {
 	const usedFraction = rankingUsedFraction(limit);
-	const durationMs = limit.window?.durationMs ?? SEVEN_DAYS_MS;
+	const durationMs = limit.window?.durationMs ?? WEEK_MS;
 	if (!Number.isFinite(durationMs) || durationMs <= 0) return usedFraction;
 	const resetAt = limit.window?.resetsAt;
 	if (typeof resetAt !== "number" || !Number.isFinite(resetAt)) return usedFraction;

package/src/usage/cursor.ts

@@ -1,3 +1,4 @@
+import { toNumber } from "@oh-my-pi/pi-catalog/utils";
 import { extractCursorAccessTokenUserId } from "../registry/oauth/cursor";
 import type {
 	UsageAmount,
@@ -6,21 +7,15 @@ import type {
 	UsageLimit,
 	UsageProvider,
 	UsageReport,
-	UsageStatus,
 	UsageWindow,
 } from "../usage";
-import { toNumber } from "./shared";
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
+import { isRecord } from "../utils";
+import { parseIsoTimestamp, usageStatus } from "./shared";
 
 function parseTimestamp(value: unknown): number | undefined {
 	const numeric = toNumber(value);
 	if (numeric !== undefined) return numeric < 1_000_000_000_000 ? numeric * 1000 : numeric;
-	if (typeof value !== "string" || !value.trim()) return undefined;
-	const parsed = Date.parse(value);
-	return Number.isFinite(parsed) ? parsed : undefined;
+	return parseIsoTimestamp(value);
 }
 
 const DEFAULT_CURSOR_BASE_URL = "https://api2.cursor.sh";
@@ -78,51 +73,145 @@ function deriveResetsAt(payload: Record<string, unknown>): number | undefined {
 	return undefined;
 }
 
-function resolveCursorStatus(usedFraction: number | undefined): UsageStatus {
-	if (usedFraction === undefined) return "unknown";
-	if (usedFraction >= 1) return "exhausted";
-	if (usedFraction >= 0.9) return "warning";
-	return "ok";
-}
-
-export function parseCursorIndividualUsage(payload: unknown, fetchedAt = Date.now()): UsageReport | null {
-	if (!isRecord(payload) || !isRecord(payload.individualUsage) || !isRecord(payload.individualUsage.overall)) {
-		return null;
-	}
-	const individual = payload.individualUsage.overall;
-	if (individual.enabled === false) return null;
+/**
+ * Parse a Cursor cents bucket (`used`/`limit`/`remaining` in USD cents).
+ * Returns null for disabled or non-positive / malformed buckets.
+ */
+function parseCursorCentsBucket(bucket: Record<string, unknown>): UsageAmount | null {
+	if (bucket.enabled === false) return null;
 
-	const reportedUsed = toNumber(individual.used);
-	const reportedRemaining = toNumber(individual.remaining);
+	const reportedUsed = toNumber(bucket.used);
+	const reportedRemaining = toNumber(bucket.remaining);
 	const hasValidUsed = reportedUsed !== undefined && reportedUsed >= 0;
 	const hasValidRemaining = reportedRemaining !== undefined && reportedRemaining >= 0;
-	const limit = toNumber(individual.limit);
+	const limit = toNumber(bucket.limit);
 
-	let amount: UsageAmount;
-	if (individual.limit === null || individual.limit === undefined) {
+	if (bucket.limit === null || bucket.limit === undefined) {
 		if (!hasValidUsed) return null;
-		amount = { used: reportedUsed / 100, unit: "usd" };
+		return { used: reportedUsed / 100, unit: "usd" };
+	}
+
+	if (limit === undefined || limit <= 0) return null;
+	let used: number;
+	if (reportedUsed !== undefined && reportedUsed > 0) {
+		used = reportedUsed;
+	} else if (hasValidRemaining && reportedRemaining < limit) {
+		used = Math.max(0, limit - reportedRemaining);
+	} else if (hasValidUsed) {
+		used = reportedUsed;
 	} else {
-		if (limit === undefined || limit <= 0) return null;
-		let used: number;
-		if (reportedUsed !== undefined && reportedUsed > 0) {
-			used = reportedUsed;
-		} else if (hasValidRemaining && reportedRemaining < limit) {
-			used = Math.max(0, limit - reportedRemaining);
-		} else if (hasValidUsed) {
-			used = reportedUsed;
+		return null;
+	}
+	const remaining = Math.max(0, limit - used);
+	return {
+		used: used / 100,
+		limit: limit / 100,
+		remaining: remaining / 100,
+		usedFraction: used / limit,
+		remainingFraction: remaining / limit,
+		unit: "usd",
+	};
+}
+
+/**
+ * Cursor's dashboard does not treat plan.used / plan.limit as the visible %.
+ * Pro+ shows separate quota pools (not one shared percent):
+ * - Cursor Models  ← autoPercentUsed
+ *   (includes Cursor Grok 4.5 and Composer 2.5)
+ * - Other Models   ← apiPercentUsed (separate included-$ pool; different quota)
+ * Prefer those fractions when present; fall back to cents only for older overall buckets.
+ */
+function parseCursorPlanDashboardAmounts(bucket: Record<string, unknown>): {
+	auto?: UsageAmount;
+	api?: UsageAmount;
+	fallback?: UsageAmount;
+} {
+	if (bucket.enabled === false) return {};
+
+	const limitCents = toNumber(bucket.limit);
+	const limitUsd = limitCents !== undefined && limitCents > 0 ? limitCents / 100 : undefined;
+	const autoPct = toNumber(bucket.autoPercentUsed);
+	const apiPct = toNumber(bucket.apiPercentUsed);
+	const totalPct = toNumber(bucket.totalPercentUsed);
+
+	const fromPercent = (pct: number, withLimit: boolean): UsageAmount => {
+		const usedFraction = Math.max(0, pct) / 100;
+		if (withLimit && limitUsd !== undefined) {
+			const used = limitUsd * usedFraction;
+			return {
+				used,
+				limit: limitUsd,
+				remaining: Math.max(0, limitUsd - used),
+				usedFraction,
+				remainingFraction: Math.max(0, 1 - usedFraction),
+				unit: "usd",
+			};
+		}
+		return { used: usedFraction * 100, usedFraction, unit: "percent" };
+	};
+
+	const result: { auto?: UsageAmount; api?: UsageAmount; fallback?: UsageAmount } = {};
+	if (autoPct !== undefined) result.auto = fromPercent(autoPct, false);
+	if (apiPct !== undefined) result.api = fromPercent(apiPct, true);
+	if (!result.auto && !result.api) {
+		if (totalPct !== undefined) {
+			result.fallback = fromPercent(totalPct, true);
 		} else {
-			return null;
+			const cents = parseCursorCentsBucket(bucket);
+			if (cents) result.fallback = cents;
 		}
-		const remaining = Math.max(0, limit - used);
-		amount = {
-			used: used / 100,
-			limit: limit / 100,
-			remaining: remaining / 100,
-			usedFraction: used / limit,
-			remainingFraction: remaining / limit,
-			unit: "usd",
-		};
+	}
+	return result;
+}
+
+function pushCursorPlanRails(limits: UsageLimit[], bucket: Record<string, unknown>, window: UsageWindow): void {
+	const rails = parseCursorPlanDashboardAmounts(bucket);
+	if (rails.auto) {
+		limits.push({
+			id: "cursor:usd:individual-auto",
+			label: "Cursor Models",
+			scope: { provider: "cursor", windowId: window.id },
+			window,
+			amount: rails.auto,
+			...(rails.auto.usedFraction !== undefined ? { status: usageStatus(rails.auto.usedFraction) } : {}),
+		});
+	}
+	if (rails.api) {
+		limits.push({
+			id: "cursor:usd:individual-api",
+			label: "Other Models",
+			scope: { provider: "cursor", windowId: window.id },
+			window,
+			amount: rails.api,
+			...(rails.api.usedFraction !== undefined ? { status: usageStatus(rails.api.usedFraction) } : {}),
+		});
+	}
+	if (rails.fallback) {
+		limits.push({
+			id: "cursor:usd:individual-plan",
+			label: "Personal Usage",
+			scope: { provider: "cursor", windowId: window.id },
+			window,
+			amount: rails.fallback,
+			...(rails.fallback.usedFraction !== undefined ? { status: usageStatus(rails.fallback.usedFraction) } : {}),
+		});
+	}
+}
+
+/**
+ * Cursor's `/api/usage-summary` has shipped two personal-bucket shapes:
+ * - Enterprise/team dashboards historically exposed `individualUsage.overall`
+ * - Current Pro / Pro+ / Ultra dashboards expose `individualUsage.plan`
+ *   (plus optional `onDemand`)
+ *
+ * Prefer a *usable* overall bucket; if overall is absent/disabled/malformed,
+ * fall through to plan rails (`autoPercentUsed` / `apiPercentUsed`). Always
+ * consider on-demand afterward so a valid on-demand meter is not dropped when
+ * the included plan bucket is empty.
+ */
+export function parseCursorIndividualUsage(payload: unknown, fetchedAt = Date.now()): UsageReport | null {
+	if (!isRecord(payload) || !isRecord(payload.individualUsage)) {
+		return null;
 	}
 
 	const resetsAt = deriveResetsAt(payload);
@@ -131,21 +220,52 @@ export function parseCursorIndividualUsage(payload: unknown, fetchedAt = Date.no
 		label: "Monthly",
 		...(resetsAt !== undefined ? { resetsAt } : {}),
 	};
-	const limitEntry: UsageLimit = {
-		id: "cursor:usd:individual-overall",
-		label: "Personal Usage",
-		scope: {
-			provider: "cursor",
-			windowId: window.id,
-		},
-		window,
-		amount,
-		...(amount.usedFraction !== undefined ? { status: resolveCursorStatus(amount.usedFraction) } : {}),
-	};
+	const limits: UsageLimit[] = [];
+
+	const overall = isRecord(payload.individualUsage.overall) ? payload.individualUsage.overall : null;
+	const plan = isRecord(payload.individualUsage.plan) ? payload.individualUsage.plan : null;
+
+	// Prefer a usable overall bucket; if it is disabled/malformed, fall through to plan.
+	let usedOverall = false;
+	if (overall) {
+		const amount = parseCursorCentsBucket(overall);
+		if (amount) {
+			usedOverall = true;
+			limits.push({
+				id: "cursor:usd:individual-overall",
+				label: "Personal Usage",
+				scope: { provider: "cursor", windowId: window.id },
+				window,
+				amount,
+				...(amount.usedFraction !== undefined ? { status: usageStatus(amount.usedFraction) } : {}),
+			});
+		}
+	}
+	if (!usedOverall && plan) {
+		pushCursorPlanRails(limits, plan, window);
+	}
+
+	// Keep on-demand even when the included plan/overall bucket is absent or unusable.
+	if (isRecord(payload.individualUsage.onDemand)) {
+		const onDemandAmount = parseCursorCentsBucket(payload.individualUsage.onDemand);
+		if (onDemandAmount && onDemandAmount.limit !== undefined && onDemandAmount.limit > 0) {
+			limits.push({
+				id: "cursor:usd:individual-ondemand",
+				label: "On-Demand Usage",
+				scope: { provider: "cursor", windowId: window.id },
+				window,
+				amount: onDemandAmount,
+				...(onDemandAmount.usedFraction !== undefined ? { status: usageStatus(onDemandAmount.usedFraction) } : {}),
+			});
+		}
+	}
+
+	if (limits.length === 0) return null;
+
 	return {
 		provider: "cursor",
 		fetchedAt,
-		limits: [limitEntry],
+		limits,
 		raw: payload,
 	};
 }
@@ -197,7 +317,7 @@ export function parseCursorUsage(payload: unknown, fetchedAt = Date.now()): Usag
 				unit,
 			};
 
-			const status = resolveCursorStatus(amount.usedFraction);
+			const status = usageStatus(amount.usedFraction);
 
 			limits.push({
 				id: limitId,

package/src/usage/gemini.ts

@@ -8,6 +8,7 @@ import type {
 	UsageReport,
 	UsageWindow,
 } from "../usage";
+import { parseIsoTimestamp } from "./shared";
 
 // (Refresh is the sole responsibility of AuthStorage; no provider-direct refresh here.)
 
@@ -79,8 +80,8 @@ function parseWindow(resetTime: string | undefined): UsageWindow {
 			label: "Quota window",
 		};
 	}
-	const resetsAt = Date.parse(resetTime);
-	if (Number.isNaN(resetsAt)) {
+	const resetsAt = parseIsoTimestamp(resetTime);
+	if (resetsAt === undefined) {
 		return {
 			id: "quota",
 			label: "Quota window",

package/src/usage/github-copilot.ts

@@ -18,6 +18,7 @@ import type {
 	UsageWindow,
 } from "../usage";
 import { isRecord } from "../utils";
+import { parseIsoTimestamp } from "./shared";
 
 type CopilotQuotaDetail = {
 	entitlement: number;
@@ -74,8 +75,8 @@ function resolveGitHubApiBaseUrl(params: UsageFetchParams): string {
 
 function buildWindow(resetDate: string | undefined): UsageWindow | undefined {
 	if (!resetDate) return undefined;
-	const resetAt = Date.parse(resetDate);
-	if (!Number.isFinite(resetAt)) return undefined;
+	const resetAt = parseIsoTimestamp(resetDate);
+	if (resetAt === undefined) return undefined;
 	return {
 		id: "monthly",
 		label: "Monthly",

package/src/usage/google-antigravity.ts

@@ -12,6 +12,7 @@ import type {
 	UsageStatus,
 	UsageWindow,
 } from "../usage";
+import { DAY_MS, parseIsoTimestamp, WEEK_MS } from "./shared";
 
 // (Refresh is the sole responsibility of AuthStorage; no provider-direct refresh here.)
 
@@ -47,9 +48,6 @@ interface AntigravityUsageResponse {
 const DEFAULT_ENDPOINT = "https://daily-cloudcode-pa.googleapis.com";
 const FETCH_AVAILABLE_MODELS_PATH = "/v1internal:fetchAvailableModels";
 
-const ONE_DAY_MS = 24 * 60 * 60 * 1000;
-const ONE_WEEK_MS = 7 * ONE_DAY_MS;
-
 interface AntigravityWindowDescriptor {
 	id: string;
 	label: string;
@@ -59,25 +57,20 @@ interface AntigravityWindowDescriptor {
 function classifyWindow(id: string | undefined, label: string | undefined): AntigravityWindowDescriptor | undefined {
 	const source = `${id ?? ""} ${label ?? ""}`.toLowerCase();
 	if (source.includes("week") || source.includes("7d") || /7[\s_-]*day/.test(source)) {
-		return { id: "weekly", label: "Weekly", durationMs: ONE_WEEK_MS };
+		return { id: "weekly", label: "Weekly", durationMs: WEEK_MS };
 	}
 	if (source.includes("day") || source.includes("daily") || source.includes("24h")) {
-		return { id: "daily", label: "Daily", durationMs: ONE_DAY_MS };
+		return { id: "daily", label: "Daily", durationMs: DAY_MS };
 	}
 	if (id || label) return { id: id ?? label ?? "default", label: label ?? id ?? "Default" };
 	return undefined;
 }
 
-function parseResetTime(info: AntigravityQuotaInfo): number | undefined {
-	const resetAt = info.resetTime ? Date.parse(info.resetTime) : undefined;
-	return resetAt !== undefined && Number.isFinite(resetAt) ? resetAt : undefined;
-}
-
 function inferWindowFromReset(resetAt: number | undefined, nowMs: number): AntigravityWindowDescriptor {
-	if (resetAt !== undefined && resetAt - nowMs > ONE_DAY_MS) {
-		return { id: "weekly", label: "Weekly", durationMs: ONE_WEEK_MS };
+	if (resetAt !== undefined && resetAt - nowMs > DAY_MS) {
+		return { id: "weekly", label: "Weekly", durationMs: WEEK_MS };
 	}
-	return { id: "daily", label: "Daily", durationMs: ONE_DAY_MS };
+	return { id: "daily", label: "Daily", durationMs: DAY_MS };
 }
 
 function quotaInferenceKey(info: AntigravityQuotaInfo): string {
@@ -98,7 +91,7 @@ function inferWindowDescriptors(
 			continue;
 		}
 		const group = groups.get(quotaInferenceKey(info)) ?? [];
-		group.push({ info, resetAt: parseResetTime(info) });
+		group.push({ info, resetAt: parseIsoTimestamp(info.resetTime) });
 		groups.set(quotaInferenceKey(info), group);
 	}
 
@@ -110,7 +103,7 @@ function inferWindowDescriptors(
 		for (const entry of group) {
 			const descriptor =
 				latestReset !== undefined && entry.resetAt === latestReset
-					? { id: "weekly", label: "Weekly", durationMs: ONE_WEEK_MS }
+					? { id: "weekly", label: "Weekly", durationMs: WEEK_MS }
 					: inferWindowFromReset(entry.resetAt, nowMs);
 			descriptors.set(entry.info, descriptor);
 		}
@@ -149,7 +142,7 @@ function parseWindow(
 	info: AntigravityQuotaInfo,
 	descriptor: AntigravityWindowDescriptor | undefined,
 ): UsageWindow | undefined {
-	const resetAt = parseResetTime(info);
+	const resetAt = parseIsoTimestamp(info.resetTime);
 	const hasResetAt = resetAt !== undefined;
 	if (!descriptor && !hasResetAt) return undefined;
 	return {
@@ -493,5 +486,5 @@ export const antigravityRankingStrategy: CredentialRankingStrategy = {
 	// Antigravity windows carry `durationMs` when the response identifies them
 	// as daily/weekly. Fall back to daily for legacy unlabelled quotaInfo
 	// entries from `daily-cloudcode-pa.googleapis.com`.
-	windowDefaults: { primaryMs: ONE_DAY_MS, secondaryMs: ONE_DAY_MS },
+	windowDefaults: { primaryMs: DAY_MS, secondaryMs: DAY_MS },
 };

package/src/usage/kimi.ts

@@ -1,3 +1,4 @@
+import { toNumber } from "@oh-my-pi/pi-catalog/utils";
 import { $env } from "@oh-my-pi/pi-utils";
 import { getKimiCommonHeaders } from "../registry/oauth/kimi";
 import type {
@@ -7,12 +8,12 @@ import type {
 	UsageLimit,
 	UsageProvider,
 	UsageReport,
-	UsageStatus,
 	UsageWindow,
 } from "../usage";
 import { isRecord } from "../utils";
+import { parseIsoTimestamp, usageStatus } from "./shared";
+
 // (Refresh is the sole responsibility of AuthStorage; no provider-direct refresh here.)
-import { toNumber } from "./shared";
 
 const DEFAULT_BASE_URL = "https://api.kimi.com/coding/v1";
 const USAGE_PATH = "usages";
@@ -47,8 +48,8 @@ function parseResetTime(data: Record<string, unknown>, nowMs: number): number |
 	for (const key of timeKeys) {
 		const value = data[key];
 		if (typeof value === "string" && value.trim()) {
-			const parsed = Date.parse(value);
-			if (Number.isFinite(parsed)) return parsed;
+			const parsed = parseIsoTimestamp(value);
+			if (parsed !== undefined) return parsed;
 		}
 		if (typeof value === "number" && Number.isFinite(value)) {
 			return value > 1_000_000_000_000 ? value : value * 1000;
@@ -76,6 +77,23 @@ function formatDurationLabel(duration: number, timeUnit: string): string | undef
 	return undefined;
 }
 
+const MINUTE_MS = 60_000;
+const HOUR_MS = 3_600_000;
+const DAY_MS = 86_400_000;
+
+/**
+ * Status-line and ranking consumers match on canonical window ids ("5h",
+ * "7d"), so derive the id from the reported span: the 300-minute burst window
+ * surfaces as "5h" instead of "300time_unit_minute". Mirrors the
+ * intervalWindowId convention in minimax-code.ts.
+ */
+function canonicalWindowId(durationMs: number): string {
+	if (durationMs > 0 && durationMs % DAY_MS === 0) return `${durationMs / DAY_MS}d`;
+	if (durationMs > 0 && durationMs % HOUR_MS === 0) return `${durationMs / HOUR_MS}h`;
+	const minutes = Math.round(durationMs / MINUTE_MS);
+	return minutes > 0 ? `${minutes}m` : "default";
+}
+
 function buildWindow(windowData: Record<string, unknown>, nowMs: number): UsageWindow | undefined {
 	const duration = toNumber(windowData.duration);
 	const timeUnit = typeof windowData.timeUnit === "string" ? windowData.timeUnit : "";
@@ -85,14 +103,15 @@ function buildWindow(windowData: Record<string, unknown>, nowMs: number): UsageW
 	if (duration === undefined && !label && !resetsAt) return undefined;
 	let durationMs: number | undefined;
 	if (duration !== undefined) {
-		if (timeUnit.toUpperCase().includes("MINUTE")) durationMs = duration * 60_000;
-		else if (timeUnit.toUpperCase().includes("HOUR")) durationMs = duration * 3_600_000;
-		else if (timeUnit.toUpperCase().includes("DAY")) durationMs = duration * 86_400_000;
+		if (timeUnit.toUpperCase().includes("MINUTE")) durationMs = duration * MINUTE_MS;
+		else if (timeUnit.toUpperCase().includes("HOUR")) durationMs = duration * HOUR_MS;
+		else if (timeUnit.toUpperCase().includes("DAY")) durationMs = duration * DAY_MS;
+		else if (timeUnit.toUpperCase().includes("WEEK")) durationMs = duration * 7 * DAY_MS;
 		else if (timeUnit.toUpperCase().includes("SECOND")) durationMs = duration * 1000;
 	}
 
 	return {
-		id: duration !== undefined && timeUnit ? `${duration}${timeUnit.toLowerCase()}` : "default",
+		id: durationMs !== undefined ? canonicalWindowId(durationMs) : "default",
 		label: label ?? "Usage window",
 		durationMs,
 		resetsAt,
@@ -136,13 +155,6 @@ function buildUsageAmount(row: KimiUsageRow): UsageAmount {
 	return amount;
 }
 
-function buildUsageStatus(amount: UsageAmount): UsageStatus {
-	if (amount.usedFraction === undefined) return "unknown";
-	if (amount.usedFraction >= 1) return "exhausted";
-	if (amount.usedFraction >= 0.9) return "warning";
-	return "ok";
-}
-
 function toUsageLimit(row: KimiUsageRow, provider: string, index: number, accountId?: string): UsageLimit {
 	// Kimi puts `resetTime` on the limit `detail`, not on `window`, so a
 	// window built from `duration`/`timeUnit` alone carries no resetsAt.
@@ -172,7 +184,7 @@ function toUsageLimit(row: KimiUsageRow, provider: string, index: number, accoun
 		},
 		window,
 		amount,
-		status: buildUsageStatus(amount),
+		status: usageStatus(amount.usedFraction),
 	};
 }
 
@@ -183,7 +195,13 @@ function parseUsagePayload(payload: unknown, nowMs: number): { rows: KimiUsageRo
 
 	if (isRecord(data.usage)) {
 		const summary = buildUsageRow(data.usage, "Total quota", nowMs);
-		if (summary) rows.push(summary);
+		if (summary) {
+			// Kimi Code's aggregate quota resets weekly, but the payload carries
+			// only `resetTime` and no duration. Attach the canonical weekly
+			// window explicitly so status-line/ranking consumers recognize it.
+			summary.window = { id: "7d", label: "7 Day", resetsAt: summary.resetsAt };
+			rows.push(summary);
+		}
 	}
 
 	if (Array.isArray(data.limits)) {