dsh-subscriptions 0.1.5 → 0.2.2

package/lib/providers/cursor-auth.js

@@ -18,11 +18,20 @@ async function parseCredential(value) {
     if (parsed === null || typeof parsed !== 'object')
         throw new Error('Cursor credential is malformed');
     const item = parsed;
-    if (item.type !== 'oauth' || typeof item.access !== 'string' || item.access.length === 0
-        || typeof item.refresh !== 'string' || typeof item.expires !== 'number' || !Number.isFinite(item.expires)) {
+    if (item.type !== 'oauth' ||
+        typeof item.access !== 'string' ||
+        item.access.length === 0 ||
+        typeof item.refresh !== 'string' ||
+        typeof item.expires !== 'number' ||
+        !Number.isFinite(item.expires)) {
         throw new Error('Cursor credential is malformed');
     }
-    return { type: 'oauth', access: item.access, refresh: item.refresh, expires: item.expires };
+    return {
+        type: 'oauth',
+        access: item.access,
+        refresh: item.refresh,
+        expires: item.expires,
+    };
 }
 function tokenExpiry(token, now) {
     try {
@@ -34,15 +43,23 @@ function tokenExpiry(token, now) {
         if (typeof exp === 'number' && Number.isFinite(exp))
             return exp * 1000;
     }
-    catch { /* JWTs without exp still receive a bounded lifetime. */ }
+    catch {
+        /* JWTs without exp still receive a bounded lifetime. */
+    }
     return now + 24 * 60 * 60_000;
 }
 function abortableDelay(ms, signal) {
     if (signal.aborted)
         return Promise.reject(signal.reason);
     return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => { signal.removeEventListener('abort', aborted); resolve(); }, ms);
-        function aborted() { clearTimeout(timer); reject(signal.reason); }
+        const timer = setTimeout(() => {
+            signal.removeEventListener('abort', aborted);
+            resolve();
+        }, ms);
+        function aborted() {
+            clearTimeout(timer);
+            reject(signal.reason);
+        }
         signal.addEventListener('abort', aborted, { once: true });
     });
 }
@@ -70,7 +87,7 @@ export class CursorAuth {
             ...(this.error === undefined ? {} : { error: this.error }),
         };
     }
-    async accessToken({ signal } = {}) {
+    async accessToken({ signal, } = {}) {
         signal?.throwIfAborted();
         const current = await this.read();
         if (current === undefined)
@@ -82,27 +99,39 @@ export class CursorAuth {
         if (this.refreshTask === undefined) {
             const pending = this.refresh(current, signal);
             this.refreshTask = pending;
-            void pending.finally(() => { if (this.refreshTask === pending)
-                this.refreshTask = undefined; }).catch(() => undefined);
+            void pending
+                .finally(() => {
+                if (this.refreshTask === pending)
+                    this.refreshTask = undefined;
+            })
+                .catch(() => undefined);
         }
         return (await this.refreshTask).access;
     }
     async refresh(current, signal) {
         const response = await this.http(`${API_ORIGIN}/auth/exchange_user_api_key`, {
-            method: 'POST', redirect: 'error',
-            headers: { authorization: `Bearer ${current.refresh}`, accept: 'application/json', 'content-type': 'application/json' },
+            method: 'POST',
+            redirect: 'error',
+            headers: {
+                authorization: `Bearer ${current.refresh}`,
+                accept: 'application/json',
+                'content-type': 'application/json',
+            },
             body: '{}',
             ...(signal === undefined ? {} : { signal }),
         });
         if (!response.ok)
             throw new Error(`Cursor token refresh failed (HTTP ${response.status})`);
-        const body = await parseProviderJson(response, 'Cursor token refresh');
+        const body = (await parseProviderJson(response, 'Cursor token refresh'));
         if (typeof body.accessToken !== 'string' || body.accessToken.length === 0) {
             throw new Error('Cursor token refresh returned no access token');
         }
         const next = {
-            type: 'oauth', access: body.accessToken,
-            refresh: typeof body.refreshToken === 'string' && body.refreshToken.length > 0 ? body.refreshToken : current.refresh,
+            type: 'oauth',
+            access: body.accessToken,
+            refresh: typeof body.refreshToken === 'string' && body.refreshToken.length > 0
+                ? body.refreshToken
+                : current.refresh,
             expires: tokenExpiry(body.accessToken, this.now()),
         };
         const latest = await this.read();
@@ -121,13 +150,22 @@ export class CursorAuth {
         const challenge = createHash('sha256').update(verifier).digest('base64url');
         const uuid = randomUUID();
         const url = new URL('https://cursor.com/loginDeepControl');
-        url.search = new URLSearchParams({ challenge, uuid, mode: 'login', redirectTarget: 'cli' }).toString();
+        url.search = new URLSearchParams({
+            challenge,
+            uuid,
+            mode: 'login',
+            redirectTarget: 'cli',
+        }).toString();
         const abort = new AbortController();
         const promise = this.pollLogin(uuid, verifier, abort.signal)
-            .catch(error => { if (!abort.signal.aborted)
-            this.error = error instanceof Error ? error.message : String(error); })
-            .finally(() => { if (this.loginTask?.abort === abort)
-            this.loginTask = undefined; });
+            .catch((error) => {
+            if (!abort.signal.aborted)
+                this.error = error instanceof Error ? error.message : String(error);
+        })
+            .finally(() => {
+            if (this.loginTask?.abort === abort)
+                this.loginTask = undefined;
+        });
         this.loginTask = { abort, promise };
         return { authorizeUrl: url.href };
     }
@@ -136,23 +174,30 @@ export class CursorAuth {
         for (let attempt = 0; attempt < 150; attempt++) {
             await abortableDelay(delay, signal);
             const url = `${API_ORIGIN}/auth/poll?uuid=${encodeURIComponent(uuid)}&verifier=${encodeURIComponent(verifier)}`;
-            const response = await this.http(url, { headers: { accept: 'application/json' }, redirect: 'error', signal });
+            const response = await this.http(url, {
+                headers: { accept: 'application/json' },
+                redirect: 'error',
+                signal,
+            });
             if (response.status === 404) {
                 delay = Math.min(Math.ceil(delay * 1.2), 10_000);
                 continue;
             }
             if (!response.ok)
                 throw new Error(`Cursor login failed (HTTP ${response.status})`);
-            const body = await parseProviderJson(response, 'Cursor login poll');
+            const body = (await parseProviderJson(response, 'Cursor login poll'));
             signal.throwIfAborted();
-            if (typeof body.accessToken !== 'string' || body.accessToken.length === 0) {
+            if (typeof body.accessToken !== 'string' ||
+                body.accessToken.length === 0) {
                 throw new Error('Cursor login returned no access token');
             }
-            if (typeof body.refreshToken !== 'string' || body.refreshToken.length === 0) {
+            if (typeof body.refreshToken !== 'string' ||
+                body.refreshToken.length === 0) {
                 throw new Error('Cursor login returned no refresh token');
             }
             const value = {
-                type: 'oauth', access: body.accessToken,
+                type: 'oauth',
+                access: body.accessToken,
                 refresh: body.refreshToken,
                 expires: tokenExpiry(body.accessToken, this.now()),
             };

package/lib/providers/cursor-model-settings.js

@@ -9,7 +9,8 @@ export function validateCursorModelSettings(input) {
     const models = input.visibleModels;
     if (models === undefined)
         return {};
-    if (!Array.isArray(models) || models.some(id => typeof id !== 'string' || !id.trim())) {
+    if (!Array.isArray(models) ||
+        models.some((id) => typeof id !== 'string' || !id.trim())) {
         throw new Error('visibleModels must be an array of model ids');
     }
     return { visibleModels: [...new Set(models)] };
@@ -26,18 +27,26 @@ export class CursorModelSettingsStore {
         }
         catch (error) {
             if (error.code !== 'ENOENT')
-                throw new Error(`Cannot read Cursor model settings at ${path}`, { cause: error });
+                throw new Error(`Cannot read Cursor model settings at ${path}`, {
+                    cause: error,
+                });
         }
     }
-    get() { return structuredClone(this.current); }
-    visibleModels() { return this.current.visibleModels; }
+    get() {
+        return structuredClone(this.current);
+    }
+    visibleModels() {
+        return this.current.visibleModels;
+    }
     set(input) {
         const validated = validateCursorModelSettings(input);
         const run = this.writes.then(async () => {
             await mkdir(dirname(this.path), { recursive: true });
             const temporary = `${this.path}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
             try {
-                await writeFile(temporary, JSON.stringify(validated, null, 2), { mode: 0o600 });
+                await writeFile(temporary, JSON.stringify(validated, null, 2), {
+                    mode: 0o600,
+                });
                 await rename(temporary, this.path);
             }
             finally {

package/lib/providers/cursor-usage.js

@@ -52,17 +52,21 @@ function legacyRequestWindow(body, resetsAt) {
     if (usage === undefined)
         return undefined;
     const gpt4 = record(usage['gpt-4']);
-    const candidate = gpt4 !== undefined && number(gpt4.numRequests) !== undefined ? gpt4 : Object.values(usage)
-        .map(record)
-        .filter((value) => value !== undefined)
-        .sort((a, b) => (number(b.maxRequestUsage) ?? 0) - (number(a.maxRequestUsage) ?? 0))[0];
+    const candidate = gpt4 !== undefined && number(gpt4.numRequests) !== undefined
+        ? gpt4
+        : Object.values(usage)
+            .map(record)
+            .filter((value) => value !== undefined)
+            .sort((a, b) => (number(b.maxRequestUsage) ?? 0) -
+            (number(a.maxRequestUsage) ?? 0))[0];
     const used = number(candidate?.numRequests);
     const limit = number(candidate?.maxRequestUsage);
     if (used === undefined || limit === undefined || limit <= 0)
         return undefined;
     return {
-        kind: 'other', scope: 'Included requests',
-        usedPercent: Math.max(0, Math.min(100, used / limit * 100)),
+        kind: 'other',
+        scope: 'Included requests',
+        usedPercent: Math.max(0, Math.min(100, (used / limit) * 100)),
         ...(resetsAt === undefined ? {} : { resetsAt }),
     };
 }
@@ -79,18 +83,26 @@ export async function fetchCursorUsage(accessToken, http = fetch, signal) {
         dashboardJson(`${ORIGIN}/api/usage-summary`, cookie, http, signal),
         dashboardJson(`${ORIGIN}/api/usage?user=${encodeURIComponent(userId)}`, cookie, http, signal),
     ]);
-    if (summaryResult.status === 'rejected' && legacyResult.status === 'rejected') {
-        throw summaryResult.reason instanceof Error ? summaryResult.reason : new Error('Cursor usage is unavailable');
+    if (summaryResult.status === 'rejected' &&
+        legacyResult.status === 'rejected') {
+        throw summaryResult.reason instanceof Error
+            ? summaryResult.reason
+            : new Error('Cursor usage is unavailable');
     }
-    const summary = summaryResult.status === 'fulfilled' ? record(summaryResult.value) : undefined;
-    const plan = record(record(summary?.individualUsage)?.plan) ?? record(record(summary?.teamUsage)?.plan);
+    const summary = summaryResult.status === 'fulfilled'
+        ? record(summaryResult.value)
+        : undefined;
+    const plan = record(record(summary?.individualUsage)?.plan) ??
+        record(record(summary?.teamUsage)?.plan);
     const resetValue = summary?.billingCycleEnd;
     const parsedReset = typeof resetValue === 'string' ? Date.parse(resetValue) : NaN;
     const resetsAt = Number.isFinite(parsedReset) ? parsedReset : undefined;
     const startValue = summary?.billingCycleStart;
     const parsedStart = typeof startValue === 'string' ? Date.parse(startValue) : NaN;
-    const timing = { ...(resetsAt === undefined ? {} : { resetsAt }),
-        ...(Number.isFinite(parsedStart) ? { startsAt: parsedStart } : {}) };
+    const timing = {
+        ...(resetsAt === undefined ? {} : { resetsAt }),
+        ...(Number.isFinite(parsedStart) ? { startsAt: parsedStart } : {}),
+    };
     const windows = [];
     for (const [field, scope] of [
         ['totalPercentUsed', 'Included'],
@@ -112,6 +124,8 @@ export async function fetchCursorUsage(accessToken, http = fetch, signal) {
     return {
         supported: true,
         windows,
-        ...(typeof membershipType === 'string' && membershipType.length > 0 ? { plan: membershipType } : {}),
+        ...(typeof membershipType === 'string' && membershipType.length > 0
+            ? { plan: membershipType }
+            : {}),
     };
 }

package/lib/providers/external-usage-controller.d.ts

@@ -1,6 +1,6 @@
 import type { ProviderUsage } from './common.js';
 /** Usage-only sources whose model routes are supplied by the DSH base install. */
-export type ExternalUsageSource = 'opencode-go' | 'kimi-code' | 'minimax' | 'minimax-cn';
+export type ExternalUsageSource = 'opencode-go' | 'kimi-code' | 'minimax' | 'minimax-cn' | 'ollama-cloud';
 export declare const EXTERNAL_USAGE_SOURCES: readonly ExternalUsageSource[];
 export interface ExternalUsageStatus {
     configured: boolean;
@@ -8,11 +8,18 @@ export interface ExternalUsageStatus {
 type ResolveCredential = (name: string) => Promise<{
     value: string;
 } | undefined>;
+/**
+ * A setting the controller reads per call. The function form keeps the Ollama
+ * reference and base URL live: the Settings card can change them after the
+ * controller was constructed.
+ */
+type LiveValue = string | (() => string);
 export declare class ExternalUsageController {
     private readonly resolveCredential;
     private readonly http;
     private readonly refs;
-    constructor(resolveCredential: ResolveCredential, http?: typeof fetch, refs?: Partial<Record<ExternalUsageSource, string>>);
+    private readonly ollamaBaseURL;
+    constructor(resolveCredential: ResolveCredential, http?: typeof fetch, refs?: Partial<Record<ExternalUsageSource, LiveValue>>, ollamaBaseURL?: LiveValue);
     status(): Promise<Record<ExternalUsageSource, ExternalUsageStatus>>;
     usage(source: ExternalUsageSource, signal?: AbortSignal): Promise<ProviderUsage>;
 }

package/lib/providers/external-usage-controller.js

@@ -1,35 +1,58 @@
 import { fetchMiniMaxUsage } from './minimax-usage.js';
-import { fetchKimiCodeUsage, fetchOpenCodeGoUsage } from './external-usage.js';
-export const EXTERNAL_USAGE_SOURCES = ['opencode-go', 'kimi-code', 'minimax', 'minimax-cn'];
+import { fetchKimiCodeUsage, fetchOllamaUsage, fetchOpenCodeGoUsage, } from './external-usage.js';
+import { DEFAULT_OLLAMA_API_KEY_REF, DEFAULT_OLLAMA_BASE_URL, } from './ollama.js';
+export const EXTERNAL_USAGE_SOURCES = [
+    'opencode-go',
+    'kimi-code',
+    'minimax',
+    'minimax-cn',
+    'ollama-cloud',
+];
+function valueOf(value) {
+    return typeof value === 'function' ? value() : value;
+}
 const DEFAULT_REFS = {
     'opencode-go': 'OPENCODE_GO_API_KEY',
     'kimi-code': 'KIMI_CODING_API_KEY',
-    'minimax': 'MINIMAX_API_KEY',
+    minimax: 'MINIMAX_API_KEY',
     'minimax-cn': 'MINIMAX_CN_API_KEY',
+    'ollama-cloud': DEFAULT_OLLAMA_API_KEY_REF,
 };
 export class ExternalUsageController {
     resolveCredential;
     http;
     refs;
-    constructor(resolveCredential, http = fetch, refs = {}) {
+    ollamaBaseURL;
+    constructor(resolveCredential, http = fetch, refs = {}, ollamaBaseURL = DEFAULT_OLLAMA_BASE_URL) {
         this.resolveCredential = resolveCredential;
         this.http = http;
         this.refs = { ...DEFAULT_REFS, ...refs };
+        this.ollamaBaseURL = ollamaBaseURL;
     }
     async status() {
         const values = await Promise.all(EXTERNAL_USAGE_SOURCES.map(async (source) => {
-            const value = await this.resolveCredential(this.refs[source]);
+            const value = await this.resolveCredential(valueOf(this.refs[source]));
             return typeof value?.value === 'string' && value.value.length > 0;
         }));
-        return Object.fromEntries(EXTERNAL_USAGE_SOURCES.map((source, i) => [source, { configured: values[i] ?? false }]));
+        return Object.fromEntries(EXTERNAL_USAGE_SOURCES.map((source, i) => [
+            source,
+            { configured: values[i] ?? false },
+        ]));
     }
     async usage(source, signal) {
-        const credential = await this.resolveCredential(this.refs[source]);
+        // Snapshot the endpoint facts before the first await: a save that
+        // switches the ref or host mid-flight must not send the old
+        // reference's key to the new host.
+        const ref = valueOf(this.refs[source]);
+        const ollamaBase = valueOf(this.ollamaBaseURL);
+        const credential = await this.resolveCredential(ref);
         if (credential?.value === undefined || credential.value.length === 0) {
             throw new Error(`${source} API key is not configured`);
         }
         if (source === 'minimax' || source === 'minimax-cn')
             return fetchMiniMaxUsage(credential.value, source === 'minimax-cn' ? 'cn' : 'global', this.http, signal);
+        if (source === 'ollama-cloud')
+            return fetchOllamaUsage(credential.value, ollamaBase, this.http, signal);
         return source === 'opencode-go'
             ? fetchOpenCodeGoUsage(credential.value, this.http, signal)
             : fetchKimiCodeUsage(credential.value, this.http, signal);

package/lib/providers/external-usage.d.ts

@@ -5,4 +5,12 @@ type HttpFetch = typeof fetch;
 export declare function fetchOpenCodeGoUsage(apiKey: string, http?: HttpFetch, signal?: AbortSignal): Promise<ProviderUsage>;
 /** Read official CLI count windows and retain compatibility with older ratio pools. */
 export declare function fetchKimiCodeUsage(apiKey: string, http?: HttpFetch, signal?: AbortSignal): Promise<ProviderUsage>;
+/**
+ * Read Ollama Cloud quota from `GET {base}/balance`. The Cloud has no
+ * `limits` object: quota is the included allowance against its remaining
+ * balance (`included.allowance_usd`, `included.balance_usd`) over the
+ * reported period. A 404 means a self-hosted endpoint without the
+ * surface: not an error, the card renders an unsupported note instead.
+ */
+export declare function fetchOllamaUsage(apiKey: string, baseURL: string, http?: HttpFetch, signal?: AbortSignal): Promise<ProviderUsage>;
 export {};

package/lib/providers/external-usage.js

@@ -1,5 +1,6 @@
 /** Usage readers for subscriptions whose model adapters are built into DSH. */
-import { parseProviderJson } from './common.js';
+import { attributionHeaders } from '@deepseek-ai/dsh-llm';
+import { parseProviderJson, readBoundedJson } from './common.js';
 function numeric(value) {
     const n = typeof value === 'string' && value.trim() !== '' ? Number(value) : value;
     return typeof n === 'number' && Number.isFinite(n) ? n : undefined;
@@ -23,7 +24,10 @@ function record(value) {
         : undefined;
 }
 function percent(value) {
-    return typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= 100
+    return typeof value === 'number' &&
+        Number.isFinite(value) &&
+        value >= 0 &&
+        value <= 100
         ? value
         : undefined;
 }
@@ -59,14 +63,24 @@ export async function fetchOpenCodeGoUsage(apiKey, http = fetch, signal) {
         if (usedPercent === undefined)
             continue;
         const resetsAt = resetTime(value?.resetsAt);
+        // Monthly has no interval fields. Both key providers' monthly pools
+        // read the same display assumption: a 30-day span back from the
+        // reset, clamped to now. Only the marker may ride it — pace never.
+        const monthlyDisplay = field === 'monthly' && resetsAt !== undefined
+            ? { displayStartsAt: Math.min(resetsAt - 30 * 86_400_000, Date.now()) }
+            : {};
         windows.push({
             kind,
             ...(scope === undefined ? {} : { scope }),
             usedPercent,
             // Go's rolling counter is first-use anchored, not per-request sliding.
-            ...(field === 'rolling' ? { fixedWindow: true, windowDurationMs: 18_000_000 }
-                : field === 'weekly' ? { fixedWindow: true, windowDurationMs: 604_800_000 } : {}),
+            ...(field === 'rolling'
+                ? { fixedWindow: true, windowDurationMs: 18_000_000 }
+                : field === 'weekly'
+                    ? { fixedWindow: true, windowDurationMs: 604_800_000 }
+                    : {}),
             ...(resetsAt === undefined ? {} : { resetsAt }),
+            ...monthlyDisplay,
         });
     }
     if (windows.length === 0)
@@ -79,40 +93,80 @@ export async function fetchKimiCodeUsage(apiKey, http = fetch, signal) {
     if (body === undefined)
         throw new Error('Kimi Code usage response is not an object');
     const modern = [];
+    // Only the top-level `usage` object is the summary the official CLI labels
+    // "Weekly limit"; an anonymous `limits[]` entry is "Limit #n" there.
     const rows = [
-        ...(record(body.usage) ? [{ detail: body.usage }] : []),
-        ...(Array.isArray(body.limits) ? body.limits : []),
+        ...(record(body.usage)
+            ? [{ raw: { detail: body.usage }, summary: true }]
+            : []),
+        ...(Array.isArray(body.limits)
+            ? body.limits.map((raw) => ({ raw, summary: false }))
+            : []),
     ];
-    for (const raw of rows) {
+    for (const { raw, summary } of rows) {
         const item = record(raw);
         if (!item)
             continue;
         const detail = record(item.detail) ?? item;
         const limit = numeric(detail.limit);
-        const used = numeric(detail.used) ?? (limit !== undefined && numeric(detail.remaining) !== undefined
-            ? limit - numeric(detail.remaining) : undefined);
+        const used = numeric(detail.used) ??
+            (limit !== undefined && numeric(detail.remaining) !== undefined
+                ? limit - numeric(detail.remaining)
+                : undefined);
         if (limit === undefined || limit <= 0 || used === undefined)
             continue;
-        const usedPercent = percent(used / limit * 100);
+        const usedPercent = percent((used / limit) * 100);
         if (usedPercent === undefined)
             continue;
         const window = record(item.window) ?? item;
         const duration = numeric(window.duration ?? item.duration ?? detail.duration);
         const unit = String(window.timeUnit ?? item.timeUnit ?? detail.timeUnit ?? '').toUpperCase();
-        const multiplier = unit.includes('MINUTE') ? 60_000 : unit.includes('HOUR') ? 3_600_000
-            : unit.includes('DAY') ? 86_400_000 : unit.includes('SECOND') ? 1000 : undefined;
+        const multiplier = unit.includes('MINUTE')
+            ? 60_000
+            : unit.includes('HOUR')
+                ? 3_600_000
+                : unit.includes('DAY')
+                    ? 86_400_000
+                    : unit.includes('SECOND')
+                        ? 1000
+                        : undefined;
         const durationMs = duration === undefined || duration <= 0 || multiplier === undefined
-            ? undefined : duration * multiplier;
-        const kind = durationMs === 18_000_000 ? 'session' : durationMs === 604_800_000 ? 'weekly' : 'other';
+            ? undefined
+            : duration * multiplier;
+        const kind = durationMs === 18_000_000
+            ? 'session'
+            : durationMs === 604_800_000
+                ? 'weekly'
+                : // No period fields at all: the official CLI labels the top-level
+                    // summary the weekly limit, so use that kind rather than 'other'.
+                    durationMs === undefined && unit === ''
+                        ? 'weekly'
+                        : 'other';
         const resetsAt = kimiReset(detail);
         const scope = detail.name ?? detail.title ?? item.name ?? item.title;
-        modern.push({ kind, usedPercent,
+        // A vendor-declared span anchors the display marker at
+        // min(reset − span, now); pace stays unverified (rolling semantics
+        // are not established), so the assumed instant rides displayStartsAt.
+        // The top-level summary without a usable period (absent, zero, or no
+        // unit) is read as the weekly limit (above), so its marker assumes seven
+        // days. The official CLI
+        // gives only the label, not a span; the span rests on a live account
+        // whose summary reset matched `usages.limit_7d` to within a second.
+        // An anonymous `limits[]` entry gets no such assumption. Display only.
+        const markerSpan = durationMs ?? (summary && kind === 'weekly' ? 604_800_000 : undefined);
+        const displayStart = resetsAt !== undefined && markerSpan !== undefined
+            ? { displayStartsAt: Math.min(resetsAt - markerSpan, Date.now()) }
+            : {};
+        modern.push({
+            kind,
+            usedPercent,
             ...(typeof scope === 'string' ? { scope } : {}),
             ...(resetsAt === undefined ? {} : { resetsAt }),
             ...(durationMs === undefined ? {} : { windowDurationMs: durationMs }),
-            // Legacy weekly plans reset as whole seven-day buckets; five-hour semantics
-            // are documented as rolling, so no fixed-window assertion is made there.
-            ...(kind === 'weekly' ? { fixedWindow: true } : {}),
+            // A whole seven-day bucket reset, not a rolling span, only where the
+            // endpoint actually said 7 DAY.
+            ...(durationMs === 604_800_000 ? { fixedWindow: true } : {}),
+            ...displayStart,
         });
     }
     if (modern.length)
@@ -128,16 +182,82 @@ export async function fetchKimiCodeUsage(apiKey, http = fetch, signal) {
     ]) {
         const value = record(usages[field]);
         const ratio = value?.used_ratio ?? value?.usedRatio;
-        if (typeof ratio !== 'number' || !Number.isFinite(ratio) || ratio < 0 || ratio > 1)
+        if (typeof ratio !== 'number' ||
+            !Number.isFinite(ratio) ||
+            ratio < 0 ||
+            ratio > 1)
             continue;
         const resetsAt = resetTime(value?.reset_time ?? value?.resetAt);
+        // The monthly total resets on the subscription's cycle, not the
+        // calendar month; the display marker assumes ~30 days back. It only
+        // moves the marker — pace never rides it.
+        const monthlyDisplay = field === 'limit_month_total' && resetsAt !== undefined
+            ? { displayStartsAt: Math.min(resetsAt - 30 * 86_400_000, Date.now()) }
+            : {};
         windows.push({
             kind,
             ...(scope === undefined ? {} : { scope }),
             usedPercent: ratio * 100,
-            ...(field === 'limit_7d' ? { fixedWindow: true, windowDurationMs: 604_800_000 } : {}),
+            ...(field === 'limit_7d'
+                ? { fixedWindow: true, windowDurationMs: 604_800_000 }
+                : {}),
             ...(resetsAt === undefined ? {} : { resetsAt }),
+            ...monthlyDisplay,
         });
     }
     return { supported: true, windows, plan: 'Kimi Code' };
 }
+/**
+ * Read Ollama Cloud quota from `GET {base}/balance`. The Cloud has no
+ * `limits` object: quota is the included allowance against its remaining
+ * balance (`included.allowance_usd`, `included.balance_usd`) over the
+ * reported period. A 404 means a self-hosted endpoint without the
+ * surface: not an error, the card renders an unsupported note instead.
+ */
+export async function fetchOllamaUsage(apiKey, baseURL, http = fetch, signal) {
+    const combined = signal === undefined
+        ? AbortSignal.timeout(15_000)
+        : AbortSignal.any([AbortSignal.timeout(15_000), signal]);
+    const response = await http(`${baseURL.replace(/\/+$/, '')}/balance`, {
+        headers: {
+            accept: 'application/json',
+            authorization: `Bearer ${apiKey}`,
+            ...attributionHeaders(),
+        },
+        redirect: 'error',
+        signal: combined,
+    });
+    if (signal?.aborted)
+        throw signal.reason;
+    if (response.status === 404)
+        return { supported: false };
+    if (!response.ok)
+        throw new Error(`Usage endpoint returned HTTP ${response.status}`);
+    const body = record(await readBoundedJson(response, 'usage', 1 * 1024 * 1024));
+    const included = record(body?.included);
+    const allowance = numeric(included?.allowance_usd);
+    const balance = numeric(included?.balance_usd);
+    if (included === undefined ||
+        allowance === undefined ||
+        allowance <= 0 ||
+        balance === undefined) {
+        throw new Error('Ollama balance response has no usable included allowance');
+    }
+    const period = record(included.period);
+    const resetsAt = period === undefined ? undefined : resetTime(period.until);
+    const startsAt = period === undefined ? undefined : resetTime(period.from);
+    return {
+        supported: true,
+        windows: [
+            {
+                kind: 'other',
+                scope: 'Credits',
+                // An overdrawn balance stays visible instead of dropping the window.
+                usedPercent: ((allowance - balance) / allowance) * 100,
+                ...(resetsAt === undefined ? {} : { resetsAt }),
+                ...(startsAt === undefined ? {} : { startsAt }),
+            },
+        ],
+        plan: 'Ollama Cloud',
+    };
+}