@jingyi0605/codingns4dsh 0.2.1-rc.2 → 0.2.1-rc.4

package/data/build/dist/host/cli-adapters/magpie-usage.js

@@ -1,5 +1,6 @@
 import { spawnSync } from 'node:child_process';
 import { commandEnvironment, resolveCommandPath, runAsyncCommand, WINDOWS, withCommandSignal } from './process-utils.js';
+import { parseMagpieWebProviders } from './magpie-management.js';
 const MAGPIE_CATALOG_TTL_MS = 60_000;
 const MAGPIE_MODEL_METADATA_TTL_MS = 60_000;
 const MAGPIE_FAILURE_CACHE_TTL_MS = 5_000;
@@ -7,9 +8,14 @@ const MAX_MAGPIE_MODEL_METADATA_CACHE_ENTRIES = 4;
 const MAGPIE_MINIMUM_CLI_VERSION = [0, 1, 1295];
 const MAGPIE_CLI_TIMEOUT_MS = 10_000;
 const MAGPIE_HTTP_TIMEOUT_MS = 3_000;
+const MAGPIE_DASHBOARD_CACHE_TTL_MS = 15_000;
+const MAGPIE_PROVIDER_CATALOG_TTL_MS = 15_000;
 const MAX_MAGPIE_CLI_OUTPUT_BYTES = 512 * 1024;
 const MAX_MAGPIE_RESPONSE_BYTES = 2 * 1024 * 1024;
+const MAX_MAGPIE_ICON_FETCHES = 64;
 const MAX_MAGPIE_MODELS = 10_000;
+const MAX_MAGPIE_SESSION_SCAN_ROWS = 10_000;
+const MAX_MAGPIE_SESSION_IDENTITIES = 16;
 const MAX_MODEL_TOKEN_LIMIT = 1_000_000_000;
 const MAGPIE_MODEL_ID_PATTERN = '[A-Za-z0-9][A-Za-z0-9._-]*(?:/[A-Za-z0-9][A-Za-z0-9._:/-]*)+';
 const MAGPIE_AGENT_BY_ADAPTER = {
@@ -39,11 +45,7 @@ const MAGPIE_USAGE_AGENT_ALIASES = {
     // usage ledger, while its verified model catalog uses `commandcode`.
     commandcode: ['commandcode', 'codingns4dsh'],
 };
-/**
- * Reads Magpie's public local Gateway API only after its CLI confirms that the
- * current Agent model is in that Agent's catalog. No Agent or Magpie config
- * files are opened here; the provider session ID is supplied by the Host.
- */
+/** Reads usage from the authenticated local Magpie Web API and exact-matches session identity. */
 export class MagpieUsageService {
     readModels;
     readVersion;
@@ -51,6 +53,8 @@ export class MagpieUsageService {
     now;
     timeoutMs;
     lifetimeSignal;
+    webApi;
+    onDashboardTiming;
     /** Agent CLI verification remains isolated; model metadata below is Gateway-wide and shared. */
     catalogs = new Map();
     catalogLoads = new Map();
@@ -59,6 +63,10 @@ export class MagpieUsageService {
     modelMetadataLoads = new Map();
     versionCheck;
     versionLoad;
+    dashboardCache = new Map();
+    dashboardRefreshes = new Map();
+    quotaLogoCache = new Map();
+    providerCatalog;
     constructor(options = {}) {
         this.readModels = options.readModels ?? readMagpieModels;
         // An injected catalog reader represents the whole fake CLI boundary in
@@ -70,6 +78,8 @@ export class MagpieUsageService {
         this.now = options.now ?? Date.now;
         this.timeoutMs = options.timeoutMs ?? MAGPIE_HTTP_TIMEOUT_MS;
         this.lifetimeSignal = options.lifetimeSignal;
+        this.webApi = options.webApi;
+        this.onDashboardTiming = options.onDashboardTiming;
     }
     async read(session, signal, includeRoute = false, dshSessionId) {
         signal?.throwIfAborted();
@@ -77,10 +87,6 @@ export class MagpieUsageService {
         const requestedModelId = cleanText(session.modelId);
         if (agent === null || requestedModelId === null)
             return null;
-        const catalog = await this.loadCatalog(agent, signal);
-        const modelId = resolveCatalogModelId(agent, requestedModelId, catalog, requestedModelId);
-        if (catalog === null || modelId === null)
-            return null;
         const providerSessionId = cleanText(session.providerSessionId);
         const nativeSessionId = cleanText(dshSessionId);
         // Native DSH requests use the DSH session ID as their Magpie session
@@ -88,7 +94,19 @@ export class MagpieUsageService {
         const sessionId = providerSessionId !== null && providerSessionId !== nativeSessionId
             ? providerSessionId
             : agent === 'dsh' ? nativeSessionId : null;
-        return this.readFromGateway(agent, requestedModelId, catalog.gatewayOrigin, sessionId, signal, includeRoute);
+        // Command Code's ACP child tags loopback Magpie requests with the DSH
+        // session ID injected by the Host, so the ledger key differs from the ACP
+        // session ID shown in the panel. Older Hosts without that ID keep the
+        // provider ID so the panel still reports the same "no usage" state.
+        const magpieSessionId = agent === 'commandcode' ? nativeSessionId ?? sessionId : sessionId;
+        // During a rolling update the ACP child may still tag requests with its ACP
+        // session ID; fall back to it when the DSH-ID ledger row is absent.
+        const fallbackSessionId = agent === 'commandcode' && nativeSessionId !== null && sessionId !== null && nativeSessionId !== sessionId
+            ? sessionId
+            : null;
+        if (magpieSessionId === null)
+            return null;
+        return this.readFromWeb(agent, requestedModelId, sessionId, magpieSessionId, fallbackSessionId, signal, includeRoute);
     }
     /**
      * Mark Magpie models and enrich their public metadata. The marker is
@@ -174,47 +192,279 @@ export class MagpieUsageService {
         const metadata = await this.loadModelMetadata(catalog, signal);
         return metadata?.get(id) ?? null;
     }
-    async readFromGateway(agent, modelId, gatewayOrigin, sessionId, signal, includeRoute) {
+    /** Read bounded, graph-ready usage and quota data through authenticated Magpie Web. */
+    async readDashboard(period, signal) {
+        signal?.throwIfAborted();
+        const cached = this.dashboardCache.get(period);
+        if (cached !== undefined) {
+            if (this.now() - cached.loadedAt >= MAGPIE_DASHBOARD_CACHE_TTL_MS) {
+                void this.refreshDashboard(period).catch(() => undefined);
+            }
+            return cached.dashboard;
+        }
+        return this.refreshDashboard(period, signal);
+    }
+    /** Stream cumulative dashboard snapshots as each independent Web API part is ready. */
+    async *readDashboardStream(period, signal, force = false) {
+        signal?.throwIfAborted();
+        const cached = this.dashboardCache.get(period);
+        if (!force && cached !== undefined) {
+            const stale = this.now() - cached.loadedAt >= MAGPIE_DASHBOARD_CACHE_TTL_MS;
+            yield { part: 'cache', dashboard: cached.dashboard, stale };
+            if (!stale)
+                return;
+        }
+        let latest;
+        for await (const chunk of this.readDashboardNetwork(period, signal)) {
+            latest = chunk.dashboard;
+            yield chunk;
+        }
+        if (latest !== undefined)
+            this.dashboardCache.set(period, { dashboard: latest, loadedAt: this.now() });
+    }
+    async refreshDashboard(period, signal) {
+        const pending = this.dashboardRefreshes.get(period);
+        if (pending !== undefined)
+            return awaitWithSignal(pending, signal);
+        const request = (async () => {
+            let latest;
+            for await (const chunk of this.readDashboardNetwork(period, signal))
+                latest = chunk.dashboard;
+            if (latest === undefined)
+                throw new Error('Magpie dashboard returned no snapshot');
+            this.dashboardCache.set(period, { dashboard: latest, loadedAt: this.now() });
+            return latest;
+        })().finally(() => {
+            if (this.dashboardRefreshes.get(period) === request)
+                this.dashboardRefreshes.delete(period);
+        });
+        this.dashboardRefreshes.set(period, request);
+        return awaitWithSignal(request, signal);
+    }
+    async *readDashboardNetwork(period, signal) {
+        const capturedAt = new Date(this.now()).toISOString();
+        let dashboard = emptyMagpieDashboard(period, capturedAt);
+        let quotas = null;
+        let logoLoad;
+        const results = new Map([
+            ['usage', this.timedDashboardRead('usage', () => this.readWebJson(`/api/usage?period=${magpieWebPeriod(period)}`, signal))],
+            ['quotas', this.timedDashboardRead('quotas', () => this.readWebJson('/api/usage/quotas', signal))],
+            ['history', this.timedDashboardRead('history', () => this.readWebJson('/api/usage/quotas/history?days=30', signal))],
+        ]);
+        const completed = new Map();
+        while (results.size > 0) {
+            const result = await Promise.race(results.values());
+            results.delete(result.part);
+            const response = asRecord(result.value);
+            const partOk = result.ok && response?.ok === true;
+            const partValue = partOk ? response.value : undefined;
+            completed.set(result.part, partOk);
+            if (result.part === 'usage') {
+                const parsed = partOk ? parseMagpieDashboardUsage(partValue) : null;
+                dashboard = {
+                    ...dashboard,
+                    usageStatus: parsed === null ? 'unavailable' : 'available',
+                    aggregate: parsed?.aggregate ?? null,
+                    series: parsed?.series ?? [],
+                    agents: parsed?.agents ?? [],
+                    providers: parsed?.providers ?? [],
+                    models: parsed?.models ?? [],
+                    accounts: parsed?.accounts ?? [],
+                    sessions: parsed?.sessions ?? [],
+                    sessionCount: parsed?.sessionCount ?? null,
+                };
+            }
+            else if (result.part === 'quotas') {
+                quotas = partOk ? parseMagpieQuotaCards(partValue) : null;
+                dashboard = { ...dashboard, quotaStatus: quotas === null ? 'unavailable' : 'available', quotas: quotas ?? [] };
+                if (quotas !== null)
+                    logoLoad = this.timedDashboardRead('quota-logos', () => this.attachQuotaLogos(quotas, signal)).then((result) => result.value);
+            }
+            else {
+                const parsed = partOk ? parseMagpieQuotaHistory(partValue) : null;
+                dashboard = { ...dashboard, quotaHistoryStatus: parsed === null ? 'unavailable' : 'available', quotaHistory: parsed ?? [] };
+            }
+            yield { part: result.part, dashboard, stale: false };
+        }
+        dashboard = { ...dashboard, availabilityIssue: [...completed.values()].every((ok) => !ok) ? 'web-api-unavailable' : null };
+        yield { part: 'complete', dashboard, stale: false };
+        if (logoLoad !== undefined) {
+            dashboard = { ...dashboard, quotas: await logoLoad };
+            yield { part: 'logos', dashboard, stale: false };
+        }
+    }
+    async timedDashboardRead(part, read) {
+        const started = this.now();
+        try {
+            return { part: part === 'quota-logos' ? 'logos' : part, value: await read(), ok: true };
+        }
+        finally {
+            this.onDashboardTiming?.({ part, elapsedMs: Math.max(0, this.now() - started) });
+        }
+    }
+    /** Read one bounded Web API ledger page and exact-match session identities on Host. */
+    async readRequestPage(options, signal) {
+        signal?.throwIfAborted();
+        if (!isMagpieDashboardPeriod(options.period)
+            || !Number.isSafeInteger(options.offset) || options.offset < 0 || options.offset > 1_000_000
+            || !Number.isSafeInteger(options.limit) || options.limit < 1 || options.limit > 100)
+            return null;
+        const sessionId = options.sessionId === undefined ? null : cleanText(options.sessionId);
+        const sessionIds = options.sessionIds === undefined
+            ? []
+            : options.sessionIds.map(cleanText);
+        const sessionAgent = options.sessionAgent === undefined ? null : cleanText(options.sessionAgent);
+        if ((options.sessionId !== undefined && sessionId === null)
+            || sessionIds.some((value) => value === null)
+            || sessionIds.length > MAX_MAGPIE_SESSION_IDENTITIES
+            || (options.sessionAgent !== undefined && (sessionAgent === null || !isMagpieAgentId(sessionAgent)))
+            || ((sessionId === null) !== (sessionAgent === null))
+            || (sessionIds.length > 0 && sessionId === null))
+            return null;
+        const requestedSessionIds = sessionId === null
+            ? []
+            : [...new Set([sessionId, ...sessionIds.filter((value) => value !== null)])];
+        if (requestedSessionIds.length > MAX_MAGPIE_SESSION_IDENTITIES)
+            return null;
+        const readCandidatePage = async (offset, limit, querySessionId) => {
+            const query = new URLSearchParams({ period: magpieWebPeriod(options.period), limit: String(limit), offset: String(offset) });
+            if (querySessionId !== null)
+                query.set('q', querySessionId);
+            const response = await this.readWebJson(`/api/usage/requests?${query.toString()}`, signal);
+            if (!response.ok)
+                return null;
+            const root = asRecord(response.value);
+            const rows = root?.rows;
+            if (!Array.isArray(rows) || rows.length > 500)
+                return null;
+            return { rows, total: safeCount(root?.total) };
+        };
+        if (sessionId === null) {
+            const page = await readCandidatePage(options.offset, options.limit, null);
+            if (page === null)
+                return null;
+            const providerRecords = page.rows.some((row) => routeText(asRecord(row)?.agent) === 'codex')
+                ? await this.readProviderCatalog(signal)
+                : [];
+            const items = parseMagpieRequestRows(page.rows, null, null, providerRecords);
+            return {
+                period: options.period,
+                offset: options.offset,
+                limit: options.limit,
+                total: page.total,
+                hasMore: page.total === null ? page.rows.length >= options.limit : options.offset + page.rows.length < page.total,
+                sessionId,
+                sessionAgent,
+                items: items.slice(0, options.limit),
+            };
+        }
+        // Magpie's `q` is a free-text candidate search, not an exact session filter.
+        // Fetch candidates from the beginning and apply the exact filter before paging;
+        // otherwise unrelated rows can consume the requested page and hide valid rows.
+        //
+        // Scanning stops one match past the requested page: enough to fill it and to prove
+        // whether another page exists. `total` therefore stays `null` while the identity's
+        // candidate window is not exhausted; the page that reads the window's end reports
+        // the exact count. Aggregated DSH sessions scan every contributing identity so one
+        // provider conversation cannot hide another.
+        const candidateLimit = 100;
+        const requestedEnd = options.offset + options.limit;
+        const rawRowsByKey = new Map();
+        let fullyScanned = true;
+        const perIdentityScanLimit = Math.floor(MAX_MAGPIE_SESSION_SCAN_ROWS / requestedSessionIds.length);
+        const acceptedAgents = MAGPIE_USAGE_AGENT_ALIASES[sessionAgent] ?? [sessionAgent];
+        const acceptedSessionIds = new Set(requestedSessionIds);
+        const matchesIn = () => [...rawRowsByKey.values()].reduce((count, row) => {
+            const record = asRecord(row);
+            if (record === null)
+                return count;
+            if (!acceptedSessionIds.has(cleanText(record.session) ?? '') && !acceptedSessionIds.has(cleanText(record.native_session) ?? ''))
+                return count;
+            return acceptedAgents.includes(cleanText(record.agent) ?? '') ? count + 1 : count;
+        }, 0);
+        for (const querySessionId of requestedSessionIds) {
+            let candidateOffset = 0;
+            let reachedEnd = false;
+            while (!reachedEnd && candidateOffset < perIdentityScanLimit) {
+                const pageLimit = Math.min(candidateLimit, perIdentityScanLimit - candidateOffset);
+                const page = await readCandidatePage(candidateOffset, pageLimit, querySessionId);
+                if (page === null)
+                    return null;
+                for (const row of page.rows) {
+                    const key = magpieRequestRowKey(row);
+                    if (!rawRowsByKey.has(key))
+                        rawRowsByKey.set(key, row);
+                }
+                const pageLength = page.rows.length;
+                const nextOffset = candidateOffset + pageLength;
+                reachedEnd = pageLength === 0
+                    || nextOffset <= candidateOffset
+                    || (page.total === null ? pageLength < pageLimit : nextOffset >= page.total);
+                candidateOffset = nextOffset;
+                // Enough rows for this page plus one more: no need to read the rest of the window.
+                if (!reachedEnd && matchesIn() > requestedEnd)
+                    break;
+            }
+            if (!reachedEnd)
+                fullyScanned = false;
+        }
+        const rawRows = [...rawRowsByKey.values()];
+        const providerRecords = rawRows.some((row) => routeText(asRecord(row)?.agent) === 'codex')
+            ? await this.readProviderCatalog(signal)
+            : [];
+        const matching = parseMagpieRequestRows(rawRows, sessionId, sessionAgent, providerRecords, requestedSessionIds);
+        const total = fullyScanned ? matching.length : null;
+        return {
+            period: options.period,
+            offset: options.offset,
+            limit: options.limit,
+            total,
+            hasMore: !fullyScanned || matching.length > requestedEnd,
+            sessionId,
+            sessionAgent,
+            items: matching.slice(options.offset, requestedEnd),
+        };
+    }
+    async readFromWeb(agent, modelId, sessionId, magpieSessionId, fallbackSessionId, signal, includeRoute) {
         const capturedAt = new Date(this.now()).toISOString();
-        if (gatewayOrigin === null)
-            return unavailableMagpieSnapshot(agent, modelId, sessionId, this.now(), capturedAt);
         const [usageResult, quotaResult] = await Promise.all([
-            this.readGatewayJson(gatewayOrigin, '/v1/magpie/usage?period=today', signal),
-            this.readGatewayJson(gatewayOrigin, '/v1/magpie/quotas', signal),
+            this.readWebJson('/api/usage?period=today', signal),
+            this.readWebJson('/api/usage/quotas', signal),
         ]);
         const aggregate = usageResult.ok ? readTotals(usageResult.value) : null;
-        const sessionUsage = usageResult.ok && sessionId !== null
-            ? readSession(usageResult.value, agent, sessionId)
+        const primarySession = usageResult.ok && magpieSessionId !== null
+            ? readSession(usageResult.value, agent, magpieSessionId)
+            : null;
+        const fallbackSession = primarySession === null && usageResult.ok && fallbackSessionId !== null
+            ? readSession(usageResult.value, agent, fallbackSessionId)
             : null;
-        // A providerSessionId is not enough to prove that Magpie knows this Agent
-        // session. Require the exact Agent + ID pair in Magpie's own usage result
-        // before asking the route endpoint, and then verify its echoed identity.
-        const canReadRoute = includeRoute && sessionId !== null && sessionId.length <= 128 && sessionUsage !== null;
-        const routeResultPromise = canReadRoute
-            ? this.readGatewayJson(gatewayOrigin, `/v1/magpie/route?session=${encodeURIComponent(sessionId)}`, signal)
-            : Promise.resolve({ ok: false });
-        const routeHistoryResultPromise = canReadRoute
-            ? this.readGatewayJson(gatewayOrigin, `/v1/magpie/usage/requests?period=today&q=${encodeURIComponent(sessionId)}&limit=100`, signal)
-            : Promise.resolve({ ok: false });
-        const [routeResult, routeHistoryResult] = await Promise.all([routeResultPromise, routeHistoryResultPromise]);
-        const routeRead = sessionId === null
-            ? { status: 'session-unavailable', route: null }
-            : !includeRoute
-                ? { status: 'not-requested', route: null }
-                : !canReadRoute
-                    ? { status: 'unavailable', route: null }
-                    : !routeResult.ok
-                        ? { status: 'unavailable', route: null }
-                        : readRoute(routeResult.value, sessionId);
-        const routeHistory = routeHistoryResult.ok && sessionId !== null && sessionUsage !== null
-            ? readSessionRouteHistory(routeHistoryResult.value, agent, sessionId)
+        const sessionUsage = primarySession ?? fallbackSession;
+        const resolvedSessionId = primarySession !== null ? magpieSessionId : fallbackSession !== null ? fallbackSessionId : magpieSessionId;
+        if (sessionUsage === null)
+            return null;
+        const canReadRoute = includeRoute && resolvedSessionId !== null && resolvedSessionId.length <= 128;
+        const routeHistoryResult = canReadRoute
+            ? await this.readWebJson(`/api/usage/requests?period=today&offset=0&limit=100&q=${encodeURIComponent(resolvedSessionId)}`, signal)
+            : { ok: false };
+        const routeRows = routeHistoryResult.ok ? asRecord(routeHistoryResult.value)?.rows : null;
+        const routeHistoryValid = Array.isArray(routeRows) && routeRows.length <= 500;
+        const providerRecords = agent === 'codex' && routeHistoryValid
+            && routeRows.some((row) => routeText(asRecord(row)?.agent) === 'codex')
+            ? await this.readProviderCatalog(signal)
+            : [];
+        const routeHistory = routeHistoryResult.ok && routeHistoryValid && resolvedSessionId !== null
+            ? readSessionRouteHistory(routeHistoryResult.value, agent, resolvedSessionId, providerRecords)
             : [];
-        const route = routeRead.route === null
-            ? routeHistory[0]?.route ?? null
-            : enrichRouteWithHistory(routeRead.route, routeHistory);
+        const route = routeHistory[0]?.route ?? null;
         const routeStatus = route !== null
             ? 'available'
-            : routeRead.status;
+            : resolvedSessionId === null
+                ? 'session-unavailable'
+                : !includeRoute
+                    ? 'not-requested'
+                    : !canReadRoute || !routeHistoryValid
+                        ? 'unavailable'
+                        : 'no-route';
         const allQuotas = quotaResult.ok ? parseMagpieQuotas(quotaResult.value) : null;
         const routeProviders = [...new Set([
                 providerFromRoute(route),
@@ -224,9 +474,15 @@ export class MagpieUsageService {
             ? routeProviders
             : [providerFromModelId(modelId, agent)].filter((provider) => provider !== null);
         const upstreamProvider = upstreamProviders[0] ?? null;
-        const quotas = allQuotas === null
+        const sessionQuotas = allQuotas === null
             ? []
             : filterSessionQuotas(allQuotas, upstreamProviders, routeHistory);
+        const matchingQuotas = markSessionAccounts(sessionQuotas, routeHistory, route);
+        const quotas = allQuotas === null ? [] : await this.attachQuotaLogos(matchingQuotas, signal);
+        // 同厂商的其它账号单独下发：客户端分组展示，但绝不参与本会话余量。
+        const siblingQuotas = allQuotas === null
+            ? []
+            : await this.attachQuotaLogos(otherProviderAccounts(allQuotas, upstreamProviders, sessionQuotas), signal);
         return {
             agent,
             modelId,
@@ -234,6 +490,7 @@ export class MagpieUsageService {
             usageStatus: aggregate === null ? 'unavailable' : 'available',
             aggregate,
             sessionId,
+            ...(resolvedSessionId === null ? {} : { requestSessionId: resolvedSessionId }),
             session: sessionUsage,
             routeStatus,
             route,
@@ -241,8 +498,47 @@ export class MagpieUsageService {
             upstreamProviders,
             quotaStatus: allQuotas === null ? 'unavailable' : upstreamProviders.length === 0 ? 'provider-unavailable' : 'available',
             quotas,
+            ...(siblingQuotas.length === 0 ? {} : { providerAccounts: siblingQuotas }),
         };
     }
+    async attachQuotaLogos(quotas, signal) {
+        const requestAssetDataUrl = this.webApi?.requestAssetDataUrl;
+        if (typeof requestAssetDataUrl !== 'function')
+            return quotas;
+        const icons = [...new Set(quotas
+                .map((quota) => quota.icon)
+                .filter((icon) => icon !== undefined))].slice(0, MAX_MAGPIE_ICON_FETCHES);
+        if (icons.length === 0)
+            return quotas;
+        const logos = new Map();
+        await Promise.all(icons.map(async (icon) => {
+            const cached = this.quotaLogoCache.get(icon);
+            const logo = cached === undefined ? await this.readMagpieLogoDataUrl(icon, signal) : cached;
+            if (cached === undefined)
+                this.quotaLogoCache.set(icon, logo);
+            logos.set(icon, logo);
+        }));
+        return quotas.map((quota) => {
+            const logoDataUrl = quota.icon === undefined ? null : logos.get(quota.icon) ?? null;
+            return logoDataUrl === null ? quota : { ...quota, logoDataUrl };
+        });
+    }
+    async readMagpieLogoDataUrl(icon, signal) {
+        const requestAssetDataUrl = this.webApi?.requestAssetDataUrl;
+        if (typeof requestAssetDataUrl !== 'function')
+            return null;
+        for (const path of magpieIconAssetPaths(icon)) {
+            try {
+                const value = await requestAssetDataUrl.call(this.webApi, path, signal === undefined ? {} : { signal });
+                if (value !== null && value !== '')
+                    return value;
+            }
+            catch {
+                signal?.throwIfAborted();
+            }
+        }
+        return null;
+    }
     async loadCatalog(agent, signal) {
         const cached = this.catalogs.get(agent);
         const cacheTtl = cached?.catalog === null ? MAGPIE_FAILURE_CACHE_TTL_MS : MAGPIE_CATALOG_TTL_MS;
@@ -264,7 +560,12 @@ export class MagpieUsageService {
                     .catch(() => null);
             const [supported, catalog] = await Promise.all([supportedRequest, catalogRequest]);
             const result = supported ? catalog : null;
-            this.catalogs.set(agent, { catalog: result, loadedAt: this.now() });
+            const unavailableIssue = result !== null
+                ? null
+                : !supported
+                    ? this.versionCheck?.executableAvailable === true ? 'cli-version-unsupported' : 'cli-unavailable'
+                    : 'model-catalog-unavailable';
+            this.catalogs.set(agent, { catalog: result, unavailableIssue, loadedAt: this.now() });
             return result;
         })
             .catch(() => null)
@@ -320,13 +621,13 @@ export class MagpieUsageService {
         if (this.versionLoad !== undefined)
             return awaitWithSignal(this.versionLoad, signal);
         const load = this.readVersion(this.lifetimeSignal)
-            .then((value) => parseMagpieCliVersion(value))
-            .then((supported) => {
-            this.versionCheck = { supported, checkedAt: this.now() };
+            .then((value) => {
+            const supported = parseMagpieCliVersion(value);
+            this.versionCheck = { supported, executableAvailable: value !== null, checkedAt: this.now() };
             return supported;
         })
             .catch(() => {
-            this.versionCheck = { supported: false, checkedAt: this.now() };
+            this.versionCheck = { supported: false, executableAvailable: false, checkedAt: this.now() };
             return false;
         })
             .finally(() => { if (this.versionLoad === load)
@@ -363,22 +664,29 @@ export class MagpieUsageService {
             return { ok: false };
         }
     }
-}
-function unavailableMagpieSnapshot(agent, modelId, sessionId, now, capturedAt = new Date(now).toISOString()) {
-    return {
-        agent,
-        modelId,
-        capturedAt,
-        usageStatus: 'unavailable',
-        aggregate: null,
-        sessionId,
-        session: null,
-        routeStatus: sessionId === null ? 'session-unavailable' : 'unavailable',
-        route: null,
-        upstreamProvider: providerFromModelId(modelId, agent),
-        quotaStatus: 'unavailable',
-        quotas: [],
-    };
+    async readWebJson(path, signal) {
+        if (this.webApi === undefined)
+            return { ok: false };
+        try {
+            return { ok: true, value: await this.webApi.requestJson(path, signal === undefined ? {} : { signal }) };
+        }
+        catch {
+            signal?.throwIfAborted();
+            return { ok: false };
+        }
+    }
+    /** Provider management data is the canonical source when a usage row mislabels its upstream. */
+    async readProviderCatalog(signal) {
+        const cached = this.providerCatalog;
+        if (cached !== undefined && this.now() - cached.loadedAt < MAGPIE_PROVIDER_CATALOG_TTL_MS)
+            return cached.records;
+        const response = await this.readWebJson('/api/providers', signal);
+        const parsed = response.ok ? parseMagpieWebProviders(response.value) : null;
+        const records = parsed?.records ?? [];
+        if (parsed !== null)
+            this.providerCatalog = { records, loadedAt: this.now() };
+        return records;
+    }
 }
 function awaitWithSignal(task, signal) {
     if (signal === undefined)
@@ -635,13 +943,142 @@ async function runMagpieCommand(args, signal) {
 }
 /**
  * Magpie IDs normally match adapter IDs. Keep naming differences explicit;
- * every result is still checked against Magpie's own catalog output before
- * any Gateway request is made.
+ * it is used for exact Agent identity matching in Magpie usage records.
  */
 export function magpieAgentForAdapter(adapterId) {
     const agent = MAGPIE_AGENT_BY_ADAPTER[adapterId];
     return agent !== undefined && isMagpieAgentId(agent) ? agent : null;
 }
+/** Return the exact Magpie Agent identities accepted for one adapter. */
+export function magpieUsageAgentAliases(adapterId) {
+    const agent = magpieAgentForAdapter(adapterId);
+    return agent === null ? [] : MAGPIE_USAGE_AGENT_ALIASES[agent] ?? [agent];
+}
+/**
+ * Enrich dashboard session rows only after an exact `(Agent, session ID)` match.
+ * Provider session IDs and DSH IDs are both candidates because Command Code and
+ * native DSH use different identities across Magpie versions.
+ */
+export function attachMagpieSessionNames(dashboard, bindings) {
+    if (!Array.isArray(dashboard.sessions))
+        return dashboard;
+    const owners = new Map();
+    const ambiguous = new Set();
+    const ownerByGroup = new Map();
+    for (const binding of bindings) {
+        const dshSessionId = cleanText(binding.dshSessionId);
+        const name = cleanSessionName(binding.name);
+        if (dshSessionId === null)
+            continue;
+        // Magpie versions may record either the provider conversation ID or the
+        // DSH ID; both exact identities represent the same DSH session.
+        const providerSessionId = cleanText(binding.providerSessionId);
+        const ids = new Set([dshSessionId, providerSessionId].filter((value) => value !== null));
+        const groupKey = `dsh\u0000${dshSessionId}`;
+        const owner = ownerByGroup.get(groupKey) ?? {
+            groupKey,
+            dshSessionId,
+            agent: magpieAgentForAdapter(binding.adapterId) ?? binding.adapterId,
+            name,
+            ids: [...new Set(ids)],
+        };
+        if (ownerByGroup.has(groupKey)) {
+            ownerByGroup.set(groupKey, {
+                ...owner,
+                name: owner.name === null || name === null || owner.name === name ? owner.name ?? name : null,
+                ids: [...new Set([...owner.ids, ...ids])],
+            });
+        }
+        else {
+            ownerByGroup.set(groupKey, owner);
+        }
+        const currentOwner = ownerByGroup.get(groupKey);
+        for (const agent of magpieUsageAgentAliases(binding.adapterId)) {
+            for (const id of ids) {
+                const key = `${agent}\u0000${id}`;
+                if (ambiguous.has(key))
+                    continue;
+                const previous = owners.get(key);
+                if (previous !== undefined && previous.groupKey !== groupKey) {
+                    owners.delete(key);
+                    ambiguous.add(key);
+                }
+                else {
+                    owners.set(key, currentOwner);
+                }
+            }
+        }
+    }
+    for (const [key, owner] of owners) {
+        const currentOwner = ownerByGroup.get(owner.groupKey);
+        if (currentOwner !== undefined)
+            owners.set(key, currentOwner);
+    }
+    const grouped = new Map();
+    for (const row of dashboard.sessions) {
+        const aliasKey = `${row.agent}\u0000${row.id}`;
+        const owner = ambiguous.has(aliasKey) ? undefined : owners.get(aliasKey);
+        const groupKey = owner?.groupKey ?? `raw\u0000${row.agent}\u0000${row.id}`;
+        const current = grouped.get(groupKey);
+        if (current === undefined) {
+            const ids = new Set(owner?.ids ?? [row.id]);
+            ids.add(row.id);
+            const session = owner === undefined
+                ? row
+                : {
+                    ...row,
+                    id: owner.dshSessionId,
+                    agent: owner.agent,
+                    ...(owner.name === null ? {} : { dshSessionName: owner.name }),
+                    sessionIds: [...ids],
+                };
+            grouped.set(groupKey, { session, ids });
+            continue;
+        }
+        for (const id of owner?.ids ?? [row.id])
+            current.ids.add(id);
+        current.ids.add(row.id);
+        current.session = mergeMagpieUsageSessions(current.session, row, owner);
+    }
+    const sessions = [...grouped.values()].map(({ session, ids }) => {
+        if (ids.size <= 1 && session.sessionIds === undefined)
+            return session;
+        return { ...session, sessionIds: [...ids] };
+    });
+    if (sessions.length === dashboard.sessions.length && sessions.every((session, index) => session === dashboard.sessions[index]))
+        return dashboard;
+    return { ...dashboard, sessions };
+}
+function mergeMagpieUsageSessions(current, row, owner) {
+    return {
+        ...current,
+        id: owner?.dshSessionId ?? current.id,
+        agent: owner?.agent ?? current.agent,
+        calls: sumMagpieUsageMetric(current.calls, row.calls),
+        errors: sumMagpieUsageMetric(current.errors, row.errors),
+        retried: sumMagpieUsageMetric(current.retried, row.retried),
+        inputTokens: sumMagpieUsageMetric(current.inputTokens, row.inputTokens),
+        outputTokens: sumMagpieUsageMetric(current.outputTokens, row.outputTokens),
+        cacheReadTokens: sumMagpieUsageMetric(current.cacheReadTokens, row.cacheReadTokens),
+        cacheWriteTokens: sumMagpieUsageMetric(current.cacheWriteTokens, row.cacheWriteTokens),
+        reasoningTokens: sumMagpieUsageMetric(current.reasoningTokens, row.reasoningTokens),
+        cost: sumMagpieUsageMetric(current.cost, row.cost),
+        unpriced: sumMagpieUsageMetric(current.unpriced, row.unpriced),
+        credits: sumMagpieUsageMetric(current.credits, row.credits),
+        credited: sumMagpieUsageMetric(current.credited, row.credited),
+        timed: sumMagpieUsageMetric(current.timed, row.timed),
+        ttftMs: sumMagpieUsageMetric(current.ttftMs, row.ttftMs),
+        decodeMs: sumMagpieUsageMetric(current.decodeMs, row.decodeMs),
+        decodeTokens: sumMagpieUsageMetric(current.decodeTokens, row.decodeTokens),
+        decodeCount: sumMagpieUsageMetric(current.decodeCount, row.decodeCount),
+        ...(current.dshSessionName === undefined && owner?.name !== null && owner?.name !== undefined
+            ? { dshSessionName: owner.name }
+            : {}),
+    };
+}
+function sumMagpieUsageMetric(left, right) {
+    return left === null && right === null ? null : (left ?? 0) + (right ?? 0);
+}
 function isMagpieAgentId(value) {
     return value.length <= 64 && /^[a-z0-9][a-z0-9-]*$/u.test(value);
 }
@@ -728,48 +1165,8 @@ function readSession(value, agent, sessionId) {
     const usageAgent = cleanText(record?.agent);
     return record !== null && usageAgent !== null && totals !== null ? { id: sessionId, agent: usageAgent, ...totals } : null;
 }
-function readRoute(value, expectedSessionId) {
-    const envelope = asRecord(value);
-    if (envelope === null || cleanText(envelope.session) !== expectedSessionId || !('route' in envelope))
-        return { status: 'unavailable', route: null };
-    if (envelope.route === null)
-        return { status: 'no-route', route: null };
-    const record = asRecord(envelope.route);
-    if (record === null)
-        return { status: 'unavailable', route: null };
-    const tries = Array.isArray(record.tries)
-        ? record.tries.slice(0, 20).flatMap((item) => {
-            const attempt = asRecord(item);
-            if (attempt === null)
-                return [];
-            const model = routeText(attempt.model);
-            const provider = routeText(attempt.provider);
-            return [{
-                    model: model !== null && provider !== null && !model.includes('/') ? `${provider}/${model}` : model ?? provider,
-                    failed: routeText(attempt.fail) !== null,
-                }];
-        })
-        : [];
-    return {
-        status: 'available',
-        route: {
-            asked: routeText(record.asked),
-            group: routeText(record.group),
-            rule: readRule(record.rule),
-            model: routeText(record.model),
-            effort: routeText(record.effort),
-            tries,
-            done: typeof record.done === 'boolean' ? record.done : null,
-            status: routeStatusText(record.status),
-            served: routeText(record.served),
-            routeId: safeRouteId(record.id),
-            time: routeText(record.time),
-            providerAccount: routeText(record.providerAccount),
-        },
-    };
-}
 /** Read the durable request ledger when Magpie's short in-memory trace has expired. */
-function readSessionRouteHistory(value, agent, sessionId) {
+function readSessionRouteHistory(value, agent, sessionId, providerRecords = []) {
     const rows = asRecord(value)?.rows;
     if (!Array.isArray(rows) || rows.length > 500)
         return [];
@@ -779,9 +1176,11 @@ function readSessionRouteHistory(value, agent, sessionId) {
         const rowAgent = cleanText(record?.agent);
         const session = cleanText(record?.session);
         const nativeSession = cleanText(record?.native_session);
-        const provider = routeText(record?.provider);
         if (record === null || rowAgent === null || !usageAgents.includes(rowAgent)
-            || (session !== sessionId && nativeSession !== sessionId) || provider === null)
+            || (session !== sessionId && nativeSession !== sessionId))
+            return [];
+        const provider = normalizeMagpieRequestProvider(record, providerRecords);
+        if (provider === null)
             return [];
         const requested = routeText(record.req);
         const model = routeText(record.model);
@@ -814,18 +1213,19 @@ function routeTime(value) {
     const time = Date.parse(value);
     return Number.isFinite(time) ? time : 0;
 }
-function enrichRouteWithHistory(route, history) {
-    if (route.routeId === undefined || route.routeId === null)
-        return route;
-    const record = history.find((item) => item.route.routeId === route.routeId);
-    if (record === undefined)
-        return route;
-    return {
-        ...route,
-        time: route.time ?? record.route.time ?? null,
-        providerAccount: route.providerAccount ?? record.account,
-    };
-}
+/**
+ * 选出本会话确实使用过的上游账号配额。
+ *
+ * 归属必须严格：请求历史里没有出现的账号不能算作本会话的配额。
+ *
+ * - 账号维度能对上：只留命中的账号。
+ * - 上游不提供账号名（Codex 这类量贩账号没有 `user`），无从按账号筛选：保留该厂商
+ *   全部候选。过去这里返回空数组，`quotaStatus` 仍是 `available`，界面就只剩下
+ *   "上游没有报告配额窗口"的空态 —— 明明识别出了 `glorinfo-api-platform`，却看不到
+ *   它的额度。
+ * - 有账号记录但一条都不匹配：返回空，宁可显示"没有可用配额"也不能把别的账号的额度
+ *   说成本会话的。
+ */
 function filterSessionQuotas(quotas, providers, history) {
     return providers.flatMap((provider) => {
         const candidates = quotas.filter((quota) => quota.provider === provider);
@@ -834,7 +1234,53 @@ function filterSessionQuotas(quotas, providers, history) {
             .map((record) => record.account));
         if (accounts.size === 0)
             return candidates;
-        return candidates.filter((quota) => quota.user !== null && accounts.has(quota.user));
+        const matched = candidates.filter((quota) => quota.user !== null && accounts.has(quota.user));
+        return matched.length > 0 ? matched : candidates.filter((quota) => quota.user === null);
+    });
+}
+/**
+ * 与本会话同一厂商、但本会话没用过的其它账号。
+ *
+ * 单独返回而不是并进 `quotas`：客户端用它们做"同厂商账号分组"的补充展示，
+ * 但这些账号的额度绝不参与本会话余量判断。顺序沿用上游。
+ */
+function otherProviderAccounts(quotas, providers, sessionQuotas) {
+    const claimed = new Set(sessionQuotas.map((quota) => `${quota.provider}\u0000${quota.user ?? ''}`));
+    return providers.flatMap((provider) => quotas
+        .filter((quota) => quota.provider === provider)
+        .filter((quota) => quota.user !== null && !claimed.has(`${quota.provider}\u0000${quota.user}`)));
+}
+/**
+ * 标记本会话实际使用过的账号。
+ *
+ * 只有能追溯到会话请求记录的账号才标 `active`；route 的账号字段优先于请求历史，
+ * 因为它来自 Magpie 对这一次请求的精确归属。
+ *
+ * 账号名比对必须同时限定厂商：不同厂商的账号名会重名（WorkBuddy 与 WorkBuddy AI 都有
+ * `zj59122704501@gmail.com`），只比名字会把别的厂商的账号标成本会话正在使用。
+ * 无法确认时保持未标记，客户端据此显示"未知活动账号"，而不是随便挑一个账号当"正在使用"。
+ */
+function markSessionAccounts(quotas, history, route) {
+    const used = new Set(history
+        .filter((record) => record.account !== null)
+        .map((record) => `${record.provider}\u0000${record.account}`));
+    const routedProvider = providerFromRoute(route);
+    const routedAccount = route?.providerAccount ?? null;
+    const routedKey = routedAccount === null || routedProvider === null ? null : `${routedProvider}\u0000${routedAccount}`;
+    if (used.size === 0 && routedKey === null)
+        return quotas;
+    // 每个厂商只承认一个活动账号：精确路由优先，其次是首个命中的历史账号。
+    const claimed = new Set();
+    return quotas.map((quota) => {
+        if (quota.user === null)
+            return quota;
+        const key = `${quota.provider}\u0000${quota.user}`;
+        if (claimed.has(key))
+            return quota;
+        if (key !== routedKey && !used.has(key))
+            return quota;
+        claimed.add(key);
+        return { ...quota, active: true };
     });
 }
 function safeRouteId(value) {
@@ -866,6 +1312,7 @@ export function parseMagpieQuotas(value) {
         quotas.push({
             provider,
             name,
+            ...optionalQuotaIcon(record.icon),
             kind: routeText(record.kind),
             user: routeText(record.user),
             plan: routeText(record.plan),
@@ -873,22 +1320,519 @@ export function parseMagpieQuotas(value) {
             balance: routeText(record.balance),
             readAt: routeText(record.readAt),
             windows,
+            ...sessionQuotaDaily(record),
+            ...readQuotaAccountMeta(record),
         });
     }
     return quotas;
 }
+/** Normalize the live aggregate and per-dimension usage response. */
+export function parseMagpieDashboardUsage(value) {
+    const root = asRecord(value);
+    if (root === null)
+        return null;
+    const hasMetrics = ['calls', 'errors', 'input', 'output', 'cache_read', 'cache_write', 'cost'].some((key) => key in root);
+    if (!hasMetrics && !Array.isArray(root.series) && !Array.isArray(root.sessions))
+        return null;
+    const series = readMagpieSeries(root.series);
+    const agents = readMagpieUsageGroups(root.agents, 'agent');
+    const providers = readMagpieUsageGroups(root.providerKeys ?? root.providers, 'provider');
+    const models = readMagpieUsageGroups(root.models, 'model');
+    const accounts = readMagpieUsageGroups(root.accounts, 'account');
+    const sessions = readMagpieUsageSessions(root.sessions);
+    if (series === null || agents === null || providers === null || models === null || accounts === null || sessions === null)
+        return null;
+    return {
+        aggregate: readMagpieUsageMetrics(root),
+        series,
+        agents,
+        providers,
+        models,
+        accounts,
+        sessions,
+        sessionCount: safeCount(root.sessionCount),
+    };
+}
+/** Normalize quota cards while preserving nullable values and bounded history. */
+export function parseMagpieQuotaCards(value) {
+    const root = asRecord(value);
+    const rows = Array.isArray(value) ? value : Array.isArray(root?.data) ? root.data : null;
+    if (rows === null || rows.length > 512)
+        return null;
+    const quotas = [];
+    for (const row of rows) {
+        const record = asRecord(row);
+        const provider = routeText(record?.provider);
+        const name = routeText(record?.name);
+        if (record === null || provider === null || name === null
+            || !Array.isArray(record.windows) || record.windows.length > 64)
+            return null;
+        const windows = record.windows.flatMap((item) => {
+            const window = asRecord(item);
+            const windowName = routeText(window?.name);
+            if (window === null || windowName === null)
+                return [];
+            return [{
+                    name: windowName,
+                    usedPercent: quotaUsedPercent(window),
+                    remainingPercent: quotaRemainingPercent(window),
+                    resetsAt: routeText(window.resetsAt),
+                    display: routeText(window.display),
+                    amount: safeDecimal(window.amount),
+                    limit: safeDecimal(window.limit),
+                    unit: routeText(window.unit),
+                    holdsWhy: routeText(window.holdsWhy),
+                    runsOutAt: routeText(window.runsOutAt),
+                    runsOut: safeDecimal(window.runsOut),
+                }];
+        });
+        if (windows.length !== record.windows.length)
+            return null;
+        const dailyRecord = record.daily === undefined ? null : asRecord(record.daily);
+        const dailyPoints = dailyRecord === null ? [] : dailyRecord.days;
+        if (dailyRecord !== null && (!Array.isArray(dailyPoints) || dailyPoints.length > 366))
+            return null;
+        const days = (Array.isArray(dailyPoints) ? dailyPoints : []).flatMap((item) => {
+            const point = asRecord(item);
+            const day = routeText(point?.day);
+            if (point === null || day === null)
+                return [];
+            const used = safeDecimal(point.used);
+            return [{ day, used }];
+        });
+        if (days.length !== (Array.isArray(dailyPoints) ? dailyPoints.length : 0))
+            return null;
+        quotas.push({
+            provider,
+            name,
+            ...optionalQuotaIcon(record.icon),
+            kind: routeText(record.kind),
+            user: routeText(record.user),
+            plan: routeText(record.plan),
+            alias: routeText(record.alias),
+            balance: routeText(record.balance),
+            readAt: routeText(record.readAt),
+            windows,
+            daily: { since: routeText(dailyRecord?.since), days },
+            ...readQuotaAccountMeta(record),
+        });
+    }
+    return quotas;
+}
+export function parseMagpieQuotaHistory(value) {
+    const root = asRecord(value);
+    const rows = Array.isArray(value) ? value : Array.isArray(root?.data) ? root.data : null;
+    if (rows === null || rows.length > 512)
+        return null;
+    const history = [];
+    for (const row of rows) {
+        const record = asRecord(row);
+        const provider = routeText(record?.provider);
+        if (record === null || provider === null || !Array.isArray(record.lines) || record.lines.length > 64)
+            return null;
+        const lines = record.lines.flatMap((item) => {
+            const line = asRecord(item);
+            const name = routeText(line?.name);
+            if (line === null || name === null || !Array.isArray(line.points) || line.points.length > 2_000)
+                return [];
+            const points = line.points.flatMap((pointValue) => {
+                const point = asRecord(pointValue);
+                const at = routeText(point?.at);
+                return point === null || at === null ? [] : [{
+                        at,
+                        left: safeDecimal(point.left),
+                        start: routeText(point.start),
+                        resetsAt: routeText(point.resetsAt),
+                    }];
+            });
+            if (points.length !== line.points.length)
+                return [];
+            return [{ name, points }];
+        });
+        if (lines.length !== record.lines.length)
+            return null;
+        history.push({ provider, user: routeText(record.user), lines });
+    }
+    return history;
+}
+function readMagpieUsageMetrics(record) {
+    return {
+        calls: safeCount(record.calls),
+        errors: safeCount(record.errors),
+        retried: safeCount(record.retried),
+        inputTokens: safeCount(record.input),
+        outputTokens: safeCount(record.output),
+        cacheReadTokens: safeCount(record.cache_read),
+        cacheWriteTokens: safeCount(record.cache_write),
+        reasoningTokens: safeCount(record.reasoning),
+        cost: safeDecimal(record.cost),
+        unpriced: safeDecimal(record.unpriced),
+        credits: safeDecimal(record.credits),
+        credited: safeDecimal(record.credited),
+        timed: safeCount(record.timed),
+        ttftMs: safeDecimal(record.ttft_ms),
+        decodeMs: safeDecimal(record.decode_ms),
+        decodeTokens: safeCount(record.decode_out),
+        decodeCount: safeCount(record.decode_n),
+    };
+}
+function readMagpieSeries(value) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value) || value.length > 2_000)
+        return null;
+    return value.flatMap((item) => {
+        const record = asRecord(item);
+        return record === null ? [] : [{
+                time: routeText(record.time),
+                label: routeText(record.label),
+                ...readMagpieUsageMetrics(record),
+            }];
+    });
+}
+function readMagpieUsageGroups(value, dimension) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value) || value.length > 2_000)
+        return null;
+    const idKeys = {
+        agent: ['id', 'agent'],
+        provider: ['provider', 'id'],
+        model: ['model', 'id'],
+        account: ['account', 'id'],
+    };
+    const groups = value.flatMap((item) => {
+        const record = asRecord(item);
+        if (record === null)
+            return [];
+        const id = firstRouteText(record, idKeys[dimension]);
+        if (id === null)
+            return [];
+        return [{
+                id,
+                name: routeText(record.name),
+                provider: routeText(record.provider),
+                model: routeText(record.model),
+                account: routeText(record.account),
+                agent: routeText(record.agent ?? record.id),
+                ...readMagpieUsageMetrics(record),
+            }];
+    });
+    if (dimension !== 'provider')
+        return groups;
+    const byProvider = new Map();
+    for (const group of groups) {
+        const current = byProvider.get(group.id);
+        if (current === undefined) {
+            byProvider.set(group.id, group);
+            continue;
+        }
+        byProvider.set(group.id, {
+            ...current,
+            calls: sumNullable(current.calls, group.calls),
+            errors: sumNullable(current.errors, group.errors),
+            retried: sumNullable(current.retried, group.retried),
+            inputTokens: sumNullable(current.inputTokens, group.inputTokens),
+            outputTokens: sumNullable(current.outputTokens, group.outputTokens),
+            cacheReadTokens: sumNullable(current.cacheReadTokens, group.cacheReadTokens),
+            cacheWriteTokens: sumNullable(current.cacheWriteTokens, group.cacheWriteTokens),
+            reasoningTokens: sumNullable(current.reasoningTokens, group.reasoningTokens),
+            cost: sumNullable(current.cost, group.cost),
+            unpriced: sumNullable(current.unpriced, group.unpriced),
+            credits: sumNullable(current.credits, group.credits),
+            credited: sumNullable(current.credited, group.credited),
+            timed: sumNullable(current.timed, group.timed),
+            ttftMs: null,
+            decodeMs: null,
+            decodeTokens: sumNullable(current.decodeTokens, group.decodeTokens),
+            decodeCount: sumNullable(current.decodeCount, group.decodeCount),
+        });
+    }
+    return [...byProvider.values()];
+}
+function readMagpieUsageSessions(value) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value) || value.length > 2_000)
+        return null;
+    return value.flatMap((item) => {
+        const record = asRecord(item);
+        const id = cleanText(record?.id);
+        const agent = cleanText(record?.agent);
+        return record === null || id === null || agent === null ? [] : [{ id, agent, ...readMagpieUsageMetrics(record) }];
+    });
+}
+function parseMagpieRequestRows(rows, sessionId, sessionAgent, providerRecords = [], sessionIds = sessionId === null ? [] : [sessionId]) {
+    const acceptedAgents = sessionAgent === null ? null : MAGPIE_USAGE_AGENT_ALIASES[sessionAgent] ?? [sessionAgent];
+    const acceptedSessionIds = new Set(sessionIds);
+    return rows.flatMap((row) => {
+        const record = asRecord(row);
+        if (record === null)
+            return [];
+        const candidateSession = cleanText(record.session);
+        const nativeSession = cleanText(record.native_session);
+        const agent = cleanText(record.agent);
+        if (sessionId !== null
+            && (!acceptedSessionIds.has(candidateSession ?? '') && !acceptedSessionIds.has(nativeSession ?? '')
+                || agent === null || acceptedAgents === null || !acceptedAgents.includes(agent)))
+            return [];
+        const item = parseMagpieRequest(record, providerRecords);
+        return item === null ? [] : [sessionId === null ? item : { ...item, sessionId }];
+    });
+}
+function magpieRequestRowKey(value) {
+    const record = asRecord(value);
+    const routeId = safeRouteId(record?.route_id);
+    return routeId === null ? JSON.stringify(record) : `route:${routeId}`;
+}
+function parseMagpieRequest(record, providerRecords = []) {
+    const agent = routeText(record.agent);
+    const provider = normalizeMagpieRequestProvider(record, providerRecords);
+    const requestedModel = routeText(record.req);
+    const servedModel = routeText(record.served);
+    const group = requestedModel?.startsWith('group/') === true ? requestedModel.slice('group/'.length) : null;
+    return {
+        routeId: safeRouteId(record.route_id),
+        time: routeText(record.t),
+        agent,
+        provider,
+        account: normalizeMagpieRequestAccount(record, provider, providerRecords),
+        requestedModel,
+        servedModel,
+        group,
+        effort: routeText(record.effort),
+        inputTokens: safeCount(record.in),
+        outputTokens: safeCount(record.out),
+        cacheReadTokens: safeCount(record.cache_read),
+        cacheWriteTokens: safeCount(record.cache_write),
+        reasoningTokens: safeCount(record.reasoning),
+        cost: safeDecimal(record.cost),
+        priced: typeof record.priced === 'boolean' ? record.priced : null,
+        status: routeStatusText(record.status),
+        durationMs: safeDecimal(record.ms),
+        ttftMs: safeDecimal(record.ttft_ms),
+        firstTextMs: safeDecimal(record.first_text_ms),
+        firstReasoningMs: safeDecimal(record.first_reasoning_ms),
+        flowMs: safeDecimal(record.flow_ms),
+        sessionId: cleanText(record.session) ?? cleanText(record.native_session),
+    };
+}
+/** Session-filtered rows can omit the account label; use only the matching provider's safe catalog label. */
+function normalizeMagpieRequestAccount(record, provider, providerRecords) {
+    const account = routeText(record.providerAccount);
+    if (account !== null || provider === null)
+        return account;
+    const matches = providerRecords.filter((item) => item.id === provider);
+    return matches.length === 1 ? matches[0].account : null;
+}
+/**
+ * Magpie's usage ledger can retain a stale provider id after an Agent provider
+ * is renamed. Reconcile only Codex rows against the read-only provider catalog;
+ * arbitrary provider ids must remain untouched when the evidence is ambiguous.
+ */
+function normalizeMagpieRequestProvider(record, providerRecords) {
+    const provider = routeText(record.provider);
+    if (provider === null || routeText(record.agent)?.toLocaleLowerCase() !== 'codex')
+        return provider;
+    const codexProviders = providerRecords.filter((item) => item.accountAgent?.toLocaleLowerCase() === 'codex');
+    if (codexProviders.length === 0)
+        return provider;
+    const modelValues = [record.model, record.served, record.req]
+        .map(routeText)
+        .filter((value) => value !== null);
+    const matches = codexProviders.filter((candidate) => candidate.models.some((model) => modelValues.some((value) => magpieModelMatchesProvider(value, model.id, candidate.id))));
+    if (matches.length === 1)
+        return matches[0].id;
+    return codexProviders.length === 1 ? codexProviders[0].id : provider;
+}
+function magpieModelMatchesProvider(value, modelId, providerId) {
+    if (value === modelId)
+        return true;
+    const prefix = `${providerId}/`;
+    return modelId.startsWith(prefix) && value === modelId.slice(prefix.length);
+}
+function firstRouteText(record, keys) {
+    for (const key of keys) {
+        const value = routeText(record[key]);
+        if (value !== null)
+            return value;
+    }
+    return null;
+}
+function sumNullable(left, right) {
+    return left === null && right === null ? null : (left ?? 0) + (right ?? 0);
+}
+function isMagpieDashboardPeriod(value) {
+    return value === 'today' || value === 'week' || value === 'month' || value === 'all';
+}
+function magpieWebPeriod(period) {
+    switch (period) {
+        case 'today': return 'today';
+        case 'week': return '7d';
+        case 'month': return '30d';
+        case 'all': return 'all';
+    }
+}
+function emptyMagpieDashboard(period, capturedAt) {
+    return {
+        period,
+        capturedAt,
+        availabilityIssue: null,
+        usageStatus: 'unavailable',
+        aggregate: null,
+        series: [],
+        agents: [],
+        providers: [],
+        models: [],
+        accounts: [],
+        sessions: [],
+        sessionCount: null,
+        quotaStatus: 'unavailable',
+        quotas: [],
+        quotaHistoryStatus: 'unavailable',
+        quotaHistory: [],
+    };
+}
+/**
+ * 窗口使用的百分比。
+ *
+ * Magpie 的 `used` 始终是 0–100 的百分比（见其 `auth.usage` 契约），但 `remaining`
+ * 不一定：同一份数据里既有 `remaining: 96` 这种百分比，也有 `remaining: 86.57`
+ * 配 `amount: 322.25 / limit: 2400` 这种"剩余量"。凡是带 `limit`（或 `amount`）的窗口，
+ * `remaining` 一律按数量解释，不能直接当成 0–100 的百分比，否则 WorkBuddy 的
+ * `322 / 2400` 会被读成"剩余 86.57%"，和 `display` 里的数量对不上。
+ */
+function quotaUsedPercent(record) {
+    return safePercent(record.used);
+}
+function quotaRemainingPercent(record) {
+    const counted = safeDecimal(record.limit) !== null || safeDecimal(record.amount) !== null;
+    if (counted) {
+        const used = quotaUsedPercent(record);
+        return used === null ? null : 100 - used;
+    }
+    return safePercent(record.remaining);
+}
 function readQuotaWindow(record, name) {
     return {
         name,
-        usedPercent: safePercent(record.used),
-        remainingPercent: safePercent(record.remaining),
+        usedPercent: quotaUsedPercent(record),
+        remainingPercent: quotaRemainingPercent(record),
         resetsAt: routeText(record.resetsAt),
         display: routeText(record.display),
         amount: safeDecimal(record.amount),
         limit: safeDecimal(record.limit),
         unit: routeText(record.unit),
         holdsWhy: routeText(record.holdsWhy),
+        startsAt: routeText(record.startsAt),
+        runsOut: safeDecimal(record.runsOut),
+        runsOutAt: routeText(record.runsOutAt),
+    };
+}
+/**
+ * Read the daily check-in result of providers that have one (WorkBuddy, Trae, MiniMax).
+ *
+ * `outcome` stays an upstream string: the client only localizes the outcomes it knows, so a
+ * new vendor state never gets presented as a successful check-in.
+ */
+function readQuotaCheckin(value) {
+    const record = asRecord(value);
+    if (record === null)
+        return null;
+    const checkin = {
+        day: routeText(record.day),
+        at: routeText(record.at),
+        outcome: routeText(record.outcome),
+        credit: safeDecimal(record.credit),
+        streak: safeCount(record.streak),
     };
+    return Object.values(checkin).every((item) => item === null) ? null : checkin;
+}
+function readQuotaDaily(value) {
+    const record = asRecord(value);
+    if (record === null)
+        return undefined;
+    const points = record.days;
+    if (!Array.isArray(points) || points.length > 366)
+        return undefined;
+    const days = points.flatMap((item) => {
+        const point = asRecord(item);
+        const day = routeText(point?.day);
+        return point === null || day === null ? [] : [{ day, used: safeDecimal(point.used) }];
+    });
+    if (days.length !== points.length)
+        return undefined;
+    return { since: routeText(record.since), days };
+}
+/**
+ * Read a provider's remaining reset cards without exposing the vendor's raw record.
+ *
+ * `count` 缺失与 0 不同：上游在 0 张时会省略整个对象，因此这里只在对象存在时才返回，
+ * 客户端把缺失显示为"未知"而不是"没有可用重置卡"。
+ */
+function readQuotaResets(value) {
+    const record = asRecord(value);
+    if (record === null)
+        return null;
+    const eachPoints = record.each;
+    const each = Array.isArray(eachPoints)
+        ? eachPoints.flatMap((item) => {
+            const point = asRecord(item);
+            if (point === null)
+                return [];
+            return [{ window: routeText(point.window), until: routeText(point.until) }];
+        }).slice(0, 64)
+        : [];
+    return {
+        count: safeCount(record.count),
+        until: routeText(record.until),
+        each,
+        byWindow: record.byWindow === true,
+        fiveHour: safeCount(record.fiveHour),
+        weekly: safeCount(record.weekly),
+    };
+}
+/** 会话级配额卡只带上 `daily`；上游缺字段时整个属性不出现。 */
+function sessionQuotaDaily(record) {
+    const daily = readQuotaDaily(record.daily);
+    return daily === undefined ? {} : { daily };
+}
+/**
+ * Read the account-level fields shared by both quota parsers.
+ *
+ * `/api/usage/quotas` (session popover) and the dashboard read the same rows; keeping these
+ * fields in one place stops the two views drifting apart. Absent values stay `undefined` so
+ * older Magpie builds keep working.
+ */
+function readQuotaAccountMeta(record) {
+    const checkin = readQuotaCheckin(record.checkin);
+    const resets = readQuotaResets(record.resets);
+    return {
+        ...(typeof record.active === 'boolean' ? { active: record.active } : {}),
+        ...(checkin === null ? {} : { checkin }),
+        ...(record.checkins === true ? { checkins: true } : {}),
+        error: routeText(record.error),
+        until: routeText(record.until),
+        renew: routeText(record.renew),
+        ...(resets === null ? {} : { resets }),
+        credits: routeText(record.credits),
+    };
+}
+function optionalQuotaIcon(value) {
+    const icon = routeText(value);
+    if (icon === null)
+        return {};
+    if (/^file:[A-Za-z0-9][A-Za-z0-9._~-]{0,255}$/u.test(icon))
+        return { icon };
+    return /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/u.test(icon) ? { icon } : {};
+}
+function magpieIconAssetPaths(icon) {
+    if (/^file:[A-Za-z0-9][A-Za-z0-9._~-]{0,255}$/u.test(icon)) {
+        return [`/api/icons/${encodeURIComponent(icon.slice('file:'.length))}`];
+    }
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/u.test(icon))
+        return [];
+    return [`/icons/${icon}.svg`, `/icons/${icon}.png`];
 }
 function providerFromRoute(route) {
     if (route === null)
@@ -947,6 +1891,12 @@ function cleanText(value) {
     const text = value.trim();
     return text === '' || text.length > 512 || /[\u0000-\u001f\u007f]/u.test(text) ? null : text;
 }
+function cleanSessionName(value) {
+    if (typeof value !== 'string')
+        return null;
+    const text = value.trim().replace(/[\u0000-\u001f\u007f]/gu, '').slice(0, 240);
+    return text === '' ? null : text;
+}
 /** Pi and Command Code store Magpie selections with a local `magpie/` provider prefix. */
 function resolveCatalogModelId(agent, requestedModelId, catalog, modelName) {
     if (catalog === null)