@velum-labs/routekit-daemon 0.13.0 → 0.15.0

package/dist/call-attribution-store.d.ts

@@ -11,6 +11,19 @@ export declare class CallAttributionStore implements ProvenanceSink {
         ttlMs?: number;
         now?: () => number;
     });
+    configureBudget(options: {
+        limit: number;
+        ttlMs: number;
+    }): void;
+    budget(): {
+        limit: number;
+        ttlMs: number;
+    };
     onModelCall(modelCall: ModelCallRecord): void;
     get(callId: string): RouteKitCallInspection | undefined;
+    /** Snapshot retained inspections after TTL prune (insertion order). */
+    list(): RouteKitCallInspection[];
+    /** True when the store has dropped records due to the capacity budget. */
+    truncated(): boolean;
+    size(): number;
 }

package/dist/call-attribution-store.js

@@ -93,11 +93,27 @@ export class CallAttributionStore {
     #limit;
     #ttlMs;
     #now;
+    #evicted = false;
     constructor(options = {}) {
         this.#limit = options.limit ?? DEFAULT_CALL_ATTRIBUTION_LIMIT;
         this.#ttlMs = options.ttlMs ?? DEFAULT_CALL_ATTRIBUTION_TTL_MS;
         this.#now = options.now ?? Date.now;
     }
+    configureBudget(options) {
+        this.#limit = options.limit;
+        this.#ttlMs = options.ttlMs;
+        this.#prune(this.#now());
+        while (this.#entries.size > this.#limit) {
+            const oldest = this.#entries.keys().next().value;
+            if (oldest === undefined)
+                break;
+            this.#entries.delete(oldest);
+            this.#evicted = true;
+        }
+    }
+    budget() {
+        return { limit: this.#limit, ttlMs: this.#ttlMs };
+    }
     onModelCall(modelCall) {
         const inspection = callInspection(modelCall);
         if (inspection === undefined)
@@ -111,12 +127,26 @@ export class CallAttributionStore {
             if (oldest === undefined)
                 break;
             this.#entries.delete(oldest);
+            this.#evicted = true;
         }
     }
     get(callId) {
         this.#prune(this.#now());
         return this.#entries.get(callId)?.inspection;
     }
+    /** Snapshot retained inspections after TTL prune (insertion order). */
+    list() {
+        this.#prune(this.#now());
+        return [...this.#entries.values()].map((entry) => entry.inspection);
+    }
+    /** True when the store has dropped records due to the capacity budget. */
+    truncated() {
+        return this.#evicted;
+    }
+    size() {
+        this.#prune(this.#now());
+        return this.#entries.size;
+    }
     #prune(now) {
         for (const [callId, entry] of this.#entries) {
             if (now - entry.insertedAt <= this.#ttlMs)

package/dist/index.js

@@ -8,10 +8,11 @@
  */
 import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, rmSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
-import { CLIPROXY_API_KEY_ENV, CLIPROXY_BASE_URL_ENV, accountStoreEntries, cliproxyAuthDirectory, cliproxyAccountEntries, cliproxyAccountMatchesKind, cliproxyApiKey, cliproxyBaseUrl, cliproxyCredentialValid, defaultSubscriptionAccountDirectory, RateLimitTracker, removeCliproxyAccount, removeSubscriptionAccount, renameSubscriptionAccount, sanitizeSubscriptionLabel } from "@velum-labs/routekit-accounts";
+import { AccountActivityCoordinator, CLIPROXY_API_KEY_ENV, CLIPROXY_BASE_URL_ENV, accountStoreEntries, cliproxyAuthDirectory, cliproxyAccountEntries, cliproxyAccountMatchesKind, cliproxyApiKey, cliproxyBaseUrl, cliproxyCredentialValid, defaultSubscriptionAccountDirectory, RateLimitTracker, removeCliproxyAccount, removeSubscriptionAccount, renameSubscriptionAccount, sanitizeSubscriptionLabel, subscriptionAccountIdentity } from "@velum-labs/routekit-accounts";
 import { configuredProviderIds, globalRouterConfigPath, parseRouterConfigDocument, routekitHome, writeRouterConfig } from "@velum-labs/routekit-config";
 import { createRouteKitControlHandler, ROUTEKIT_CONTROL_CAPABILITY } from "@velum-labs/routekit-control";
 import { startSwitchingGatewayProxy } from "@velum-labs/routekit-gateway";
+import { resolveLeaderboardConfig } from "@velum-labs/routekit-gateway";
 import { PROVIDERS, accountKindForCliproxyAuthType, resolveAccountConnector } from "@velum-labs/routekit-registry";
 import { startRouter } from "@velum-labs/routekit-router";
 import { acquireLifecycleLock, CONTROL_PROTOCOL_VERSION, ControlClient, ControlError, createPortlessSession, createServiceRecordStore, createTokenStore, encodeJoinCredential, extendCleanupGrace, generateControlToken, nextServiceGeneration, processIdentity, registerCleanup, SERVICE_HOME_MODE, startControlServer, supervisorFromEnv, writeFileAtomic } from "@velum-labs/routekit-runtime";
@@ -19,7 +20,8 @@ import { createConsentManager } from "@velum-labs/routekit-telemetry-core";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 import { createCliproxySidecar } from "./cliproxy-sidecar.js";
 import { cleanupAccountTransaction, markAccountTransactionCommitted, prepareAccountTransaction, recoverAccountTransactions, rollbackAccountTransaction } from "./account-transaction.js";
-import { CallAttributionStore } from "./call-attribution-store.js";
+import { CallAttributionStore, callInspection } from "./call-attribution-store.js";
+import { aggregateInspections, buildLeaderboardResult, LeaderboardRollupStore } from "./leaderboard.js";
 export const ROUTEKIT_DAEMON_KIND = "daemon";
 export const ROUTEKIT_PRODUCT = "routekit";
 function dataTokenPath(home) {
@@ -275,6 +277,7 @@ export async function startRouteKitDaemon(options) {
     let portless;
     let sidecarRef;
     let activeRouter;
+    let accountActivity;
     let record;
     let closed = false;
     let draining = false;
@@ -317,7 +320,39 @@ export async function startRouteKitDaemon(options) {
         writeRevisions(home, revisions);
         const sidecar = createCliproxySidecar({ env });
         sidecarRef = sidecar;
-        const callAttributions = new CallAttributionStore();
+        let leaderboardConfig = resolveLeaderboardConfig(currentConfig);
+        const callAttributions = new CallAttributionStore({
+            limit: leaderboardConfig.liveLimit,
+            ttlMs: leaderboardConfig.liveTtlHours * 60 * 60 * 1_000
+        });
+        const leaderboardRollups = new LeaderboardRollupStore({
+            home,
+            config: leaderboardConfig
+        });
+        // Independent of leaderboard durable rollups: last-selection only.
+        mkdirSync(join(home, "usage"), { recursive: true, mode: 0o700 });
+        accountActivity = new AccountActivityCoordinator({
+            statePath: join(home, "usage", "account-activity.v1.json")
+        });
+        const applyLeaderboardConfig = (config) => {
+            leaderboardConfig = resolveLeaderboardConfig(config);
+            callAttributions.configureBudget({
+                limit: leaderboardConfig.liveLimit,
+                ttlMs: leaderboardConfig.liveTtlHours * 60 * 60 * 1_000
+            });
+            leaderboardRollups.configure({
+                durable: leaderboardConfig.durable,
+                durableRetentionDays: leaderboardConfig.durableRetentionDays
+            });
+        };
+        const provenance = {
+            onModelCall(record) {
+                callAttributions.onModelCall(record);
+                const inspection = callInspection(record);
+                if (inspection !== undefined)
+                    leaderboardRollups.record(inspection);
+            }
+        };
         const wantsCliproxySidecar = (config) => config.providers["cliproxy"] !== undefined;
         // Router generations reach the managed sidecar with its own ingress key
         // and configured listen address; resolved per generation so state created
@@ -339,7 +374,8 @@ export async function startRouteKitDaemon(options) {
             host: "127.0.0.1",
             port: 0,
             env: routerEnv(),
-            provenance: callAttributions,
+            provenance,
+            activity: accountActivity,
             drainGraceMs
         });
         await sidecar.reconcile(wantsCliproxySidecar(currentConfig));
@@ -413,6 +449,7 @@ export async function startRouteKitDaemon(options) {
             currentConfig = nextConfig;
             currentDocument = input.write ? readFileSync(configPath, "utf8") : nextDocument;
             revisions = nextRevisions;
+            applyLeaderboardConfig(currentConfig);
             if (previousRouter !== undefined) {
                 try {
                     if (previousTarget !== undefined) {
@@ -600,6 +637,46 @@ export async function startRouteKitDaemon(options) {
                 }
                 return inspection;
             },
+            "calls.leaderboard": async (params) => {
+                const by = params.by ?? "principal";
+                const sort = params.sort ?? "cost";
+                const limit = params.limit ?? 20;
+                const window = params.window ?? "live";
+                const nowIso = new Date().toISOString();
+                if (window === "live") {
+                    const inspections = callAttributions.list();
+                    const aggregated = aggregateInspections(inspections, { by, sort, limit });
+                    return buildLeaderboardResult({
+                        by,
+                        sort,
+                        source: "live",
+                        windowStart: aggregated.windowStart ?? nowIso,
+                        windowEnd: aggregated.windowEnd ?? nowIso,
+                        sampleSize: aggregated.sampleSize,
+                        truncated: callAttributions.truncated(),
+                        budget: leaderboardConfig,
+                        rows: aggregated.rows
+                    });
+                }
+                if (!leaderboardConfig.durable) {
+                    throw new ControlError({
+                        code: "bad_request",
+                        message: "durable leaderboard rollups are disabled; set leaderboard.durable: true in router.yaml"
+                    });
+                }
+                const aggregated = leaderboardRollups.query({ by, sort, limit, window });
+                return buildLeaderboardResult({
+                    by,
+                    sort,
+                    source: "durable",
+                    windowStart: aggregated.windowStart,
+                    windowEnd: aggregated.windowEnd,
+                    sampleSize: aggregated.sampleSize,
+                    truncated: false,
+                    budget: leaderboardConfig,
+                    rows: aggregated.rows
+                });
+            },
             "accounts.list": async () => ({
                 accounts: accountEntries(env).map((entry) => {
                     if (entry.connector === "native")
@@ -618,6 +695,7 @@ export async function startRouteKitDaemon(options) {
                 return {
                     accounts: entries.map((entry) => {
                         if (entry.connector === "cliproxy") {
+                            const ready = entry.credentialValid && cliproxyConfigured && cliproxyReachable;
                             return {
                                 subscriptionKind: entry.subscriptionKind,
                                 label: entry.label,
@@ -625,8 +703,11 @@ export async function startRouteKitDaemon(options) {
                                 ...(entry.localOnly === true ? { localOnly: true } : {}),
                                 credentialValid: entry.credentialValid,
                                 configured: cliproxyConfigured,
-                                relayOpen: entry.credentialValid && cliproxyConfigured && cliproxyReachable,
-                                active: entry.credentialValid && cliproxyConfigured && cliproxyReachable,
+                                relayOpen: ready,
+                                serving: false,
+                                inFlight: 0,
+                                lastSelected: false,
+                                active: false,
                                 models: []
                             };
                         }
@@ -642,7 +723,13 @@ export async function startRouteKitDaemon(options) {
                             configured: currentConfig.providers[entry.subscriptionKind] !== undefined,
                             relayOpen: member?.relayReady === true &&
                                 currentConfig.providers[entry.subscriptionKind] !== undefined,
-                            active: member?.active ?? false,
+                            serving: member?.serving ?? false,
+                            inFlight: member?.inFlight ?? 0,
+                            ...(member?.lastSelectedAt !== undefined
+                                ? { lastSelectedAt: member.lastSelectedAt }
+                                : {}),
+                            lastSelected: member?.lastSelected ?? false,
+                            active: member?.lastSelected ?? false,
                             models: member?.models ?? [],
                             ...(member?.limits !== undefined ? { limits: member.limits } : {})
                         };
@@ -956,11 +1043,12 @@ export async function startRouteKitDaemon(options) {
                         const nextConfig = disableProvider
                             ? parseConfigDocument(nextDocument)
                             : currentConfig;
+                        const activityPath = join(home, "usage", "account-activity.v1.json");
                         const transaction = prepareAccountTransaction({
                             home,
                             configPath,
-                            accountPaths: [nativePath],
-                            accountRoots: [activeNativeDirectory],
+                            accountPaths: [nativePath, activityPath],
+                            accountRoots: [activeNativeDirectory, home],
                             kind: nativeKind,
                             provider: nativeKind,
                             labels: [params.label]
@@ -976,7 +1064,10 @@ export async function startRouteKitDaemon(options) {
                                 write: disableProvider,
                                 configRevision: disableProvider,
                                 accountRevision: true,
-                                beforeSwap: () => markAccountTransactionCommitted(transaction)
+                                beforeSwap: () => {
+                                    accountActivity.remove(subscriptionAccountIdentity(nativeKind, params.label));
+                                    markAccountTransactionCommitted(transaction);
+                                }
                             });
                             try {
                                 cleanupAccountTransaction(transaction);
@@ -989,6 +1080,7 @@ export async function startRouteKitDaemon(options) {
                             const rollbackFailures = [];
                             try {
                                 rollbackAccountTransaction(transaction, home);
+                                accountActivity?.reload();
                             }
                             catch (rollbackError) {
                                 rollbackFailures.push(rollbackError);
@@ -1057,6 +1149,7 @@ export async function startRouteKitDaemon(options) {
                     const sourcePath = join(directory, `${params.source}.json`);
                     const targetPath = join(directory, `${params.target}.json`);
                     const trackerPath = join(directory, ".state.json");
+                    const activityPath = join(home, "usage", "account-activity.v1.json");
                     if (!existsSync(sourcePath)) {
                         throw new ControlError({
                             code: "not_found",
@@ -1082,8 +1175,8 @@ export async function startRouteKitDaemon(options) {
                     const transaction = prepareAccountTransaction({
                         home,
                         configPath,
-                        accountPaths: [sourcePath, targetPath, trackerPath],
-                        accountRoots: [directory],
+                        accountPaths: [sourcePath, targetPath, trackerPath, activityPath],
+                        accountRoots: [directory, home],
                         kind,
                         provider: kind,
                         labels: [params.source, params.target]
@@ -1097,7 +1190,10 @@ export async function startRouteKitDaemon(options) {
                         await replaceRouter(currentConfig, currentDocument, {
                             write: false,
                             accountRevision: true,
-                            beforeSwap: () => markAccountTransactionCommitted(transaction)
+                            beforeSwap: () => {
+                                accountActivity.rename(subscriptionAccountIdentity(kind, params.source), subscriptionAccountIdentity(kind, params.target));
+                                markAccountTransactionCommitted(transaction);
+                            }
                         });
                         try {
                             cleanupAccountTransaction(transaction);
@@ -1110,6 +1206,7 @@ export async function startRouteKitDaemon(options) {
                         const rollbackFailures = [];
                         try {
                             rollbackAccountTransaction(transaction, home);
+                            accountActivity?.reload();
                         }
                         catch (rollbackError) {
                             rollbackFailures.push(rollbackError);
@@ -1138,6 +1235,43 @@ export async function startRouteKitDaemon(options) {
             "accounts.usage": async (_params, context) => {
                 return await activeRouter.usage(context.signal);
             },
+            "accounts.redeemReset": async (params, context) => {
+                try {
+                    const result = await activeRouter.redeemReset({
+                        kind: params.kind,
+                        label: params.label,
+                        ...(params.creditId !== undefined ? { creditId: params.creditId } : {}),
+                        ...(params.redeemRequestId !== undefined
+                            ? { redeemRequestId: params.redeemRequestId }
+                            : {})
+                    }, context.signal);
+                    return {
+                        ok: result.ok,
+                        code: result.code,
+                        kind: "codex",
+                        label: result.label,
+                        redeemRequestId: result.redeemRequestId,
+                        ...(result.creditId !== undefined ? { creditId: result.creditId } : {}),
+                        ...(result.windowsReset !== undefined
+                            ? { windowsReset: result.windowsReset }
+                            : {}),
+                        usage: result.usage
+                    };
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    if (message.includes("is not enrolled") || message.includes("no redeemable")) {
+                        throw new ControlError({ code: "not_found", message });
+                    }
+                    if (message.includes("does not support") ||
+                        message.includes("no codex account pool") ||
+                        message.includes("creditId must not be empty") ||
+                        message.includes("account label is required")) {
+                        throw new ControlError({ code: "bad_request", message });
+                    }
+                    throw new ControlError({ code: "internal", message });
+                }
+            },
             "telemetry.get": async () => ({ enabled: telemetry.resolve().enabled }),
             "telemetry.set": async (params) => {
                 await serializeMutation(async () => {
@@ -1262,7 +1396,7 @@ export async function startRouteKitDaemon(options) {
                         token: issued.token,
                         ...(issued.plane === "control"
                             ? {
-                                joinToken: encodeJoinCredential({
+                                joinCredential: encodeJoinCredential({
                                     publicRecordPath: daemonPublicRecordPath(home),
                                     token: issued.token
                                 })
@@ -1364,6 +1498,7 @@ export async function startRouteKitDaemon(options) {
                 lifecycle = "draining";
                 await proxy?.drain(drainGraceMs);
                 await activeRouter?.close();
+                accountActivity?.close();
                 await sidecar.close();
                 await control?.close();
                 if (portless?.enabled)
@@ -1400,6 +1535,7 @@ export async function startRouteKitDaemon(options) {
     catch (error) {
         await proxy?.close();
         await activeRouter?.close();
+        accountActivity?.close();
         await sidecarRef?.close();
         await control?.close();
         if (portless?.enabled)

package/dist/leaderboard.d.ts

@@ -0,0 +1,52 @@
+import type { RouteKitCallInspection, RouteKitControlParams, RouteKitLeaderboard } from "@velum-labs/routekit-control";
+import type { LeaderboardConfig } from "@velum-labs/routekit-gateway";
+export type LeaderboardDimension = RouteKitLeaderboard["by"];
+export type LeaderboardSort = RouteKitLeaderboard["sort"];
+export type LeaderboardWindow = NonNullable<RouteKitControlParams["calls.leaderboard"]["window"]>;
+export declare const LEADERBOARD_ROLLUP_VERSION: 1;
+export declare const LEADERBOARD_ROLLUP_RELATIVE_PATH: string;
+export declare function aggregateInspections(inspections: readonly RouteKitCallInspection[], options: {
+    by: LeaderboardDimension;
+    sort: LeaderboardSort;
+    limit: number;
+}): {
+    rows: RouteKitLeaderboard["rows"];
+    sampleSize: number;
+    windowStart?: string;
+    windowEnd?: string;
+};
+export declare class LeaderboardRollupStore {
+    #private;
+    constructor(options: {
+        home: string;
+        config: LeaderboardConfig;
+        now?: () => number;
+        flushDelayMs?: number;
+    });
+    configure(config: Pick<LeaderboardConfig, "durable" | "durableRetentionDays">): void;
+    record(inspection: RouteKitCallInspection): void;
+    flush(): void;
+    query(options: {
+        by: LeaderboardDimension;
+        sort: LeaderboardSort;
+        limit: number;
+        window: Exclude<LeaderboardWindow, "live">;
+    }): {
+        rows: RouteKitLeaderboard["rows"];
+        sampleSize: number;
+        windowStart: string;
+        windowEnd: string;
+    };
+    path(): string;
+}
+export declare function buildLeaderboardResult(input: {
+    by: LeaderboardDimension;
+    sort: LeaderboardSort;
+    source: RouteKitLeaderboard["source"];
+    windowStart: string;
+    windowEnd: string;
+    sampleSize: number;
+    truncated: boolean;
+    budget: LeaderboardConfig;
+    rows: RouteKitLeaderboard["rows"];
+}): RouteKitLeaderboard;

package/dist/leaderboard.js

@@ -0,0 +1,404 @@
+/**
+ * Usage leaderboard aggregation over live call attribution and optional
+ * durable hourly rollups under `$ROUTEKIT_HOME/usage/`.
+ */
+import { chmodSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { writeFileAtomic } from "@velum-labs/routekit-runtime";
+export const LEADERBOARD_ROLLUP_VERSION = 1;
+export const LEADERBOARD_ROLLUP_RELATIVE_PATH = join("usage", "leaderboard-rollups.v1.json");
+const WINDOW_MS = {
+    "1h": 60 * 60 * 1_000,
+    "24h": 24 * 60 * 60 * 1_000,
+    "7d": 7 * 24 * 60 * 60 * 1_000
+};
+function emptyCounters(key, label) {
+    return {
+        key,
+        ...(label !== undefined ? { label } : {}),
+        requests: 0,
+        success: 0,
+        error: 0,
+        tokensIn: 0,
+        tokensOut: 0,
+        tokensTotal: 0,
+        estimateUsd: 0,
+        unknownCostCount: 0,
+        unknownUsageCount: 0,
+        latencyMsSum: 0,
+        latencyMsCount: 0
+    };
+}
+function dimensionKey(inspection, by) {
+    switch (by) {
+        case "principal": {
+            const tokenId = inspection.principal?.tokenId;
+            if (tokenId === undefined)
+                return undefined;
+            return {
+                key: tokenId,
+                ...(inspection.principal?.label !== undefined
+                    ? { label: inspection.principal.label }
+                    : {})
+            };
+        }
+        case "model":
+            return { key: inspection.effectiveModel };
+        case "provider":
+            return { key: inspection.provider };
+    }
+}
+function addInspection(bucket, inspection, keepSamples) {
+    bucket.requests += 1;
+    if (inspection.status === "succeeded")
+        bucket.success += 1;
+    else
+        bucket.error += 1;
+    const usage = inspection.usage;
+    if (usage === undefined || inspection.cost.unknownUsage) {
+        bucket.unknownUsageCount += 1;
+    }
+    else {
+        bucket.tokensIn += usage.prompt_tokens ?? 0;
+        bucket.tokensOut += usage.completion_tokens ?? 0;
+        bucket.tokensTotal +=
+            usage.total_tokens ??
+                (usage.prompt_tokens ?? 0) + (usage.completion_tokens ?? 0);
+    }
+    if (inspection.cost.estimateUsd !== undefined && !inspection.cost.unknownCost) {
+        bucket.estimateUsd += inspection.cost.estimateUsd;
+    }
+    else if (inspection.cost.unknownCost || inspection.cost.estimateUsd === undefined) {
+        bucket.unknownCostCount += 1;
+    }
+    const latencyMs = inspection.timing.latencyMs;
+    if (latencyMs !== undefined) {
+        bucket.latencyMsSum += latencyMs;
+        bucket.latencyMsCount += 1;
+        if (keepSamples) {
+            bucket.latencySamples ??= [];
+            bucket.latencySamples.push(latencyMs);
+        }
+    }
+    if (bucket.label === undefined &&
+        inspection.principal?.label !== undefined &&
+        bucket.key === inspection.principal.tokenId) {
+        bucket.label = inspection.principal.label;
+    }
+}
+function mergeCounters(target, source) {
+    target.requests += source.requests;
+    target.success += source.success;
+    target.error += source.error;
+    target.tokensIn += source.tokensIn;
+    target.tokensOut += source.tokensOut;
+    target.tokensTotal += source.tokensTotal;
+    target.estimateUsd += source.estimateUsd;
+    target.unknownCostCount += source.unknownCostCount;
+    target.unknownUsageCount += source.unknownUsageCount;
+    target.latencyMsSum += source.latencyMsSum;
+    target.latencyMsCount += source.latencyMsCount;
+    if (target.label === undefined && source.label !== undefined) {
+        target.label = source.label;
+    }
+}
+function percentile(sorted, p) {
+    if (sorted.length === 0)
+        return undefined;
+    if (sorted.length === 1)
+        return sorted[0];
+    const index = Math.min(sorted.length - 1, Math.max(0, Math.ceil((p / 100) * sorted.length) - 1));
+    return sorted[index];
+}
+function sortValue(bucket, sort) {
+    switch (sort) {
+        case "cost":
+            return bucket.estimateUsd;
+        case "requests":
+            return bucket.requests;
+        case "tokens":
+            return bucket.tokensTotal;
+        case "errors":
+            return bucket.error;
+        case "latency":
+            return bucket.latencyMsCount === 0
+                ? 0
+                : bucket.latencyMsSum / bucket.latencyMsCount;
+    }
+}
+function toRow(bucket, rank) {
+    const samples = bucket.latencySamples?.slice().sort((a, b) => a - b);
+    const avg = bucket.latencyMsCount > 0
+        ? bucket.latencyMsSum / bucket.latencyMsCount
+        : undefined;
+    return {
+        rank,
+        key: bucket.key,
+        ...(bucket.label !== undefined ? { label: bucket.label } : {}),
+        requests: bucket.requests,
+        success: bucket.success,
+        error: bucket.error,
+        tokensIn: bucket.tokensIn,
+        tokensOut: bucket.tokensOut,
+        tokensTotal: bucket.tokensTotal,
+        ...(bucket.estimateUsd > 0 || bucket.unknownCostCount === 0
+            ? { estimateUsd: bucket.estimateUsd }
+            : {}),
+        unknownCostCount: bucket.unknownCostCount,
+        unknownUsageCount: bucket.unknownUsageCount,
+        ...(avg !== undefined ? { latencyMsAvg: avg } : {}),
+        ...(samples !== undefined
+            ? {
+                ...(percentile(samples, 50) !== undefined
+                    ? { latencyMsP50: percentile(samples, 50) }
+                    : {}),
+                ...(percentile(samples, 95) !== undefined
+                    ? { latencyMsP95: percentile(samples, 95) }
+                    : {})
+            }
+            : {})
+    };
+}
+export function aggregateInspections(inspections, options) {
+    const groups = new Map();
+    let windowStart;
+    let windowEnd;
+    for (const inspection of inspections) {
+        const dim = dimensionKey(inspection, options.by);
+        if (dim === undefined)
+            continue;
+        let bucket = groups.get(dim.key);
+        if (bucket === undefined) {
+            bucket = emptyCounters(dim.key, dim.label);
+            groups.set(dim.key, bucket);
+        }
+        addInspection(bucket, inspection, true);
+        const started = inspection.timing.startedAt;
+        if (windowStart === undefined || started < windowStart)
+            windowStart = started;
+        const finished = inspection.timing.finishedAt ?? started;
+        if (windowEnd === undefined || finished > windowEnd)
+            windowEnd = finished;
+    }
+    const ranked = [...groups.values()].sort((a, b) => {
+        const delta = sortValue(b, options.sort) - sortValue(a, options.sort);
+        if (delta !== 0)
+            return delta;
+        return a.key.localeCompare(b.key);
+    });
+    return {
+        rows: ranked.slice(0, options.limit).map((bucket, index) => toRow(bucket, index + 1)),
+        sampleSize: inspections.length,
+        ...(windowStart !== undefined ? { windowStart } : {}),
+        ...(windowEnd !== undefined ? { windowEnd } : {})
+    };
+}
+function hourFloor(iso) {
+    const date = new Date(iso);
+    if (Number.isNaN(date.getTime())) {
+        const fallback = new Date();
+        fallback.setUTCMinutes(0, 0, 0);
+        return fallback.toISOString();
+    }
+    date.setUTCMinutes(0, 0, 0);
+    return date.toISOString();
+}
+function serializeBucket(bucket) {
+    const { latencySamples: _samples, ...rest } = bucket;
+    return rest;
+}
+export class LeaderboardRollupStore {
+    #path;
+    #now;
+    #flushDelayMs;
+    #enabled;
+    #retentionDays;
+    #file;
+    #timer;
+    #dirty = false;
+    constructor(options) {
+        this.#path = join(options.home, LEADERBOARD_ROLLUP_RELATIVE_PATH);
+        this.#now = options.now ?? Date.now;
+        this.#flushDelayMs = options.flushDelayMs ?? 250;
+        this.#enabled = options.config.durable;
+        this.#retentionDays = options.config.durableRetentionDays;
+        this.#file = this.#load();
+    }
+    configure(config) {
+        this.#enabled = config.durable;
+        this.#retentionDays = config.durableRetentionDays;
+        this.#file.retentionDays = this.#retentionDays;
+        this.#prune(this.#now());
+        if (this.#enabled)
+            this.#scheduleFlush();
+    }
+    record(inspection) {
+        if (!this.#enabled)
+            return;
+        const hour = hourFloor(inspection.timing.startedAt);
+        let bucket = this.#file.buckets.find((entry) => entry.hour === hour);
+        if (bucket === undefined) {
+            bucket = { hour, byPrincipal: {}, byModel: {}, byProvider: {} };
+            this.#file.buckets.push(bucket);
+            this.#file.buckets.sort((a, b) => a.hour.localeCompare(b.hour));
+        }
+        for (const by of ["principal", "model", "provider"]) {
+            const dim = dimensionKey(inspection, by);
+            if (dim === undefined)
+                continue;
+            const map = by === "principal"
+                ? bucket.byPrincipal
+                : by === "model"
+                    ? bucket.byModel
+                    : bucket.byProvider;
+            let counters = map[dim.key];
+            if (counters === undefined) {
+                counters = emptyCounters(dim.key, dim.label);
+                map[dim.key] = counters;
+            }
+            addInspection(counters, inspection, false);
+            map[dim.key] = serializeBucket(counters);
+        }
+        this.#file.updatedAt = new Date(this.#now()).toISOString();
+        this.#prune(this.#now());
+        this.#dirty = true;
+        this.#scheduleFlush();
+    }
+    flush() {
+        if (this.#timer !== undefined) {
+            clearTimeout(this.#timer);
+            this.#timer = undefined;
+        }
+        if (!this.#dirty)
+            return;
+        this.#write();
+    }
+    query(options) {
+        this.flush();
+        const endMs = this.#now();
+        const startMs = endMs - WINDOW_MS[options.window];
+        const startIso = new Date(startMs).toISOString();
+        const endIso = new Date(endMs).toISOString();
+        const groups = new Map();
+        let sampleSize = 0;
+        for (const hour of this.#file.buckets) {
+            if (hour.hour < hourFloor(startIso))
+                continue;
+            if (hour.hour > endIso)
+                continue;
+            const map = options.by === "principal"
+                ? hour.byPrincipal
+                : options.by === "model"
+                    ? hour.byModel
+                    : hour.byProvider;
+            for (const counters of Object.values(map)) {
+                sampleSize += counters.requests;
+                let bucket = groups.get(counters.key);
+                if (bucket === undefined) {
+                    bucket = emptyCounters(counters.key, counters.label);
+                    groups.set(counters.key, bucket);
+                }
+                mergeCounters(bucket, counters);
+            }
+        }
+        const ranked = [...groups.values()].sort((a, b) => {
+            const delta = sortValue(b, options.sort) - sortValue(a, options.sort);
+            if (delta !== 0)
+                return delta;
+            return a.key.localeCompare(b.key);
+        });
+        return {
+            rows: ranked.slice(0, options.limit).map((bucket, index) => toRow(bucket, index + 1)),
+            sampleSize,
+            windowStart: startIso,
+            windowEnd: endIso
+        };
+    }
+    path() {
+        return this.#path;
+    }
+    #load() {
+        if (!existsSync(this.#path)) {
+            return {
+                version: LEADERBOARD_ROLLUP_VERSION,
+                updatedAt: new Date(this.#now()).toISOString(),
+                retentionDays: this.#retentionDays,
+                buckets: []
+            };
+        }
+        try {
+            const parsed = JSON.parse(readFileSync(this.#path, "utf8"));
+            if (parsed.version !== LEADERBOARD_ROLLUP_VERSION || !Array.isArray(parsed.buckets)) {
+                return {
+                    version: LEADERBOARD_ROLLUP_VERSION,
+                    updatedAt: new Date(this.#now()).toISOString(),
+                    retentionDays: this.#retentionDays,
+                    buckets: []
+                };
+            }
+            return {
+                version: LEADERBOARD_ROLLUP_VERSION,
+                updatedAt: typeof parsed.updatedAt === "string"
+                    ? parsed.updatedAt
+                    : new Date(this.#now()).toISOString(),
+                retentionDays: this.#retentionDays,
+                buckets: parsed.buckets
+            };
+        }
+        catch {
+            return {
+                version: LEADERBOARD_ROLLUP_VERSION,
+                updatedAt: new Date(this.#now()).toISOString(),
+                retentionDays: this.#retentionDays,
+                buckets: []
+            };
+        }
+    }
+    #prune(nowMs) {
+        const cutoff = new Date(nowMs - this.#retentionDays * 24 * 60 * 60 * 1_000);
+        cutoff.setUTCMinutes(0, 0, 0);
+        const cutoffIso = cutoff.toISOString();
+        const before = this.#file.buckets.length;
+        this.#file.buckets = this.#file.buckets.filter((bucket) => bucket.hour >= cutoffIso);
+        if (this.#file.buckets.length !== before)
+            this.#dirty = true;
+    }
+    #scheduleFlush() {
+        if (this.#timer !== undefined)
+            return;
+        this.#timer = setTimeout(() => {
+            this.#timer = undefined;
+            if (this.#dirty)
+                this.#write();
+        }, this.#flushDelayMs);
+        this.#timer.unref?.();
+    }
+    #write() {
+        mkdirSync(dirname(this.#path), { recursive: true, mode: 0o700 });
+        writeFileAtomic(this.#path, `${JSON.stringify(this.#file, null, 2)}\n`, {
+            mode: 0o600
+        });
+        chmodSync(this.#path, 0o600);
+        this.#dirty = false;
+    }
+}
+export function buildLeaderboardResult(input) {
+    return {
+        by: input.by,
+        sort: input.sort,
+        source: input.source,
+        window: {
+            start: input.windowStart,
+            end: input.windowEnd
+        },
+        sampleSize: input.sampleSize,
+        truncated: input.truncated,
+        budget: {
+            liveLimit: input.budget.liveLimit,
+            liveTtlHours: input.budget.liveTtlHours,
+            durable: input.budget.durable,
+            durableRetentionDays: input.budget.durableRetentionDays
+        },
+        rows: input.rows
+    };
+}

package/dist/test/call-attribution-store.test.js

@@ -67,7 +67,19 @@ test("call attribution store evicts by capacity and expiry", () => {
     store.onModelCall(modelCall("call_3"));
     assert.equal(store.get("call_1"), undefined);
     assert.ok(store.get("call_2"));
+    assert.equal(store.truncated(), true);
+    assert.equal(store.list().length, 2);
     now = 111;
     assert.equal(store.get("call_2"), undefined);
     assert.ok(store.get("call_3"));
 });
+test("call attribution store applies a tighter live budget on configure", () => {
+    const store = new CallAttributionStore({ limit: 3, ttlMs: 60_000 });
+    store.onModelCall(modelCall("call_1"));
+    store.onModelCall(modelCall("call_2"));
+    store.onModelCall(modelCall("call_3"));
+    store.configureBudget({ limit: 1, ttlMs: 60_000 });
+    assert.equal(store.size(), 1);
+    assert.equal(store.list()[0]?.callId, "call_3");
+    assert.deepEqual(store.budget(), { limit: 1, ttlMs: 60_000 });
+});

package/dist/test/daemon.test.js

@@ -264,6 +264,19 @@ test("singleton daemon exposes authenticated control and a stable reloadable dat
         assert.equal(embeddingInspection.provider, "openai");
         assert.equal(embeddingInspection.billingMode, "api_key");
         await assert.rejects(client.call("calls.inspect", { callId: "model_call_missing" }), (error) => error instanceof ControlError && error.code === "not_found");
+        const leaderboard = await client.call("calls.leaderboard", {
+            by: "provider",
+            sort: "requests",
+            limit: 5,
+            window: "live"
+        });
+        assert.equal(leaderboard.by, "provider");
+        assert.equal(leaderboard.source, "live");
+        assert.ok(leaderboard.sampleSize >= 1);
+        assert.ok(leaderboard.rows.some((row) => row.key === "openai"));
+        await assert.rejects(client.call("calls.leaderboard", { window: "24h" }), (error) => error instanceof ControlError &&
+            error.code === "bad_request" &&
+            /durable leaderboard rollups are disabled/.test(error.message));
         await assert.rejects(client.call("config.update", {
             expectedRevision: snapshot.revision,
             document: "providers: {}\n"
@@ -311,6 +324,155 @@ test("singleton daemon exposes authenticated control and a stable reloadable dat
         rmSync(root, { recursive: true, force: true });
     }
 });
+test("daemon account activity persists last selection independently of leaderboard rollups", async () => {
+    const root = mkdtempSync(join(tmpdir(), "routekit-daemon-activity-"));
+    const stateHome = join(root, "state");
+    const configPath = join(root, "router.yaml");
+    const accountsDirectory = join(stateHome, "subscriptions", "codex");
+    const activityPath = join(stateHome, "usage", "account-activity.v1.json");
+    mkdirSync(accountsDirectory, { recursive: true, mode: 0o700 });
+    mkdirSync(join(stateHome, "usage"), { recursive: true, mode: 0o700 });
+    writeFileSync(join(accountsDirectory, "work.json"), `${JSON.stringify(nativeCredential("codex"))}\n`, { mode: 0o600 });
+    writeFileSync(activityPath, `${JSON.stringify({
+        version: 1,
+        sequence: 3,
+        accounts: [
+            {
+                identity: "codex:work",
+                lastSelectedAt: 1_700_000_000_000,
+                sequence: 3
+            }
+        ]
+    })}\n`, { mode: 0o600 });
+    writeFileSync(configPath, [
+        "providers:",
+        "  codex: {}",
+        "defaultModel: codex/gpt-test-model",
+        "leaderboard:",
+        "  durable: false",
+        ""
+    ].join("\n"));
+    try {
+        await withMockNativeDiscovery("codex", async () => {
+            const daemon = await startRouteKitDaemon({
+                packageVersion: "1.2.3",
+                stateHome,
+                configPath,
+                port: 0,
+                portless: false,
+                env: {
+                    HOME: root,
+                    ROUTEKIT_HOME: stateHome,
+                    ROUTEKIT_PORTLESS: "0"
+                }
+            });
+            try {
+                const client = new RouteKitControlClient({
+                    url: daemon.record.url,
+                    token: daemon.record.controlToken
+                });
+                const status = await client.call("accounts.status", {});
+                const usage = await client.call("accounts.usage", {});
+                assert.equal(status.accounts[0]?.lastSelected, true);
+                assert.equal(status.accounts[0]?.active, true);
+                assert.equal(status.accounts[0]?.serving, false);
+                assert.equal(status.accounts[0]?.inFlight, 0);
+                assert.equal(status.accounts[0]?.lastSelectedAt, 1_700_000_000_000);
+                assert.equal(usage.accountSets[0]?.members[0]?.lastSelected, true);
+                assert.equal(usage.accountSets[0]?.members[0]?.active, true);
+                assert.equal(usage.accountSets[0]?.members[0]?.lastSelectedAt, 1_700_000_000_000);
+                assert.equal(existsSync(join(stateHome, "usage", "leaderboard-rollups.v1.json")), false);
+                await client.call("accounts.rename", { kind: "codex", source: "work", target: "personal" }, { idempotencyKey: "activity-rename" });
+                const renamedStatus = await client.call("accounts.status", {});
+                assert.equal(renamedStatus.accounts[0]?.label, "personal");
+                assert.equal(renamedStatus.accounts[0]?.lastSelected, true);
+                assert.equal(renamedStatus.accounts[0]?.lastSelectedAt, 1_700_000_000_000);
+                const persisted = JSON.parse(readFileSync(activityPath, "utf8"));
+                assert.deepEqual(persisted.accounts.map((account) => account.identity), ["codex:personal"]);
+                const beforeReload = await client.call("daemon.status", {});
+                const reloaded = await client.call("config.update", {
+                    expectedRevision: (await client.call("config.get", {})).revision,
+                    document: [
+                        "providers:",
+                        "  codex:",
+                        "    strategy: sticky",
+                        "defaultModel: codex/gpt-test-model",
+                        "leaderboard:",
+                        "  durable: false",
+                        ""
+                    ].join("\n")
+                });
+                assert.ok(reloaded.revision > beforeReload.configRevision);
+                const afterReload = await client.call("accounts.status", {});
+                assert.equal(afterReload.accounts[0]?.label, "personal");
+                assert.equal(afterReload.accounts[0]?.lastSelected, true);
+                assert.equal(afterReload.accounts[0]?.lastSelectedAt, 1_700_000_000_000);
+                assert.equal(afterReload.accounts[0]?.serving, false);
+                assert.equal(afterReload.accounts[0]?.inFlight, 0);
+                await assert.rejects(client.call("calls.leaderboard", { window: "24h" }), (error) => error instanceof ControlError &&
+                    error.code === "bad_request" &&
+                    /durable leaderboard rollups are disabled/.test(error.message));
+                const removed = await client.call("accounts.remove", { kind: "codex", label: "personal" }, { idempotencyKey: "activity-remove" });
+                assert.equal(removed.removed, true);
+                const afterRemove = JSON.parse(readFileSync(activityPath, "utf8"));
+                assert.deepEqual(afterRemove.accounts, []);
+            }
+            finally {
+                await daemon.close();
+            }
+            writeFileSync(join(accountsDirectory, "personal.json"), `${JSON.stringify(nativeCredential("codex"))}\n`, { mode: 0o600 });
+            writeFileSync(activityPath, `${JSON.stringify({
+                version: 1,
+                sequence: 4,
+                accounts: [
+                    {
+                        identity: "codex:personal",
+                        lastSelectedAt: 1_700_000_000_000,
+                        sequence: 4
+                    }
+                ]
+            })}\n`, { mode: 0o600 });
+            writeFileSync(configPath, [
+                "providers:",
+                "  codex: {}",
+                "defaultModel: codex/gpt-test-model",
+                "leaderboard:",
+                "  durable: false",
+                ""
+            ].join("\n"));
+            const restarted = await startRouteKitDaemon({
+                packageVersion: "1.2.3",
+                stateHome,
+                configPath,
+                port: 0,
+                portless: false,
+                env: {
+                    HOME: root,
+                    ROUTEKIT_HOME: stateHome,
+                    ROUTEKIT_PORTLESS: "0"
+                }
+            });
+            try {
+                const client = new RouteKitControlClient({
+                    url: restarted.record.url,
+                    token: restarted.record.controlToken
+                });
+                const status = await client.call("accounts.status", {});
+                assert.equal(status.accounts[0]?.label, "personal");
+                assert.equal(status.accounts[0]?.lastSelected, true);
+                assert.equal(status.accounts[0]?.lastSelectedAt, 1_700_000_000_000);
+                assert.equal(status.accounts[0]?.serving, false);
+                assert.equal(status.accounts[0]?.inFlight, 0);
+            }
+            finally {
+                await restarted.close();
+            }
+        });
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
 for (const kind of ["claude-code", "codex"]) {
     test(`native ${kind} account rename preserves routing and usage state`, async () => {
         const root = mkdtempSync(join(tmpdir(), `routekit-daemon-rename-${kind}-`));
@@ -824,7 +986,10 @@ test("daemon owns the cliproxy sidecar: spawn, restart, account routing, shutdow
                 credentialValid: true,
                 configured: true,
                 relayOpen: true,
-                active: true,
+                serving: false,
+                inFlight: 0,
+                lastSelected: false,
+                active: false,
                 models: []
             }
         ]);

package/dist/test/leaderboard.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/leaderboard.test.js

@@ -0,0 +1,258 @@
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { AccountActivityCoordinator } from "@velum-labs/routekit-accounts";
+import { aggregateInspections, LeaderboardRollupStore } from "../leaderboard.js";
+function inspection(input) {
+    return {
+        callId: input.callId,
+        status: input.status ?? "succeeded",
+        effectiveModel: input.model ?? "openai/gpt-5.5",
+        provider: input.provider ?? "openai",
+        billingMode: "api_key",
+        ...(input.principal !== undefined ? { principal: input.principal } : {}),
+        retries: { attempts: 1, total: 0, accountFailovers: 0 },
+        usage: {
+            prompt_tokens: input.tokens ?? 10,
+            completion_tokens: 5,
+            total_tokens: (input.tokens ?? 10) + 5
+        },
+        cost: {
+            ...(input.cost !== undefined ? { estimateUsd: input.cost } : {}),
+            unknownUsage: false,
+            unknownCost: input.unknownCost ?? false
+        },
+        timing: {
+            startedAt: input.startedAt ?? "2026-07-27T10:00:00.000Z",
+            finishedAt: input.startedAt ?? "2026-07-27T10:00:01.000Z",
+            latencyMs: input.latencyMs ?? 1_000
+        }
+    };
+}
+test("aggregateInspections ranks principals by cost and keeps unknown cost visible", () => {
+    const result = aggregateInspections([
+        inspection({
+            callId: "a",
+            principal: { tokenId: "tok_a", label: "alice" },
+            cost: 0.5
+        }),
+        inspection({
+            callId: "b",
+            principal: { tokenId: "tok_b", label: "bob" },
+            cost: 1.25
+        }),
+        inspection({
+            callId: "c",
+            principal: { tokenId: "tok_a", label: "alice" },
+            unknownCost: true
+        }),
+        inspection({
+            callId: "d",
+            model: "anthropic/claude-sonnet-4-5",
+            provider: "anthropic",
+            cost: 9
+        })
+    ], { by: "principal", sort: "cost", limit: 10 });
+    assert.equal(result.rows.length, 2);
+    assert.equal(result.rows[0]?.key, "tok_b");
+    assert.equal(result.rows[0]?.estimateUsd, 1.25);
+    assert.equal(result.rows[1]?.key, "tok_a");
+    assert.equal(result.rows[1]?.estimateUsd, 0.5);
+    assert.equal(result.rows[1]?.unknownCostCount, 1);
+    assert.equal(result.sampleSize, 4);
+});
+test("aggregateInspections can rank by model and sort by requests", () => {
+    const result = aggregateInspections([
+        inspection({ callId: "1", model: "openai/a", cost: 1 }),
+        inspection({ callId: "2", model: "openai/a", cost: 1 }),
+        inspection({ callId: "3", model: "openai/b", cost: 5 })
+    ], { by: "model", sort: "requests", limit: 1 });
+    assert.equal(result.rows.length, 1);
+    assert.equal(result.rows[0]?.key, "openai/a");
+    assert.equal(result.rows[0]?.requests, 2);
+});
+test("LeaderboardRollupStore persists hourly buckets across reload and prunes old hours", () => {
+    const home = mkdtempSync(join(tmpdir(), "routekit-leaderboard-"));
+    let now = Date.parse("2026-07-27T12:30:00.000Z");
+    try {
+        const store = new LeaderboardRollupStore({
+            home,
+            config: {
+                liveLimit: 1000,
+                liveTtlHours: 24,
+                durable: true,
+                durableRetentionDays: 1
+            },
+            now: () => now,
+            flushDelayMs: 0
+        });
+        store.record(inspection({
+            callId: "old",
+            principal: { tokenId: "tok_old", label: "old" },
+            cost: 1,
+            startedAt: "2026-07-25T10:15:00.000Z"
+        }));
+        store.record(inspection({
+            callId: "new",
+            principal: { tokenId: "tok_new", label: "new" },
+            cost: 2,
+            startedAt: "2026-07-27T11:15:00.000Z"
+        }));
+        store.flush();
+        const raw = JSON.parse(readFileSync(store.path(), "utf8"));
+        assert.equal(raw.buckets.length, 1);
+        assert.equal(raw.buckets[0]?.hour, "2026-07-27T11:00:00.000Z");
+        const reloaded = new LeaderboardRollupStore({
+            home,
+            config: {
+                liveLimit: 1000,
+                liveTtlHours: 24,
+                durable: true,
+                durableRetentionDays: 14
+            },
+            now: () => now,
+            flushDelayMs: 0
+        });
+        const board = reloaded.query({
+            by: "principal",
+            sort: "cost",
+            limit: 10,
+            window: "24h"
+        });
+        assert.equal(board.rows.length, 1);
+        assert.equal(board.rows[0]?.key, "tok_new");
+        assert.equal(board.rows[0]?.estimateUsd, 2);
+    }
+    finally {
+        rmSync(home, { recursive: true, force: true });
+    }
+});
+test("LeaderboardRollupStore ignores records while durable is disabled", () => {
+    const home = mkdtempSync(join(tmpdir(), "routekit-leaderboard-off-"));
+    try {
+        const store = new LeaderboardRollupStore({
+            home,
+            config: {
+                liveLimit: 1000,
+                liveTtlHours: 24,
+                durable: false,
+                durableRetentionDays: 14
+            },
+            flushDelayMs: 0
+        });
+        store.record(inspection({
+            callId: "x",
+            principal: { tokenId: "tok", label: "x" },
+            cost: 1
+        }));
+        store.flush();
+        assert.equal(store.query({
+            by: "principal",
+            sort: "cost",
+            limit: 10,
+            window: "24h"
+        }).rows.length, 0);
+    }
+    finally {
+        rmSync(home, { recursive: true, force: true });
+    }
+});
+test("provider leaderboard aggregates completed calls across accounts under one provider", () => {
+    // Account identity is not a leaderboard dimension; two accounts under
+    // the same provider roll into one provider row from completed calls only.
+    const result = aggregateInspections([
+        inspection({
+            callId: "work-1",
+            provider: "codex",
+            model: "codex/gpt-5.5",
+            cost: 1,
+            tokens: 20
+        }),
+        inspection({
+            callId: "personal-1",
+            provider: "codex",
+            model: "codex/gpt-5.5",
+            cost: 2,
+            tokens: 30
+        }),
+        inspection({
+            callId: "claude-1",
+            provider: "claude-code",
+            model: "claude-code/claude-opus",
+            cost: 5,
+            tokens: 10
+        })
+    ], { by: "provider", sort: "requests", limit: 10 });
+    assert.equal(result.rows.length, 2);
+    assert.equal(result.rows[0]?.key, "codex");
+    assert.equal(result.rows[0]?.requests, 2);
+    assert.equal(result.rows[0]?.tokensTotal, 60);
+    assert.equal(result.rows[0]?.estimateUsd, 3);
+    assert.equal(result.rows[1]?.key, "claude-code");
+    assert.equal(result.rows[1]?.requests, 1);
+});
+test("account activity persistence stays independent of leaderboard rollups", () => {
+    const home = mkdtempSync(join(tmpdir(), "routekit-leaderboard-activity-"));
+    const usageDirectory = join(home, "usage");
+    mkdirSync(usageDirectory, { recursive: true, mode: 0o700 });
+    const activityPath = join(usageDirectory, "account-activity.v1.json");
+    try {
+        const rollups = new LeaderboardRollupStore({
+            home,
+            config: {
+                liveLimit: 1000,
+                liveTtlHours: 24,
+                durable: false,
+                durableRetentionDays: 14
+            },
+            flushDelayMs: 0
+        });
+        const activity = new AccountActivityCoordinator({
+            statePath: activityPath,
+            persistDebounceMs: 0,
+            now: () => 1_700_000_000_000
+        });
+        const before = aggregateInspections([
+            inspection({
+                callId: "a",
+                provider: "codex",
+                principal: { tokenId: "tok", label: "alice" },
+                cost: 1.5
+            })
+        ], { by: "principal", sort: "cost", limit: 10 });
+        const release = activity.beginAttempt("codex:work");
+        activity.flush();
+        release();
+        rollups.record(inspection({
+            callId: "ignored-while-disabled",
+            principal: { tokenId: "tok", label: "alice" },
+            cost: 99
+        }));
+        rollups.flush();
+        const after = aggregateInspections([
+            inspection({
+                callId: "a",
+                provider: "codex",
+                principal: { tokenId: "tok", label: "alice" },
+                cost: 1.5
+            })
+        ], { by: "principal", sort: "cost", limit: 10 });
+        assert.deepEqual(after, before);
+        assert.equal(existsSync(activityPath), true);
+        assert.equal(existsSync(rollups.path()), false);
+        assert.equal(activity.snapshot("codex:work").lastSelected, true);
+        assert.equal(activity.snapshot("codex:work").inFlight, 0);
+        assert.equal(rollups.query({
+            by: "principal",
+            sort: "cost",
+            limit: 10,
+            window: "24h"
+        }).rows.length, 0);
+        activity.close();
+    }
+    finally {
+        rmSync(home, { recursive: true, force: true });
+    }
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@velum-labs/routekit-daemon",
   "private": false,
-  "version": "0.13.0",
+  "version": "0.15.0",
   "description": "Singleton RouteKit control daemon and stable model gateway.",
   "repository": {
     "type": "git",
@@ -34,14 +34,14 @@
   ],
   "dependencies": {
     "yaml": "2.9.0",
-    "@velum-labs/routekit-control": "0.13.0",
-    "@velum-labs/routekit-gateway": "0.13.0",
-    "@velum-labs/routekit-registry": "0.13.0",
-    "@velum-labs/routekit-router": "0.13.0",
-    "@velum-labs/routekit-config": "0.13.0",
-    "@velum-labs/routekit-accounts": "0.13.0",
-    "@velum-labs/routekit-telemetry-core": "0.13.0",
-    "@velum-labs/routekit-runtime": "0.13.0"
+    "@velum-labs/routekit-accounts": "0.15.0",
+    "@velum-labs/routekit-config": "0.15.0",
+    "@velum-labs/routekit-control": "0.15.0",
+    "@velum-labs/routekit-gateway": "0.15.0",
+    "@velum-labs/routekit-registry": "0.15.0",
+    "@velum-labs/routekit-router": "0.15.0",
+    "@velum-labs/routekit-runtime": "0.15.0",
+    "@velum-labs/routekit-telemetry-core": "0.15.0"
   },
   "scripts": {
     "build": "tsc -b",