agent-usage-all-in-one 0.5.0 → 0.6.0

package/dist/cli.js

@@ -159,7 +159,7 @@ function buildUsageExport(overview, request, accountIdentifiers = {}) {
         calculatedAt: null
       };
       const modelObservations = history.models.flatMap(
-        (model) => model.observations.map((observation) => ({
+        (model) => (model.observations ?? []).map((observation) => ({
           model: model.model,
           observation
         }))
@@ -210,14 +210,14 @@ function buildUsageExport(overview, request, accountIdentifiers = {}) {
       });
       const observationsById = new Map([
         ...history.models.flatMap(
-          (model) => model.observations.map((observation) => [observation.id, observation])
+          (model) => (model.observations ?? []).map((observation) => [observation.id, observation])
         ),
         ...(history.unclassified.observations ?? []).map(
           (observation) => [observation.id, observation]
         )
       ]);
       const costRows = history.costs.map((cost) => {
-        const authorities = domain.costs.filter(
+        const authorities = (domain.costs ?? []).filter(
           (candidate) => candidate.kind === cost.kind && candidate.currency.toUpperCase() === cost.currency.toUpperCase() && candidate.observedAt >= history.start && candidate.observedAt < history.end
         ).map((candidate) => candidate.authority);
         return {
@@ -268,7 +268,7 @@ function buildUsageExport(overview, request, accountIdentifiers = {}) {
           calculatedAt: null
         };
       });
-      const costObservationRows = domain.costs.filter((cost) => cost.observedAt >= history.start && cost.observedAt < history.end).map((cost) => {
+      const costObservationRows = (domain.costs ?? []).filter((cost) => cost.observedAt >= history.start && cost.observedAt < history.end).map((cost) => {
         const snapshot2 = cost.priceSnapshot ?? null;
         const observation = cost.usageObservationId ? observationsById.get(cost.usageObservationId) : null;
         return {
@@ -557,10 +557,34 @@ function anthropicEntry(options) {
     source: {
       title: "Anthropic Claude API pricing",
       url: options.sourceUrl,
-      retrievedAt: "2026-08-28"
+      retrievedAt: options.retrievedAt ?? "2026-08-28"
     }
   };
 }
+function antigravityEntry(options) {
+  const versionDate = "2026-09-02";
+  return {
+    id: options.id,
+    priceVersion: `antigravity-${versionDate}`,
+    providerId: "antigravity",
+    billingDomainId: "code-assist-subscription",
+    canonicalModel: options.model,
+    aliases: options.aliases,
+    currency: "USD",
+    effectiveFrom: GOOGLE_ANTIGRAVITY_EFFECTIVE_FROM,
+    effectiveUntil: null,
+    contextTier: "standard-api",
+    contextRule: { kind: "fixed" },
+    ratesPerMillion: {
+      input: options.input,
+      output: options.output,
+      reasoning: options.output,
+      "cache-read": options.cacheRead ?? null,
+      "cache-write": null
+    },
+    source: options.source ?? GOOGLE_ANTIGRAVITY_SOURCE
+  };
+}
 function openAiGpt56Entries(model, periods) {
   return periods.flatMap(([effectiveFrom, effectiveUntil, input, output]) => {
     const versionDate = effectiveFrom.slice(0, 10);
@@ -705,8 +729,48 @@ function openCodeLocalModelPrefix(entry) {
   if (entry.providerId === "opencode-go" && entry.billingDomainId === "go-subscription") {
     return "opencode-go";
   }
+  if (entry.providerId === "antigravity" && entry.billingDomainId === "code-assist-subscription") {
+    return "google";
+  }
   return null;
 }
+function customModelRateToCatalogEntry(rate) {
+  const versionDate = rate.updatedAt.slice(0, 10);
+  return {
+    id: `custom-rate-${rate.id}`,
+    priceVersion: `custom-${rate.id}-${rate.updatedAt}`,
+    providerId: rate.providerId,
+    billingDomainId: rate.billingDomainId ?? "*",
+    canonicalModel: rate.model,
+    aliases: [],
+    currency: "USD",
+    effectiveFrom: "2020-01-01T00:00:00.000Z",
+    effectiveUntil: null,
+    contextTier: "custom-rate",
+    contextRule: { kind: "fixed" },
+    ratesPerMillion: {
+      input: rate.ratesPerMillion.input,
+      output: rate.ratesPerMillion.output,
+      reasoning: rate.ratesPerMillion.output,
+      "cache-read": rate.ratesPerMillion.cacheRead,
+      "cache-write": null
+    },
+    source: {
+      title: "User-configured custom model rate",
+      url: "local://settings/rates",
+      retrievedAt: versionDate
+    }
+  };
+}
+function mergeCatalogWithCustomRates(catalog, customRates) {
+  if (!customRates || customRates.length === 0) return catalog;
+  const customEntries = customRates.map(customModelRateToCatalogEntry);
+  const rateFingerprints = customRates.map((r) => `${r.id}:${r.updatedAt}`).sort().join(";");
+  return {
+    version: `${catalog.version}+custom:${rateFingerprints}`,
+    entries: [...customEntries, ...catalog.entries]
+  };
+}
 function deriveRetailEquivalentCosts(snapshot2, catalog = ANTHROPIC_PRICING_CATALOG, calculatedAt = snapshot2.observedAt) {
   const costs = [];
   const decisions = [];
@@ -732,13 +796,31 @@ function priceObservation(providerId, observation, catalog, calculatedAt) {
     return unavailable("model-unclassified");
   }
   const normalizedModel = normalized.model.trim().toLowerCase();
-  const modelEntries = catalog.entries.filter(
-    (entry2) => entry2.providerId === providerId && entry2.billingDomainId === observation.billingDomainId && [entry2.canonicalModel, ...entry2.aliases].some(
+  const matchingCandidates = catalog.entries.filter(
+    (entry2) => entry2.providerId === providerId && (entry2.billingDomainId === observation.billingDomainId || entry2.billingDomainId === "*") && [entry2.canonicalModel, ...entry2.aliases].some(
       (model) => model.trim().toLowerCase() === normalizedModel
     )
   );
-  if (modelEntries.length === 0) return unavailable("model-unrecognized");
-  const timeActiveEntries = modelEntries.filter(
+  let selectedEntries;
+  const customExact = matchingCandidates.filter(
+    (e) => e.contextTier === "custom-rate" && e.billingDomainId === observation.billingDomainId
+  );
+  if (customExact.length > 0) {
+    selectedEntries = customExact;
+  } else {
+    const customWildcard = matchingCandidates.filter(
+      (e) => e.contextTier === "custom-rate" && e.billingDomainId === "*"
+    );
+    if (customWildcard.length > 0) {
+      selectedEntries = customWildcard;
+    } else {
+      selectedEntries = matchingCandidates.filter(
+        (e) => e.contextTier !== "custom-rate" && e.billingDomainId === observation.billingDomainId
+      );
+    }
+  }
+  if (selectedEntries.length === 0) return unavailable("model-unrecognized");
+  const timeActiveEntries = selectedEntries.filter(
     (entry2) => observation.observedAt >= entry2.effectiveFrom && (!entry2.effectiveUntil || observation.observedAt < entry2.effectiveUntil)
   );
   if (timeActiveEntries.length === 0) return unavailable("price-not-effective");
@@ -877,7 +959,7 @@ function matchContext(rule, observation) {
 function preciseMoney(value) {
   return Number(value.toFixed(12));
 }
-var ANTHROPIC_PRICING_CATALOG, OPENCODE_GO_SOURCE, XAI_PRICING_SOURCE, OPENAI_GPT_56_SOURCE, OPEN_CODE_GO_SOURCE_PATH, openCodeHistory, OPEN_CODE_BASE_HISTORY, OPEN_CODE_PRICE_HISTORY, OPEN_CODE_FLAT_MODELS, OPEN_CODE_CONTEXT_MODELS, DEEPSEEK_GO_MODELS, WEEKDAY_PEAK_RANGES, DEEPSEEK_OFFICIAL_SOURCE, DEEPSEEK_OFFICIAL_MODELS, DEEPSEEK_OFFICIAL_EFFECTIVE_FROM, DIRECT_OFFICIAL_PRICING_CATALOG, OFFICIAL_PRICING_CATALOG;
+var ANTHROPIC_PRICING_CATALOG, OPENCODE_GO_SOURCE, XAI_PRICING_SOURCE, OPENAI_GPT_56_SOURCE, OPEN_CODE_GO_SOURCE_PATH, openCodeHistory, OPEN_CODE_BASE_HISTORY, OPEN_CODE_PRICE_HISTORY, OPEN_CODE_FLAT_MODELS, OPEN_CODE_CONTEXT_MODELS, DEEPSEEK_GO_MODELS, WEEKDAY_PEAK_RANGES, DEEPSEEK_OFFICIAL_SOURCE, DEEPSEEK_OFFICIAL_MODELS, DEEPSEEK_OFFICIAL_EFFECTIVE_FROM, GOOGLE_ANTIGRAVITY_SOURCE, GOOGLE_ANTIGRAVITY_EFFECTIVE_FROM, DIRECT_OFFICIAL_PRICING_CATALOG, OFFICIAL_PRICING_CATALOG;
 var init_retail_pricing = __esm({
   "src/core/retail-pricing.ts"() {
     "use strict";
@@ -885,6 +967,25 @@ var init_retail_pricing = __esm({
     ANTHROPIC_PRICING_CATALOG = {
       version: "2026-08-28",
       entries: [
+        anthropicEntry({
+          id: "anthropic-fable-5-1-2026-09-01",
+          priceVersion: "anthropic-2026-09-01",
+          model: "claude-fable-5-1",
+          aliases: [
+            "Claude Fable 5.1",
+            "claude-fable-5.1",
+            "claude-fable-5-1-20260901",
+            "claude-fable-5.1-20260901",
+            "fable-5.1",
+            "fable-5-1"
+          ],
+          effectiveFrom: "2026-09-01T00:00:00.000Z",
+          input: 10,
+          output: 50,
+          cacheRead: 0.25,
+          sourceUrl: "https://platform.claude.com/docs/en/about-claude/pricing",
+          retrievedAt: "2026-09-03"
+        }),
         {
           id: "anthropic-fable-5-2026-06-09",
           priceVersion: "anthropic-2026-06-09",
@@ -1086,6 +1187,12 @@ var init_retail_pricing = __esm({
       ["deepseek-v4-flash-vision-exp", 0.22, 0.66, 7e-3]
     ];
     DEEPSEEK_OFFICIAL_EFFECTIVE_FROM = "2026-08-17T00:00:00.000Z";
+    GOOGLE_ANTIGRAVITY_SOURCE = {
+      title: "Google Gemini API pricing",
+      url: "https://ai.google.dev/pricing",
+      retrievedAt: "2026-09-02"
+    };
+    GOOGLE_ANTIGRAVITY_EFFECTIVE_FROM = "2026-01-01T00:00:00.000Z";
     DIRECT_OFFICIAL_PRICING_CATALOG = {
       version: "2026-08-28-grok-4.6-build",
       entries: [
@@ -1222,11 +1329,91 @@ var init_retail_pricing = __esm({
           output: 12,
           cacheRead: 1,
           contextRule: { kind: "prompt-tokens", minimumExclusive: 2e5 }
+        }),
+        antigravityEntry({
+          id: "antigravity-gemini-3.7-flash-2026-09-02",
+          model: "gemini-3.7-flash",
+          aliases: [
+            "gemini-3.7-flash-high",
+            "gemini-3.7-flash-medium",
+            "gemini-3.7-flash-low",
+            "gemini-3p7-flash-exp-d",
+            "gemini-3.7-flash-exp",
+            "Gemini 3.7 Flash (High)",
+            "Gemini 3.7 Flash (Medium)",
+            "Gemini 3.7 Flash (Low)"
+          ],
+          input: 0.1,
+          output: 0.4,
+          cacheRead: 0.025
+        }),
+        antigravityEntry({
+          id: "antigravity-gemini-3.6-flash-2026-09-02",
+          model: "gemini-3.6-flash",
+          aliases: [
+            "gemini-3.6-flash-high",
+            "gemini-3.6-flash-medium",
+            "gemini-3.6-flash-low",
+            "Gemini 3.6 Flash (High)",
+            "Gemini 3.6 Flash (Medium)",
+            "Gemini 3.6 Flash (Low)"
+          ],
+          input: 0.1,
+          output: 0.4,
+          cacheRead: 0.025
+        }),
+        antigravityEntry({
+          id: "antigravity-gemini-3.1-pro-2026-09-02",
+          model: "gemini-3.1-pro",
+          aliases: [
+            "gemini-3.1-pro-high",
+            "gemini-3.1-pro-low",
+            "gemini-3p1-pro-exp",
+            "Gemini 3.1 Pro (High)",
+            "Gemini 3.1 Pro (Low)"
+          ],
+          input: 1.25,
+          output: 5,
+          cacheRead: 0.3125
+        }),
+        antigravityEntry({
+          id: "antigravity-claude-sonnet-4-6-2026-09-02",
+          model: "claude-sonnet-4-6",
+          aliases: ["claude-sonnet-4-6-thinking", "Claude Sonnet 4.6 (Thinking)"],
+          input: 3,
+          output: 15,
+          cacheRead: 0.3,
+          source: {
+            title: "Anthropic Claude API pricing",
+            url: "https://platform.claude.com/docs/en/about-claude/pricing",
+            retrievedAt: "2026-09-02"
+          }
+        }),
+        antigravityEntry({
+          id: "antigravity-claude-opus-4-6-2026-09-02",
+          model: "claude-opus-4-6-thinking",
+          aliases: ["claude-opus-4-6", "Claude Opus 4.6 (Thinking)"],
+          input: 15,
+          output: 75,
+          cacheRead: 1.5,
+          source: {
+            title: "Anthropic Claude API pricing",
+            url: "https://platform.claude.com/docs/en/about-claude/pricing",
+            retrievedAt: "2026-09-02"
+          }
+        }),
+        antigravityEntry({
+          id: "antigravity-gpt-oss-120b-2026-09-02",
+          model: "gpt-oss-120b-medium",
+          aliases: ["gpt-oss-120b", "GPT-OSS 120B (Medium)"],
+          input: 0.15,
+          output: 0.6,
+          cacheRead: 0.05
         })
       ]
     };
     OFFICIAL_PRICING_CATALOG = {
-      version: "2026-09-01-dsh-deepseek-official",
+      version: "2026-09-03-fable-5.1",
       entries: [
         ...DIRECT_OFFICIAL_PRICING_CATALOG.entries,
         ...openCodeLocalHistoryEntries(DIRECT_OFFICIAL_PRICING_CATALOG.entries)
@@ -1612,6 +1799,7 @@ var init_plan_pricing = __esm({
 });
 
 // src/core/usage-application.ts
+import { randomUUID } from "crypto";
 function safeConnectorFailure(error) {
   if (error instanceof Error && "code" in error && typeof error.code === "string" && "recovery" in error && typeof error.recovery === "string") {
     return { code: error.code, message: error.message, recovery: error.recovery };
@@ -1719,7 +1907,7 @@ function notificationLevel(value) {
 function pickAgentProviderIndex(overview) {
   return {
     generatedAt: overview.generatedAt,
-    providers: overview.providers.filter((provider) => provider.id !== "opencode").map(({ id, displayName }) => ({ id, displayName }))
+    providers: overview.providers.filter((provider) => provider.id !== "opencode" && provider.id !== "dsh").map(({ id, displayName }) => ({ id, displayName }))
   };
 }
 var UsageApplication;
@@ -1743,6 +1931,7 @@ var init_usage_application = __esm({
       #connectorPolicies;
       #notifier;
       #startAtLoginManager;
+      #basePriceCatalog;
       #priceCatalog;
       #planCatalog;
       #refreshPromise = null;
@@ -1765,10 +1954,16 @@ var init_usage_application = __esm({
         this.#connectorPolicies = options.connectorPolicies ?? {};
         this.#notifier = options.notifier;
         this.#startAtLoginManager = options.startAtLoginManager;
-        this.#priceCatalog = options.priceCatalog === void 0 ? OFFICIAL_PRICING_CATALOG : options.priceCatalog;
+        this.#basePriceCatalog = options.priceCatalog === void 0 ? OFFICIAL_PRICING_CATALOG : options.priceCatalog;
+        this.#priceCatalog = this.#resolvePriceCatalog();
         this.#planCatalog = options.planCatalog ?? SUBSCRIPTION_PLAN_CATALOG;
         this.#processingStatus = createProcessingStatus(this.#clock().toISOString(), false);
       }
+      #resolvePriceCatalog() {
+        if (!this.#basePriceCatalog) return null;
+        const customRates = this.#repository.getCustomModelRates?.() ?? [];
+        return mergeCatalogWithCustomRates(this.#basePriceCatalog, customRates);
+      }
       async #backfillRetailCosts(mode) {
         if (!this.#priceCatalog || !this.#repository.getRetailPricingBackfillPage && !this.#repository.getRetailPricingBackfillSnapshots || !this.#repository.saveDerivedCosts) {
           return;
@@ -2115,6 +2310,57 @@ var init_usage_application = __esm({
         });
         return this.getPlanSettings();
       }
+      async getCustomModelRates() {
+        return this.#repository.getCustomModelRates?.() ?? [];
+      }
+      async getCustomModelRate(id) {
+        return this.#repository.getCustomModelRate?.(id) ?? null;
+      }
+      async setCustomModelRate(input) {
+        const providerId = input.providerId?.trim();
+        if (!providerId) throw new Error("Provider ID is required");
+        const model = input.model?.trim();
+        if (!model) throw new Error("Model name is required");
+        if (!Number.isFinite(input.inputRate) || input.inputRate < 0) {
+          throw new Error("Input rate must be a non-negative number");
+        }
+        if (!Number.isFinite(input.outputRate) || input.outputRate < 0) {
+          throw new Error("Output rate must be a non-negative number");
+        }
+        const cacheReadRate = input.cacheReadRate ?? 0;
+        if (!Number.isFinite(cacheReadRate) || cacheReadRate < 0) {
+          throw new Error("Cache read rate must be a non-negative number");
+        }
+        const rate = {
+          id: input.id || `rate-${randomUUID()}`,
+          providerId,
+          billingDomainId: input.billingDomainId?.trim() || null,
+          model,
+          ratesPerMillion: {
+            input: input.inputRate,
+            output: input.outputRate,
+            cacheRead: cacheReadRate
+          },
+          updatedAt: this.#clock().toISOString()
+        };
+        await this.#queueDatabaseWrite(() => {
+          this.#repository.saveCustomModelRate?.(rate);
+        });
+        this.#priceCatalog = this.#resolvePriceCatalog();
+        await this.#backfillRetailCosts("hard-rebuild");
+        return rate;
+      }
+      async deleteCustomModelRate(id) {
+        let deleted = false;
+        await this.#queueDatabaseWrite(() => {
+          deleted = this.#repository.deleteCustomModelRate?.(id) ?? false;
+        });
+        if (deleted) {
+          this.#priceCatalog = this.#resolvePriceCatalog();
+          await this.#backfillRetailCosts("hard-rebuild");
+        }
+        return deleted;
+      }
       /**
        * A billing domain can carry a plan price when its connector does not report
        * an actual metered charge. Metered domains keep their own billed amounts and
@@ -2301,7 +2547,10 @@ var init_usage_application = __esm({
         return this.#repository.getProviderOverview?.(now, providerId, query) ?? this.#repository.getOverview(now, query).providers.find((provider) => provider.id === providerId) ?? null;
       }
       async exportUsage(request) {
-        const overview = this.#repository.getOverview(this.#clock(), request);
+        const overview = this.#repository.getOverview(this.#clock(), {
+          ...request,
+          auditEvidence: true
+        });
         const accountIdentifiers = request.includeAccountIdentifiers ? this.#repository.getProviderAccountIdentifiers() : {};
         return buildUsageExport(overview, request, accountIdentifiers);
       }
@@ -2560,6 +2809,20 @@ var init_catalog = __esm({
           billingDomain: { id: "deepseek-official", displayName: "DeepSeek API" }
         },
         officialCredentialPaths: [".dsh"]
+      },
+      {
+        id: "antigravity",
+        displayName: "Antigravity",
+        command: "agy",
+        permissionDescription: "Read local Antigravity conversation session databases for token history. No credential file is opened.",
+        credentialOwner: "official-client",
+        experimental: true,
+        expectedCoverage: ["quota", "tokens", "history"],
+        target: {
+          provider: { id: "antigravity", displayName: "Antigravity" },
+          billingDomain: { id: "code-assist-subscription", displayName: "Gemini Code Assist" }
+        },
+        officialCredentialPaths: [".gemini/antigravity-cli", ".gemini/antigravity"]
       }
     ];
   }
@@ -4765,14 +5028,785 @@ var init_local_transcript_usage_client = __esm({
       async #persistCache() {
         if (!this.#cachePath) return;
         try {
-          await mkdir2(dirname(this.#cachePath), { recursive: true, mode: 448 });
+          await mkdir2(dirname(this.#cachePath), { recursive: true, mode: 448 });
+          const temporary = `${this.#cachePath}.${process.pid}.tmp`;
+          await writeFile2(
+            temporary,
+            JSON.stringify({ version: 1, files: [...this.#fileCache.values()] }),
+            { mode: 384 }
+          );
+          await rename2(temporary, this.#cachePath);
+        } catch {
+        }
+      }
+    };
+  }
+});
+
+// src/connectors/dsh/dsh-connector.ts
+function billingDomains(usage) {
+  const primary = { id: DSH_PRIMARY_BILLING_DOMAIN_ID, displayName: "DeepSeek API" };
+  const observedRoutes = [...new Set(usage.map((observation) => observation.billingDomainId))].filter((id) => id !== primary.id).sort();
+  return [primary, ...observedRoutes.map((id) => ({ id, displayName: id }))];
+}
+function incompleteSessionLogFailure() {
+  return {
+    code: "dsh-session-log-scan-incomplete",
+    message: "Some local dsh session history could not be read.",
+    recovery: "Agent Usage will retry automatically without removing stored history."
+  };
+}
+function unsupportedFormatFailure() {
+  return {
+    code: "dsh-session-format-unsupported",
+    message: "A dsh session log declares an on-disk format this version does not read.",
+    recovery: "Update Agent Usage; stored dsh history from earlier scans is retained."
+  };
+}
+function safeFailure5(error) {
+  if (error instanceof Error && "code" in error && typeof error.code === "string" && "recovery" in error && typeof error.recovery === "string") {
+    return { code: error.code, message: error.message, recovery: error.recovery };
+  }
+  return {
+    code: "dsh-session-log-read-failed",
+    message: "Local dsh session history is unavailable.",
+    recovery: "Run agent-usage doctor, then retry refresh."
+  };
+}
+var DshConnector;
+var init_dsh_connector = __esm({
+  "src/connectors/dsh/dsh-connector.ts"() {
+    "use strict";
+    init_local_transcript_usage_client();
+    DshConnector = class {
+      id = "dsh";
+      displayName = "dsh";
+      consentId = "dsh";
+      #historyClient;
+      #clock;
+      constructor(options) {
+        this.#historyClient = options.historyClient;
+        this.#clock = options.clock ?? (() => /* @__PURE__ */ new Date());
+      }
+      async collect(options = { mode: "incremental" }) {
+        const observedAt = this.#clock().toISOString();
+        const warnings = [];
+        let history = null;
+        try {
+          history = await this.#historyClient.readUsage(options);
+        } catch (error) {
+          warnings.push(safeFailure5(error));
+        }
+        if (history?.unsupportedFormat) warnings.push(unsupportedFormatFailure());
+        else if (history && !history.complete) warnings.push(incompleteSessionLogFailure());
+        const usage = history?.usage ?? [];
+        return {
+          provider: { id: this.id, displayName: this.displayName },
+          billingDomains: billingDomains(usage),
+          quotaBuckets: [],
+          usage,
+          ...usage.length > 0 && history?.complete ? {
+            usageReconciliation: {
+              authoritativeIdPrefixes: ["dsh-transcript:"],
+              retiredIdPrefixes: []
+            }
+          } : {},
+          costs: history?.costs ?? [],
+          warnings,
+          observedAt
+        };
+      }
+    };
+  }
+});
+
+// src/server/antigravity-quota-client.ts
+import { readdirSync, readFileSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join4 } from "path";
+function mapQuotaGroups(groups) {
+  const buckets = [];
+  for (const group of groups) {
+    const isGemini = /gemini/i.test(group.displayName ?? "");
+    const isClaudeOrGpt = /claude|gpt/i.test(group.displayName ?? "");
+    for (const rawBucket of group.buckets ?? []) {
+      const windowStr = (rawBucket.window ?? "").toLowerCase();
+      const displayStr = (rawBucket.displayName ?? "").toLowerCase();
+      const is5h = windowStr === "5h" || /5[- ]?hour/i.test(displayStr);
+      const isWeekly = windowStr === "weekly" || /week/i.test(displayStr);
+      let durationMinutes;
+      let windowName;
+      if (is5h) {
+        durationMinutes = 300;
+        windowName = "5 hour";
+      } else if (isWeekly) {
+        durationMinutes = 10080;
+        windowName = "Week";
+      } else {
+        continue;
+      }
+      let label = windowName;
+      if (!isGemini) {
+        if (isClaudeOrGpt) {
+          label = `Claude / GPT \xB7 ${windowName}`;
+        } else if (group.displayName) {
+          label = `${group.displayName} \xB7 ${windowName}`;
+        }
+      }
+      const usedPercent = typeof rawBucket.remainingFraction === "number" ? Math.max(0, Math.min(100, Math.round((1 - rawBucket.remainingFraction) * 100))) : null;
+      buckets.push({
+        id: rawBucket.bucketId || `${isGemini ? "gemini" : "3p"}-${windowStr}`,
+        billingDomainId: ANTIGRAVITY_PRIMARY_BILLING_DOMAIN_ID,
+        label,
+        usedPercent,
+        windowDurationMinutes: durationMinutes,
+        resetsAt: rawBucket.resetTime ?? null,
+        authority: "official-client",
+        scope: "account-wide"
+      });
+    }
+  }
+  return buckets;
+}
+var AntigravityQuotaClient;
+var init_antigravity_quota_client = __esm({
+  "src/server/antigravity-quota-client.ts"() {
+    "use strict";
+    init_antigravity_connector();
+    AntigravityQuotaClient = class {
+      #logRoots;
+      #ports;
+      #fetchFn;
+      #timeoutMs;
+      constructor(options = {}) {
+        this.#logRoots = options.logRoots ?? [
+          join4(homedir2(), "Library/Logs/Antigravity"),
+          join4(homedir2(), ".gemini/antigravity-cli/log"),
+          join4(homedir2(), ".gemini/antigravity/log")
+        ];
+        this.#ports = options.ports;
+        this.#fetchFn = options.fetchFn ?? globalThis.fetch;
+        this.#timeoutMs = options.timeoutMs ?? 1500;
+      }
+      async readQuota() {
+        const { ports, csrfToken } = this.discoverCandidates();
+        const candidatePorts = this.#ports ?? ports;
+        if (candidatePorts.length === 0) {
+          return null;
+        }
+        for (const port of candidatePorts) {
+          const quota = await this.queryPort(port, csrfToken);
+          if (quota) {
+            return quota;
+          }
+        }
+        return null;
+      }
+      discoverCandidates() {
+        let csrfToken = process.env.ANTIGRAVITY_CSRF_TOKEN ?? null;
+        const ports = [];
+        const httpPortRegex = /(?:Language server listening on random port at|Reloading all windows with URL: https?:\/\/127\.0\.0\.1:|Local:\s+https?:\/\/127\.0\.0\.1:|Host bridge server listening on http:\/\/127\.0\.0\.1:)\s*(\d+)/g;
+        const csrfRegex = /--csrf_token[= ]([a-f0-9-]+)/;
+        for (const root of this.#logRoots) {
+          try {
+            const files = readdirSync(root).filter((file) => file.endsWith(".log")).sort().reverse().slice(0, 10);
+            for (const file of files) {
+              const filePath = join4(root, file);
+              try {
+                const content = readFileSync(filePath, "utf8");
+                if (!csrfToken) {
+                  const csrfMatch = csrfRegex.exec(content);
+                  if (csrfMatch) csrfToken = csrfMatch[1];
+                }
+                let match;
+                while ((match = httpPortRegex.exec(content)) !== null) {
+                  const basePort = Number(match[1]);
+                  ports.push(basePort);
+                  ports.push(basePort + 1);
+                  ports.push(basePort + 2);
+                }
+              } catch {
+              }
+            }
+          } catch {
+          }
+        }
+        return {
+          ports: [...new Set(ports.reverse())],
+          csrfToken
+        };
+      }
+      discoverCandidatePorts() {
+        return this.discoverCandidates().ports;
+      }
+      async queryPort(port, csrfToken = null) {
+        try {
+          const url = `http://127.0.0.1:${port}/exa.language_server_pb.LanguageServerService/RetrieveUserQuotaSummary`;
+          const response = await this.#fetchFn(url, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "Connect-Protocol-Version": "1",
+              ...csrfToken ? { "x-codeium-csrf-token": csrfToken } : {}
+            },
+            body: JSON.stringify({}),
+            signal: AbortSignal.timeout(this.#timeoutMs)
+          });
+          if (!response.ok) {
+            return null;
+          }
+          const body = await response.json();
+          const groups = body.response?.groups;
+          if (!Array.isArray(groups) || groups.length === 0) {
+            return null;
+          }
+          return mapQuotaGroups(groups);
+        } catch {
+          return null;
+        }
+      }
+    };
+  }
+});
+
+// src/connectors/antigravity/antigravity-connector.ts
+function buildAntigravityQuotaBuckets(usage, nowMs, limits = DEFAULT_ANTIGRAVITY_QUOTA_LIMITS) {
+  const fiveHoursMs = 300 * 60 * 1e3;
+  const sevenDaysMs = 7 * 24 * 60 * 60 * 1e3;
+  const cutoff5h = nowMs - fiveHoursMs;
+  const cutoff7d = nowMs - sevenDaysMs;
+  const obs5h = [];
+  const obs7d = [];
+  for (const obs of usage) {
+    const t = new Date(obs.observedAt).getTime();
+    if (t >= cutoff5h) obs5h.push(obs);
+    if (t >= cutoff7d) obs7d.push(obs);
+  }
+  const tokens5h = obs5h.reduce(
+    (acc, obs) => acc + obs.inputTokens + obs.outputTokens + obs.cacheReadTokens,
+    0
+  );
+  const usedPercent5h = Math.min(100, Math.round(tokens5h / limits.rolling5hTokens * 100));
+  let resetsAt5h;
+  if (obs5h.length > 0) {
+    const oldestMs = Math.min(...obs5h.map((o) => new Date(o.observedAt).getTime()));
+    resetsAt5h = new Date(oldestMs + fiveHoursMs).toISOString();
+  } else {
+    resetsAt5h = new Date(nowMs + fiveHoursMs).toISOString();
+  }
+  const tokens7d = obs7d.reduce(
+    (acc, obs) => acc + obs.inputTokens + obs.outputTokens + obs.cacheReadTokens,
+    0
+  );
+  const usedPercent7d = Math.min(100, Math.round(tokens7d / limits.weeklyTokens * 100));
+  let resetsAt7d;
+  if (obs7d.length > 0) {
+    const oldestMs = Math.min(...obs7d.map((o) => new Date(o.observedAt).getTime()));
+    resetsAt7d = new Date(oldestMs + sevenDaysMs).toISOString();
+  } else {
+    resetsAt7d = new Date(nowMs + sevenDaysMs).toISOString();
+  }
+  return [
+    {
+      id: "gemini-5h",
+      billingDomainId: ANTIGRAVITY_PRIMARY_BILLING_DOMAIN_ID,
+      label: "5 hour",
+      usedPercent: usedPercent5h,
+      windowDurationMinutes: 300,
+      resetsAt: resetsAt5h,
+      authority: "local-observation",
+      scope: "local-only"
+    },
+    {
+      id: "gemini-weekly",
+      billingDomainId: ANTIGRAVITY_PRIMARY_BILLING_DOMAIN_ID,
+      label: "Week",
+      usedPercent: usedPercent7d,
+      windowDurationMinutes: 10080,
+      resetsAt: resetsAt7d,
+      authority: "local-observation",
+      scope: "local-only"
+    }
+  ];
+}
+function billingDomains2(usage) {
+  const primary = {
+    id: ANTIGRAVITY_PRIMARY_BILLING_DOMAIN_ID,
+    displayName: "Gemini Code Assist"
+  };
+  const observedRoutes = [...new Set(usage.map((obs) => obs.billingDomainId))].filter((id) => id !== primary.id).sort();
+  return [primary, ...observedRoutes.map((id) => ({ id, displayName: id }))];
+}
+function incompleteSessionScanFailure() {
+  return {
+    code: "antigravity-session-scan-incomplete",
+    message: "Some local Antigravity conversation databases could not be read.",
+    recovery: "Agent Usage will retry automatically on the next scan without removing stored history."
+  };
+}
+function safeFailure6() {
+  return {
+    code: "antigravity-sqlite-read-failed",
+    message: "Failed to read local Antigravity conversation stores.",
+    recovery: "Check read permissions for ~/.gemini/antigravity-cli and ~/.gemini/antigravity directories."
+  };
+}
+var ANTIGRAVITY_PRIMARY_BILLING_DOMAIN_ID, DEFAULT_ANTIGRAVITY_QUOTA_LIMITS, AntigravityConnector;
+var init_antigravity_connector = __esm({
+  "src/connectors/antigravity/antigravity-connector.ts"() {
+    "use strict";
+    init_antigravity_quota_client();
+    ANTIGRAVITY_PRIMARY_BILLING_DOMAIN_ID = "code-assist-subscription";
+    DEFAULT_ANTIGRAVITY_QUOTA_LIMITS = {
+      rolling5hTokens: 15e6,
+      weeklyTokens: 1e8
+    };
+    AntigravityConnector = class {
+      id = "antigravity";
+      displayName = "Antigravity";
+      consentId = "antigravity";
+      #historyClient;
+      #quotaClient;
+      #clock;
+      #quotaLimits;
+      constructor(options) {
+        this.#historyClient = options.historyClient;
+        this.#quotaClient = options.quotaClient ?? new AntigravityQuotaClient();
+        this.#clock = options.clock ?? (() => /* @__PURE__ */ new Date());
+        this.#quotaLimits = {
+          rolling5hTokens: options.quotaLimits?.rolling5hTokens ?? DEFAULT_ANTIGRAVITY_QUOTA_LIMITS.rolling5hTokens,
+          weeklyTokens: options.quotaLimits?.weeklyTokens ?? DEFAULT_ANTIGRAVITY_QUOTA_LIMITS.weeklyTokens
+        };
+      }
+      async collect(options = { mode: "incremental" }) {
+        const observedAt = this.#clock().toISOString();
+        const nowMs = this.#clock().getTime();
+        const warnings = [];
+        let history = null;
+        try {
+          history = await this.#historyClient.readUsage(options);
+        } catch {
+          warnings.push(safeFailure6());
+        }
+        if (history && !history.complete) {
+          warnings.push(incompleteSessionScanFailure());
+        }
+        const usage = history?.usage ?? [];
+        let quotaBuckets = [];
+        try {
+          const liveQuota = await this.#quotaClient.readQuota();
+          if (liveQuota && liveQuota.length > 0) {
+            quotaBuckets = [...liveQuota];
+          }
+        } catch {
+        }
+        const localBuckets = buildAntigravityQuotaBuckets(usage, nowMs, this.#quotaLimits);
+        const has5h = quotaBuckets.some((b) => b.label === "5 hour" || b.id === "gemini-5h");
+        const hasWeekly = quotaBuckets.some((b) => b.label === "Week" || b.id === "gemini-weekly");
+        if (!has5h || !hasWeekly) {
+          for (const localBucket of localBuckets) {
+            if (!quotaBuckets.some((b) => b.id === localBucket.id || b.label === localBucket.label)) {
+              quotaBuckets.push(localBucket);
+            }
+          }
+        }
+        return {
+          provider: { id: this.id, displayName: this.displayName },
+          billingDomains: billingDomains2(usage),
+          quotaBuckets,
+          usage,
+          ...usage.length > 0 && history?.complete ? {
+            usageReconciliation: {
+              authoritativeIdPrefixes: ["antigravity:"],
+              retiredIdPrefixes: []
+            }
+          } : {},
+          costs: history?.costs ?? [],
+          warnings,
+          observedAt
+        };
+      }
+    };
+  }
+});
+
+// src/server/antigravity-sqlite-usage-client.ts
+import { createHash as createHash3 } from "crypto";
+import { readdir, readFile as readFile4, rename as rename3, stat as stat2, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
+import { createRequire as createRequire2 } from "module";
+import { dirname as dirname2, join as join5 } from "path";
+import protobuf from "protobufjs";
+function parseAntigravityDatabase(dbPath, conversationId, fallbackMtimeMs) {
+  const db = new DatabaseSync2(dbPath, { readOnly: true });
+  try {
+    const tableExists = db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='gen_metadata'").get();
+    if (!tableExists) return [];
+    const stepTimestamps = /* @__PURE__ */ new Map();
+    try {
+      const stepRows = db.prepare("SELECT idx, metadata FROM steps WHERE length(metadata) > 0").all();
+      for (const row of stepRows) {
+        const ts = extractTimestampFromStepMetadata(row.metadata);
+        if (ts !== null) stepTimestamps.set(row.idx, ts);
+      }
+    } catch {
+    }
+    const genRows = db.prepare("SELECT idx, data FROM gen_metadata ORDER BY idx ASC").all();
+    const records = [];
+    for (const row of genRows) {
+      if (!row.data || row.data.length === 0) continue;
+      const parsed = decodeGenMetadata(row.data);
+      if (parsed.inputTokens === 0 && parsed.outputTokens === 0 && parsed.cacheReadTokens === 0) {
+        continue;
+      }
+      const timestampMs = stepTimestamps.get(row.idx) ?? fallbackMtimeMs;
+      const observedAt = new Date(timestampMs).toISOString();
+      const dedupeKey = `antigravity:${conversationId}:${row.idx}`;
+      const observation = {
+        id: dedupeKey,
+        billingDomainId: "code-assist-subscription",
+        model: parsed.canonicalModel,
+        observedAt,
+        inputTokens: parsed.inputTokens,
+        outputTokens: parsed.outputTokens,
+        reasoningTokens: 0,
+        cacheReadTokens: parsed.cacheReadTokens,
+        cacheWriteTokens: 0,
+        tokenSemantics: {
+          reasoning: "included-in-output",
+          cacheRead: "separate",
+          cacheWrite: "separate"
+        },
+        modelAttribution: "known",
+        timePrecision: "event",
+        usageScope: "this-mac",
+        aggregationTemporality: "delta",
+        authority: "local-observation"
+      };
+      normalizeTokenObservation(observation);
+      records.push({ dedupeKey, observation });
+    }
+    return records;
+  } finally {
+    db.close();
+  }
+}
+function decodeGenMetadata(buf) {
+  let rawModel = "unknown";
+  let inputTokens = 0;
+  const outputTokens = 0;
+  let cacheReadTokens = 0;
+  try {
+    const r = protobuf.Reader.create(buf);
+    while (r.pos < r.len) {
+      const tag = r.uint32();
+      const fn = tag >>> 3;
+      const wt = tag & 7;
+      if (fn === 1 && wt === 2) {
+        const sub1 = r.bytes();
+        const rSub = protobuf.Reader.create(sub1);
+        while (rSub.pos < rSub.len) {
+          const sTag = rSub.uint32();
+          const sFn = sTag >>> 3;
+          const sWt = sTag & 7;
+          if (sFn === 19 && sWt === 2) {
+            rawModel = Buffer.from(rSub.bytes()).toString("utf8");
+          } else if (sFn === 9 && sWt === 2) {
+            const sub9 = rSub.bytes();
+            const r9 = protobuf.Reader.create(sub9);
+            while (r9.pos < r9.len) {
+              const t9 = r9.uint32();
+              const fn9 = t9 >>> 3;
+              const wt9 = t9 & 7;
+              if (fn9 === 10 && wt9 === 2) {
+                const sub10 = r9.bytes();
+                const r10 = protobuf.Reader.create(sub10);
+                while (r10.pos < r10.len) {
+                  const t10 = r10.uint32();
+                  const fn10 = t10 >>> 3;
+                  const wt10 = t10 & 7;
+                  if (fn10 === 1 && wt10 === 0) {
+                    inputTokens = toNumeric(r10.uint64());
+                  } else if (fn10 === 3 && wt10 === 2) {
+                    const sub3 = r10.bytes();
+                    const r3 = protobuf.Reader.create(sub3);
+                    while (r3.pos < r3.len) {
+                      const t3 = r3.uint32();
+                      const fn3 = t3 >>> 3;
+                      const wt3 = t3 & 7;
+                      if (fn3 === 2 && wt3 === 0) {
+                        cacheReadTokens = toNumeric(r3.uint64());
+                      } else {
+                        r3.skipType(wt3);
+                      }
+                    }
+                  } else {
+                    r10.skipType(wt10);
+                  }
+                }
+              } else {
+                r9.skipType(wt9);
+              }
+            }
+          } else {
+            rSub.skipType(sWt);
+          }
+        }
+      } else {
+        r.skipType(wt);
+      }
+    }
+  } catch {
+  }
+  return {
+    rawModel,
+    canonicalModel: canonicalizeAntigravityModel(rawModel),
+    inputTokens,
+    outputTokens,
+    cacheReadTokens
+  };
+}
+function canonicalizeAntigravityModel(raw) {
+  const normalized = raw.trim().toLowerCase().replace(/[\s_]+/g, "-");
+  if (normalized.startsWith("gemini-3p7") || normalized.startsWith("gemini-3.7")) {
+    return "gemini-3.7-flash";
+  }
+  if (normalized.startsWith("gemini-3p6") || normalized.startsWith("gemini-3.6")) {
+    return "gemini-3.6-flash";
+  }
+  if (normalized.startsWith("gemini-3p1") || normalized.startsWith("gemini-3.1")) {
+    return "gemini-3.1-pro";
+  }
+  if (normalized.includes("claude-sonnet")) {
+    return "claude-sonnet-4-6";
+  }
+  if (normalized.includes("claude-opus")) {
+    return "claude-opus-4-6-thinking";
+  }
+  if (normalized.includes("gpt-oss")) {
+    return "gpt-oss-120b-medium";
+  }
+  return raw.trim() || "unknown";
+}
+function extractTimestampFromStepMetadata(buf) {
+  try {
+    const r = protobuf.Reader.create(buf);
+    while (r.pos < r.len) {
+      const tag = r.uint32();
+      const fn = tag >>> 3;
+      const wt = tag & 7;
+      if (fn === 1 && wt === 2) {
+        const tsBytes = r.bytes();
+        const rTs = protobuf.Reader.create(tsBytes);
+        let seconds = 0;
+        let nanos = 0;
+        while (rTs.pos < rTs.len) {
+          const t = rTs.uint32();
+          const tFn = t >>> 3;
+          const tWt = t & 7;
+          if (tFn === 1 && tWt === 0) {
+            seconds = toNumeric(rTs.uint64());
+          } else if (tFn === 2 && tWt === 0) {
+            nanos = toNumeric(rTs.uint64());
+          } else {
+            rTs.skipType(tWt);
+          }
+        }
+        if (seconds > 0) {
+          return seconds * 1e3 + Math.floor(nanos / 1e6);
+        }
+      } else {
+        r.skipType(wt);
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function toNumeric(val) {
+  return Number(val?.toString?.() ?? 0);
+}
+function stableId2(value) {
+  return createHash3("sha256").update(value).digest("hex").slice(0, 16);
+}
+function isCachedDatabaseFile(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const rec = value;
+  return typeof rec.path === "string" && typeof rec.size === "number" && typeof rec.mtimeMs === "number" && Array.isArray(rec.records) && typeof rec.recordsDigest === "string";
+}
+var DatabaseSync2, AntigravitySqliteUsageClient;
+var init_antigravity_sqlite_usage_client = __esm({
+  "src/server/antigravity-sqlite-usage-client.ts"() {
+    "use strict";
+    init_token_normalization();
+    init_retail_pricing();
+    ({ DatabaseSync: DatabaseSync2 } = createRequire2(import.meta.url)(
+      "node:sqlite"
+    ));
+    AntigravitySqliteUsageClient = class {
+      #roots;
+      #clock;
+      #lookbackDays;
+      #cachePath;
+      #priceCatalog;
+      #fileCache = /* @__PURE__ */ new Map();
+      #cacheLoaded = false;
+      constructor(options) {
+        this.#roots = options.roots;
+        this.#clock = options.clock ?? (() => /* @__PURE__ */ new Date());
+        this.#lookbackDays = options.lookbackDays ?? 90;
+        this.#cachePath = options.cachePath;
+        this.#priceCatalog = options.priceCatalog ?? OFFICIAL_PRICING_CATALOG;
+      }
+      async readUsage(options = { mode: "incremental" }) {
+        await this.#loadCache();
+        if (options.mode === "hard-rebuild") this.#fileCache.clear();
+        const cutoff = this.#clock().getTime() - this.#lookbackDays * 24 * 60 * 60 * 1e3;
+        const discoveredFiles = await this.#discoverDatabases(cutoff);
+        const livePaths = new Set(discoveredFiles.map((file) => stableId2(file.path)));
+        for (const path of this.#fileCache.keys()) {
+          if (!livePaths.has(path)) this.#fileCache.delete(path);
+        }
+        const usage = [];
+        const seenDedupeKeys = /* @__PURE__ */ new Set();
+        let allComplete = true;
+        for (const file of discoveredFiles) {
+          const parsed = await this.#parseDatabaseFile(file);
+          allComplete &&= parsed.complete;
+          for (const record of parsed.records) {
+            if (new Date(record.observation.observedAt).getTime() < cutoff) continue;
+            if (seenDedupeKeys.has(record.dedupeKey)) continue;
+            seenDedupeKeys.add(record.dedupeKey);
+            usage.push(record.observation);
+          }
+        }
+        usage.sort((a, b) => a.observedAt.localeCompare(b.observedAt) || a.id.localeCompare(b.id));
+        const { costs } = deriveRetailEquivalentCosts(
+          {
+            provider: { id: "antigravity", displayName: "Antigravity" },
+            billingDomains: [{ id: "code-assist-subscription", displayName: "Gemini Code Assist" }],
+            quotaBuckets: [],
+            usage,
+            costs: [],
+            observedAt: this.#clock().toISOString()
+          },
+          this.#priceCatalog
+        );
+        await this.#persistCache();
+        return {
+          usage,
+          costs,
+          complete: allComplete
+        };
+      }
+      async #discoverDatabases(cutoff) {
+        const results = [];
+        const seenDbPaths = /* @__PURE__ */ new Set();
+        for (const root of this.#roots) {
+          try {
+            const rootStat = await stat2(root);
+            if (!rootStat.isDirectory()) continue;
+          } catch {
+            continue;
+          }
+          const summariesPath = join5(root, "conversation_summaries.db");
+          const candidateIds = /* @__PURE__ */ new Set();
+          let summariesLoaded = false;
+          try {
+            const summariesStat = await stat2(summariesPath);
+            if (summariesStat.isFile()) {
+              const db = new DatabaseSync2(summariesPath, { readOnly: true });
+              try {
+                const rows = db.prepare("SELECT conversation_id, last_modified_time FROM conversation_summaries").all();
+                for (const row of rows) {
+                  if (!row.conversation_id) continue;
+                  const modifiedMs = row.last_modified_time ? new Date(row.last_modified_time).getTime() : 0;
+                  if (modifiedMs >= cutoff || modifiedMs === 0) {
+                    candidateIds.add(row.conversation_id);
+                  }
+                }
+                summariesLoaded = true;
+              } finally {
+                db.close();
+              }
+            }
+          } catch {
+          }
+          const convDir = join5(root, "conversations");
+          try {
+            const entries = await readdir(convDir);
+            for (const entry of entries) {
+              if (!entry.endsWith(".db")) continue;
+              const convId = entry.slice(0, -3);
+              if (summariesLoaded && candidateIds.size > 0 && !candidateIds.has(convId)) {
+                continue;
+              }
+              const fullPath = join5(convDir, entry);
+              if (seenDbPaths.has(fullPath)) continue;
+              seenDbPaths.add(fullPath);
+              try {
+                const fileStat = await stat2(fullPath);
+                if (fileStat.mtimeMs < cutoff && summariesLoaded) continue;
+                results.push({
+                  path: fullPath,
+                  size: fileStat.size,
+                  mtimeMs: fileStat.mtimeMs,
+                  conversationId: convId
+                });
+              } catch {
+              }
+            }
+          } catch {
+          }
+        }
+        return results;
+      }
+      async #parseDatabaseFile(file) {
+        const cached = this.#fileCache.get(stableId2(file.path));
+        if (cached && cached.size === file.size && cached.mtimeMs === file.mtimeMs) {
+          return { records: cached.records, complete: true };
+        }
+        try {
+          const records = parseAntigravityDatabase(file.path, file.conversationId, file.mtimeMs);
+          const digest = stableId2(JSON.stringify(records));
+          this.#fileCache.set(stableId2(file.path), {
+            path: file.path,
+            size: file.size,
+            mtimeMs: file.mtimeMs,
+            records,
+            recordsDigest: digest
+          });
+          return { records, complete: true };
+        } catch {
+          return { records: [], complete: false };
+        }
+      }
+      async #loadCache() {
+        if (this.#cacheLoaded) return;
+        this.#cacheLoaded = true;
+        if (!this.#cachePath) return;
+        try {
+          const content = await readFile4(this.#cachePath, "utf8");
+          const stored = JSON.parse(content);
+          if (stored.version !== 1 || !Array.isArray(stored.files)) return;
+          for (const item of stored.files) {
+            if (!isCachedDatabaseFile(item)) continue;
+            if (item.recordsDigest !== stableId2(JSON.stringify(item.records))) continue;
+            this.#fileCache.set(stableId2(item.path), item);
+          }
+        } catch {
+        }
+      }
+      async #persistCache() {
+        if (!this.#cachePath) return;
+        try {
+          await mkdir3(dirname2(this.#cachePath), { recursive: true, mode: 448 });
           const temporary = `${this.#cachePath}.${process.pid}.tmp`;
-          await writeFile2(
+          await writeFile3(
             temporary,
             JSON.stringify({ version: 1, files: [...this.#fileCache.values()] }),
             { mode: 384 }
           );
-          await rename2(temporary, this.#cachePath);
+          await rename3(temporary, this.#cachePath);
         } catch {
         }
       }
@@ -4780,83 +5814,6 @@ var init_local_transcript_usage_client = __esm({
   }
 });
 
-// src/connectors/dsh/dsh-connector.ts
-function billingDomains(usage) {
-  const primary = { id: DSH_PRIMARY_BILLING_DOMAIN_ID, displayName: "DeepSeek API" };
-  const observedRoutes = [...new Set(usage.map((observation) => observation.billingDomainId))].filter((id) => id !== primary.id).sort();
-  return [primary, ...observedRoutes.map((id) => ({ id, displayName: id }))];
-}
-function incompleteSessionLogFailure() {
-  return {
-    code: "dsh-session-log-scan-incomplete",
-    message: "Some local dsh session history could not be read.",
-    recovery: "Agent Usage will retry automatically without removing stored history."
-  };
-}
-function unsupportedFormatFailure() {
-  return {
-    code: "dsh-session-format-unsupported",
-    message: "A dsh session log declares an on-disk format this version does not read.",
-    recovery: "Update Agent Usage; stored dsh history from earlier scans is retained."
-  };
-}
-function safeFailure5(error) {
-  if (error instanceof Error && "code" in error && typeof error.code === "string" && "recovery" in error && typeof error.recovery === "string") {
-    return { code: error.code, message: error.message, recovery: error.recovery };
-  }
-  return {
-    code: "dsh-session-log-read-failed",
-    message: "Local dsh session history is unavailable.",
-    recovery: "Run agent-usage doctor, then retry refresh."
-  };
-}
-var DshConnector;
-var init_dsh_connector = __esm({
-  "src/connectors/dsh/dsh-connector.ts"() {
-    "use strict";
-    init_local_transcript_usage_client();
-    DshConnector = class {
-      id = "dsh";
-      displayName = "dsh";
-      consentId = "dsh";
-      #historyClient;
-      #clock;
-      constructor(options) {
-        this.#historyClient = options.historyClient;
-        this.#clock = options.clock ?? (() => /* @__PURE__ */ new Date());
-      }
-      async collect(options = { mode: "incremental" }) {
-        const observedAt = this.#clock().toISOString();
-        const warnings = [];
-        let history = null;
-        try {
-          history = await this.#historyClient.readUsage(options);
-        } catch (error) {
-          warnings.push(safeFailure5(error));
-        }
-        if (history?.unsupportedFormat) warnings.push(unsupportedFormatFailure());
-        else if (history && !history.complete) warnings.push(incompleteSessionLogFailure());
-        const usage = history?.usage ?? [];
-        return {
-          provider: { id: this.id, displayName: this.displayName },
-          billingDomains: billingDomains(usage),
-          quotaBuckets: [],
-          usage,
-          ...usage.length > 0 && history?.complete ? {
-            usageReconciliation: {
-              authoritativeIdPrefixes: ["dsh-transcript:"],
-              retiredIdPrefixes: []
-            }
-          } : {},
-          costs: history?.costs ?? [],
-          warnings,
-          observedAt
-        };
-      }
-    };
-  }
-});
-
 // src/connectors/grok-build/grok-build-connector.ts
 import { z as z6 } from "zod";
 function incompleteTranscriptFailure3() {
@@ -4919,7 +5876,7 @@ function derivePercent(used, limit) {
   if (used === void 0 || limit === void 0 || limit <= 0) return null;
   return Math.min(100, Math.max(0, used / limit * 100));
 }
-function safeFailure6(error) {
+function safeFailure7(error) {
   if (error instanceof Error && "code" in error && typeof error.code === "string" && "recovery" in error && typeof error.recovery === "string") {
     return { code: error.code, message: error.message, recovery: error.recovery };
   }
@@ -4982,7 +5939,7 @@ var init_grok_build_connector = __esm({
             });
           }
         } catch (error) {
-          warnings.push(safeFailure6(error));
+          warnings.push(safeFailure7(error));
         }
         const history = this.#historyClient ? await this.#historyClient.readUsage(options) : { usage: [], costs: [], complete: true };
         if (!history.complete) warnings.push(incompleteTranscriptFailure3());
@@ -5123,8 +6080,8 @@ var init_grok_telemetry = __esm({
 // src/connectors/grok-build/stdio-grok-billing-client.ts
 import { spawn as spawn3 } from "child_process";
 import { open } from "fs/promises";
-import { homedir as homedir2 } from "os";
-import { join as join4 } from "path";
+import { homedir as homedir3 } from "os";
+import { join as join6 } from "path";
 import { z as z7 } from "zod";
 function billingIsFresh(billing, now) {
   if (!billing.sourceObservedAt) return false;
@@ -5249,7 +6206,7 @@ var init_stdio_grok_billing_client = __esm({
           stdio: ["pipe", "pipe", "pipe"]
         }));
         this.#readUnifiedLog = options.readUnifiedLog ?? (() => readLogTail(
-          join4(process.env.GROK_HOME ?? join4(homedir2(), ".grok"), "logs", "unified.jsonl")
+          join6(process.env.GROK_HOME ?? join6(homedir3(), ".grok"), "logs", "unified.jsonl")
         ));
         this.#refreshBillingLog = options.refreshBillingLog ?? (options.readUnifiedLog ? async () => void 0 : () => refreshBillingLogViaDashboard(this.#command, this.#timeoutMs));
         this.#clock = options.clock ?? (() => /* @__PURE__ */ new Date());
@@ -5620,7 +6577,7 @@ function endpointFailure(error, label) {
     recovery: "Check network access and xAI status, then retry."
   };
 }
-function safeFailure7(error) {
+function safeFailure8(error) {
   if (error instanceof Error && "code" in error && typeof error.code === "string" && "recovery" in error && typeof error.recovery === "string") {
     return { code: error.code, message: error.message, recovery: error.recovery };
   }
@@ -5875,7 +6832,7 @@ var init_xai_api_connector = __esm({
             costs: [],
             balances: [],
             invoices: [],
-            warnings: [safeFailure7(error)],
+            warnings: [safeFailure8(error)],
             observedAt
           };
         }
@@ -6074,8 +7031,8 @@ var init_macos_notifier = __esm({
 });
 
 // src/server/macos-start-at-login-manager.ts
-import { mkdir as mkdir3, rm, writeFile as writeFile3 } from "fs/promises";
-import { dirname as dirname2, isAbsolute, join as join5 } from "path";
+import { mkdir as mkdir4, rm, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname3, isAbsolute, join as join7 } from "path";
 function launchAgentPlist(options) {
   const label = options.label ?? LABEL;
   const arguments_ = [
@@ -6127,15 +7084,15 @@ var init_macos_start_at_login_manager = __esm({
         const label = validateLaunchAgentLabel(options.label ?? LABEL);
         if (options.nodeImport) validateNodeImport(options.nodeImport);
         this.#options = { ...options, label };
-        this.#path = join5(options.userHome, "Library", "LaunchAgents", `${label}.plist`);
+        this.#path = join7(options.userHome, "Library", "LaunchAgents", `${label}.plist`);
       }
       async setEnabled(enabled) {
         if (!enabled) {
           await rm(this.#path, { force: true });
           return;
         }
-        await mkdir3(dirname2(this.#path), { recursive: true, mode: 448 });
-        await writeFile3(this.#path, launchAgentPlist(this.#options), { mode: 384 });
+        await mkdir4(dirname3(this.#path), { recursive: true, mode: 448 });
+        await writeFile4(this.#path, launchAgentPlist(this.#options), { mode: 384 });
       }
       async isEnabled() {
         try {
@@ -6252,7 +7209,7 @@ var init_otlp_protobuf = __esm({
 // src/server/local-server.ts
 import { createReadStream as createReadStream2, existsSync, statSync } from "fs";
 import { createServer } from "http";
-import { extname, join as join6, normalize, resolve } from "path";
+import { extname, join as join8, normalize, resolve } from "path";
 import { randomBytes } from "crypto";
 import { z as z9 } from "zod";
 async function startLocalServer(options) {
@@ -6432,6 +7389,53 @@ async function startLocalServer(options) {
         sendJson(response, 200, await options.application.updatePlanSubscription(input));
         return;
       }
+      if (request.method === "GET" && requestUrl.pathname === "/api/custom-rates") {
+        const rates = await options.application.getCustomModelRates();
+        sendJson(response, 200, { rates });
+        return;
+      }
+      if (request.method === "GET" && requestUrl.pathname.startsWith("/api/custom-rates/")) {
+        const id = decodeURIComponent(requestUrl.pathname.slice("/api/custom-rates/".length));
+        const rate = await options.application.getCustomModelRate(id);
+        if (!rate) {
+          sendJson(response, 404, { error: "rate-not-found" });
+          return;
+        }
+        sendJson(response, 200, { rate });
+        return;
+      }
+      if (request.method === "POST" && requestUrl.pathname === "/api/custom-rates") {
+        if (!validMutationOrigin(authentication, request, origin)) {
+          sendJson(response, 403, { error: "invalid-origin" });
+          return;
+        }
+        const input = customModelRateSchema.parse(await readJsonBody(request));
+        const rate = await options.application.setCustomModelRate(input);
+        sendJson(response, 200, { rate });
+        return;
+      }
+      if ((request.method === "PUT" || request.method === "PATCH") && requestUrl.pathname.startsWith("/api/custom-rates/")) {
+        if (!validMutationOrigin(authentication, request, origin)) {
+          sendJson(response, 403, { error: "invalid-origin" });
+          return;
+        }
+        const id = decodeURIComponent(requestUrl.pathname.slice("/api/custom-rates/".length));
+        const body = await readJsonBody(request);
+        const input = customModelRateSchema.parse({ ...body, id });
+        const rate = await options.application.setCustomModelRate(input);
+        sendJson(response, 200, { rate });
+        return;
+      }
+      if (request.method === "DELETE" && requestUrl.pathname.startsWith("/api/custom-rates/")) {
+        if (!validMutationOrigin(authentication, request, origin)) {
+          sendJson(response, 403, { error: "invalid-origin" });
+          return;
+        }
+        const id = decodeURIComponent(requestUrl.pathname.slice("/api/custom-rates/".length));
+        const deleted = await options.application.deleteCustomModelRate(id);
+        sendJson(response, 200, { deleted });
+        return;
+      }
       if (request.method === "GET" && requestUrl.pathname === "/api/monitoring") {
         sendJson(response, 200, await options.application.getMonitoringStatus());
         return;
@@ -6488,8 +7492,7 @@ async function startLocalServer(options) {
       }
       sendJson(response, 404, { error: "not-found" });
     } catch (error) {
-      const message = publicErrorMessage(error);
-      sendJson(response, 500, { error: "internal-error", message });
+      respondWithFailure(response, error);
     }
   });
   await new Promise((resolveListening, reject) => {
@@ -6575,8 +7578,8 @@ async function serveStatic(response, pathname, staticDirectory) {
   const root = resolve(staticDirectory);
   const requested = pathname === "/" ? "index.html" : pathname.replace(/^\/+/, "");
   const normalized = normalize(requested);
-  const candidate = resolve(join6(root, normalized));
-  const indexFile = join6(root, "index.html");
+  const candidate = resolve(join8(root, normalized));
+  const indexFile = join8(root, "index.html");
   const file = candidate.startsWith(`${root}/`) && existsSync(candidate) && statSync(candidate).isFile() ? candidate : indexFile;
   if (!existsSync(file)) {
     sendText(response, 404, "Dashboard assets are not built");
@@ -6609,11 +7612,28 @@ function secureToken() {
   return randomBytes(32).toString("base64url");
 }
 function sendJson(response, status, body) {
+  const payload = JSON.stringify(body);
   response.writeHead(status, {
     "content-type": "application/json; charset=utf-8",
     "cache-control": "no-store"
   });
-  response.end(JSON.stringify(body));
+  response.end(payload);
+}
+function respondWithFailure(response, error) {
+  const message = publicErrorMessage(error);
+  if (response.headersSent || response.writableEnded) {
+    process.stderr.write(`Agent Usage: a started response failed to finish: ${message}
+`);
+    response.destroy();
+    return;
+  }
+  try {
+    sendJson(response, 500, { error: "internal-error", message });
+  } catch {
+    process.stderr.write(`Agent Usage: a request failed without a reportable reason.
+`);
+    response.destroy();
+  }
 }
 function sendOtlpProtobuf(response, status) {
   response.writeHead(status, {
@@ -6630,7 +7650,7 @@ function sendHtml(response, status, body) {
   response.writeHead(status, { "content-type": "text/html; charset=utf-8" });
   response.end(body);
 }
-var SESSION_COOKIE, connectorActionSchema, usageQuerySchema, monitoringSettingsSchema, planSubscriptionSchema, clearDataSchema, hardRebuildSchema;
+var SESSION_COOKIE, connectorActionSchema, usageQuerySchema, monitoringSettingsSchema, planSubscriptionSchema, customModelRateSchema, clearDataSchema, hardRebuildSchema;
 var init_local_server = __esm({
   "src/server/local-server.ts"() {
     "use strict";
@@ -6664,6 +7684,15 @@ var init_local_server = __esm({
         anchorDate: z9.string().regex(/^\d{4}-\d{2}-\d{2}$/).nullable().optional()
       }).nullable()
     });
+    customModelRateSchema = z9.object({
+      id: z9.string().optional(),
+      providerId: z9.string().min(1),
+      billingDomainId: z9.string().nullable().optional(),
+      model: z9.string().min(1),
+      inputRate: z9.number().nonnegative(),
+      outputRate: z9.number().nonnegative(),
+      cacheReadRate: z9.number().nonnegative().optional()
+    });
     clearDataSchema = z9.object({ deleteProductSecrets: z9.boolean().default(false) });
     hardRebuildSchema = z9.object({ confirmExpensiveOperation: z9.literal(true) });
   }
@@ -6672,7 +7701,7 @@ var init_local_server = __esm({
 // src/server/path-discovery-probe.ts
 import { constants } from "fs";
 import { access } from "fs/promises";
-import { delimiter, isAbsolute as isAbsolute2, join as join7, resolve as resolve2 } from "path";
+import { delimiter, isAbsolute as isAbsolute2, join as join9, resolve as resolve2 } from "path";
 async function isExecutable(path) {
   try {
     await access(path, constants.X_OK);
@@ -6718,7 +7747,7 @@ var init_path_discovery_probe = __esm({
       async #findExecutable(command) {
         if (command.includes("/")) return await isExecutable(command) ? resolve2(command) : null;
         for (const directory of this.#path.split(delimiter).filter(Boolean)) {
-          const candidate = join7(directory, command);
+          const candidate = join9(directory, command);
           if (await isExecutable(candidate)) return candidate;
         }
         return null;
@@ -6729,8 +7758,8 @@ var init_path_discovery_probe = __esm({
 
 // src/server/sqlite-usage-repository.ts
 import { mkdirSync } from "fs";
-import { createRequire as createRequire2 } from "module";
-import { dirname as dirname3 } from "path";
+import { createRequire as createRequire3 } from "module";
+import { dirname as dirname4 } from "path";
 import { Worker } from "worker_threads";
 async function runDatabaseWorker(workerData) {
   return new Promise((resolve5, reject) => {
@@ -7096,7 +8125,7 @@ function buildGlobalSummary(providers, riskSummary, now, query) {
     for (const observedAt of [
       domain.history.lastObservedAt,
       ...domain.quotaBuckets.map((bucket) => bucket.observedAt ?? null),
-      ...domain.costs.map((cost) => cost.observedAt),
+      domain.lastCostObservedAt,
       ...domain.balances.map((balance) => balance.observedAt),
       ...domain.invoices.map((invoice) => invoice.createdAt)
     ]) {
@@ -7358,7 +8387,7 @@ function allDomainHistories(providers) {
       provider,
       domain,
       history: domain.history,
-      includedInHeadline: domain.id === provider.summaryBillingDomainId
+      includedInHeadline: provider.id === "dsh" ? true : domain.id === provider.summaryBillingDomainId
     }))
   );
 }
@@ -7436,25 +8465,28 @@ function buildWorkbenchModelRanking(histories, buckets, comparisonCurrency, reco
   const entries = histories.flatMap(
     ({ provider, domain, history, includedInHeadline }) => history.models.map((model) => {
       const retailEquivalent = buildWorkbenchMetric(
-        model.priceEvidence,
+        model.priceEvidence ?? [],
         "retail-equivalent",
         comparisonCurrency,
         model.tokenEvidence.recordedTokens,
         history.exchangeRates
       );
       const reportedEstimate = buildWorkbenchMetric(
-        model.priceEvidence,
+        model.priceEvidence ?? [],
         "reported-estimate",
         comparisonCurrency,
         model.tokenEvidence.recordedTokens,
         history.exchangeRates
       );
+      const observations = model.observations ?? [];
+      const priceEvidence = model.priceEvidence ?? [];
       const authorities = [
-        ...new Set(model.observations.map((observation) => observation.authority))
+        ...new Set(observations.map((observation) => observation.authority))
       ].sort();
-      const lastObservedAt = [...model.observations].sort(
-        (left, right) => right.observedAt.localeCompare(left.observedAt)
-      )[0]?.observedAt ?? null;
+      const lastObservedAt = observations.reduce(
+        (latest, observation) => latest === null || observation.observedAt > latest ? observation.observedAt : latest,
+        null
+      ) ?? null;
       return {
         id: modelRankingId(provider.id, domain.id, model.model),
         providerId: provider.id,
@@ -7472,28 +8504,28 @@ function buildWorkbenchModelRanking(histories, buckets, comparisonCurrency, reco
         reportedShare: includedInHeadline && reportedEstimate.status === "available" && reportedEstimate.amount !== null && totalReportedEstimate.status === "available" && totalReportedEstimate.amount !== null && totalReportedEstimate.amount !== 0 ? reportedEstimate.amount / totalReportedEstimate.amount : null,
         authorities,
         lastObservedAt,
-        observations: model.observations,
-        priceEvidence: model.priceEvidence,
+        composition: nonOverlappingComposition(observations, model.tokenTotals),
+        priceSnapshots: distinctPriceSnapshots(priceEvidence),
         trend: buckets.map((bucket) => {
-          const observations = model.observations.filter(
+          const bucketObservations = observations.filter(
             (observation) => observation.observedAt >= bucket.start && observation.observedAt < bucket.end
           );
-          const priceEvidence = model.priceEvidence.filter(
+          const bucketPriceEvidence = priceEvidence.filter(
             (cost) => (cost.observedAt ?? "") >= bucket.start && (cost.observedAt ?? "") < bucket.end
           );
-          const tokenTotals = observations.reduce(
+          const tokenTotals = bucketObservations.reduce(
             (total, observation) => addTokenTotals(total, observation.tokenTotals),
             zeroTokenTotals()
           );
           const intervalRetail = buildWorkbenchMetric(
-            priceEvidence,
+            bucketPriceEvidence,
             "retail-equivalent",
             comparisonCurrency,
             tokenTotals.total,
             history.exchangeRates
           );
           const intervalReported = buildWorkbenchMetric(
-            priceEvidence,
+            bucketPriceEvidence,
             "reported-estimate",
             comparisonCurrency,
             tokenTotals.total,
@@ -7503,14 +8535,19 @@ function buildWorkbenchModelRanking(histories, buckets, comparisonCurrency, reco
             start: bucket.start,
             end: bucket.end,
             label: bucket.label,
-            gap: observations.length === 0,
+            gap: bucketObservations.length === 0,
             tokenTotals,
+            recordedTokens: bucketObservations.reduce(
+              (total, observation) => total + observation.recordedTokens,
+              0
+            ),
             authorities: [
-              ...new Set(observations.map((observation) => observation.authority))
+              ...new Set(bucketObservations.map((observation) => observation.authority))
             ].sort(),
-            lastObservedAt: [...observations].sort(
-              (left, right) => right.observedAt.localeCompare(left.observedAt)
-            )[0]?.observedAt ?? null,
+            lastObservedAt: bucketObservations.reduce(
+              (latest, observation) => latest === null || observation.observedAt > latest ? observation.observedAt : latest,
+              null
+            ) ?? null,
             retailEquivalent: {
               status: intervalRetail.status,
               amount: intervalRetail.amount,
@@ -7587,6 +8624,49 @@ function buildWorkbenchModelRanking(histories, buckets, comparisonCurrency, reco
     unclassified
   };
 }
+function dropAuditEvidence(providers) {
+  for (const provider of providers) {
+    for (const domain of provider.billingDomains) {
+      for (const model of domain.history.models) {
+        delete model.observations;
+        delete model.priceEvidence;
+      }
+      delete domain.history.unclassified.observations;
+    }
+  }
+}
+function nonOverlappingComposition(observations, fallback) {
+  if (observations.length === 0) {
+    return {
+      ...fallback,
+      total: fallback.input + fallback.output + fallback.cacheRead + fallback.cacheWrite
+    };
+  }
+  const totals = zeroTokenTotals();
+  for (const observation of observations) {
+    totals.input += observation.tokenTotals.input;
+    totals.output += observation.tokenTotals.output;
+    if (observation.tokenSemantics.reasoning === "separate") {
+      totals.reasoning += observation.tokenTotals.reasoning;
+    }
+    if (observation.tokenSemantics.cacheRead === "separate") {
+      totals.cacheRead += observation.tokenTotals.cacheRead;
+    }
+    if (observation.tokenSemantics.cacheWrite === "separate") {
+      totals.cacheWrite += observation.tokenTotals.cacheWrite;
+    }
+  }
+  totals.total = totals.input + totals.output + totals.reasoning + totals.cacheRead + totals.cacheWrite;
+  return totals;
+}
+function distinctPriceSnapshots(priceEvidence) {
+  const snapshots = /* @__PURE__ */ new Map();
+  for (const evidence of priceEvidence) {
+    const snapshot2 = evidence.priceSnapshot;
+    if (snapshot2 && !snapshots.has(snapshot2.id)) snapshots.set(snapshot2.id, snapshot2);
+  }
+  return [...snapshots.values()];
+}
 function modelRankingId(providerId, billingDomainId, model) {
   return `${providerId}::${billingDomainId}::${model}`;
 }
@@ -8034,7 +9114,7 @@ function freshnessStatus(lastSuccessAt, now) {
   if (!lastSuccessAt) return "unavailable";
   return now.getTime() - new Date(lastSuccessAt).getTime() <= FRESHNESS_WINDOW_MS ? "fresh" : "stale";
 }
-var FRESHNESS_WINDOW_MS, QUERY_INDEXES_SQL, DELETE_DERIVED_RETAIL_COSTS_SQL, DELETE_DEMO_PROVIDER_DATA_SQL, DatabaseSync2, RETENTION_AGGREGATE_SQL, SqliteUsageRepository;
+var FRESHNESS_WINDOW_MS, QUERY_INDEXES_SQL, DELETE_DERIVED_RETAIL_COSTS_SQL, DELETE_DEMO_PROVIDER_DATA_SQL, DatabaseSync3, RETENTION_AGGREGATE_SQL, SqliteUsageRepository;
 var init_sqlite_usage_repository = __esm({
   "src/server/sqlite-usage-repository.ts"() {
     "use strict";
@@ -8075,7 +9155,7 @@ var init_sqlite_usage_repository = __esm({
   DELETE FROM connector_settings WHERE id = 'demo';
   DELETE FROM providers WHERE id = 'demo';
 `;
-    ({ DatabaseSync: DatabaseSync2 } = createRequire2(import.meta.url)(
+    ({ DatabaseSync: DatabaseSync3 } = createRequire3(import.meta.url)(
       "node:sqlite"
     ));
     RETENTION_AGGREGATE_SQL = `
@@ -8106,8 +9186,8 @@ var init_sqlite_usage_repository = __esm({
       constructor(databasePath, options = {}) {
         this.#databasePath = databasePath;
         this.#hideDemoProvider = options.hideDemoProvider ?? false;
-        mkdirSync(dirname3(databasePath), { recursive: true });
-        this.#database = new DatabaseSync2(databasePath);
+        mkdirSync(dirname4(databasePath), { recursive: true });
+        this.#database = new DatabaseSync3(databasePath);
         this.#database.exec("PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON;");
         this.#migrate();
       }
@@ -8171,6 +9251,22 @@ var init_sqlite_usage_repository = __esm({
            limit_currency = excluded.limit_currency,
            fallback_status = excluded.fallback_status`
           );
+          const reportedQuotaDomains = [
+            ...new Set(snapshot2.quotaBuckets.map((bucket) => bucket.billingDomainId))
+          ];
+          if (reportedQuotaDomains.length > 0) {
+            const retiredQuotaStatement = this.#database.prepare(
+              `DELETE FROM quota_buckets
+           WHERE provider_id = ? AND billing_domain_id = ? AND id NOT IN (${snapshot2.quotaBuckets.map(() => "?").join(", ")})`
+            );
+            for (const billingDomainId of reportedQuotaDomains) {
+              retiredQuotaStatement.run(
+                snapshot2.provider.id,
+                billingDomainId,
+                ...snapshot2.quotaBuckets.map((bucket) => bucket.id)
+              );
+            }
+          }
           for (const bucket of snapshot2.quotaBuckets) {
             quotaStatement.run(
               snapshot2.provider.id,
@@ -8532,7 +9628,11 @@ var init_sqlite_usage_repository = __esm({
          price_snapshot_source_url, price_snapshot_context_tier,
          model, usage_observation_id, priced_tokens, line_items_json, calculated_at
        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-       ON CONFLICT(provider_id, id) DO NOTHING`
+       ON CONFLICT(provider_id, id) DO UPDATE SET
+         amount = excluded.amount,
+         price_snapshot_rates_json = excluded.price_snapshot_rates_json,
+         line_items_json = excluded.line_items_json,
+         calculated_at = excluded.calculated_at`
         );
         this.#database.exec("BEGIN IMMEDIATE");
         try {
@@ -8602,7 +9702,7 @@ var init_sqlite_usage_repository = __esm({
         );
         const riskSummary = buildRiskSummary(overviews);
         const planSubscriptions = this.getPlanSubscriptions();
-        return {
+        const overview = {
           generatedAt: now.toISOString(),
           globalSummary: buildGlobalSummary(overviews, riskSummary, now, query),
           workbench: buildTokenMoneyWorkbench(
@@ -8615,13 +9715,15 @@ var init_sqlite_usage_repository = __esm({
           providers: overviews,
           riskSummary
         };
+        if (!query.auditEvidence) dropAuditEvidence(overviews);
+        return overview;
       }
       getAgentProviderIndex(now) {
         const providers = this.#database.prepare("SELECT id, display_name FROM providers ORDER BY id").all();
         return {
           generatedAt: now.toISOString(),
           providers: providers.filter(
-            (provider) => provider.id !== "opencode" && (!this.#hideDemoProvider || provider.id !== "demo")
+            (provider) => provider.id !== "opencode" && provider.id !== "dsh" && (!this.#hideDemoProvider || provider.id !== "demo")
           ).map((provider) => ({ id: provider.id, displayName: provider.display_name }))
         };
       }
@@ -8631,7 +9733,10 @@ var init_sqlite_usage_repository = __esm({
           `SELECT id, display_name, last_success_at, last_error, last_error_code, last_recovery
          FROM providers WHERE id = ?`
         ).get(providerId);
-        return provider ? this.#getProviderOverview(provider, now, query) : null;
+        if (!provider) return null;
+        const overview = this.#getProviderOverview(provider, now, query);
+        if (!query.auditEvidence) dropAuditEvidence([overview]);
+        return overview;
       }
       saveExchangeRateSnapshot(snapshot2) {
         this.#database.prepare(
@@ -8759,6 +9864,95 @@ var init_sqlite_usage_repository = __esm({
       deletePlanSubscription(providerId, billingDomainId) {
         this.#database.prepare("DELETE FROM plan_subscriptions WHERE provider_id = ? AND billing_domain_id = ?").run(providerId, billingDomainId);
       }
+      getCustomModelRates() {
+        const rows = this.#database.prepare(
+          `SELECT id, provider_id, billing_domain_id, model,
+                input_rate, output_rate, cache_read_rate, updated_at
+         FROM custom_model_rates
+         ORDER BY updated_at DESC`
+        ).all();
+        return rows.map((row) => ({
+          id: row.id,
+          providerId: row.provider_id,
+          billingDomainId: row.billing_domain_id ?? null,
+          model: row.model,
+          ratesPerMillion: {
+            input: row.input_rate,
+            output: row.output_rate,
+            cacheRead: row.cache_read_rate
+          },
+          updatedAt: row.updated_at
+        }));
+      }
+      getCustomModelRate(id) {
+        const row = this.#database.prepare(
+          `SELECT id, provider_id, billing_domain_id, model,
+                input_rate, output_rate, cache_read_rate, updated_at
+         FROM custom_model_rates
+         WHERE id = ?`
+        ).get(id);
+        if (!row) return null;
+        return {
+          id: row.id,
+          providerId: row.provider_id,
+          billingDomainId: row.billing_domain_id ?? null,
+          model: row.model,
+          ratesPerMillion: {
+            input: row.input_rate,
+            output: row.output_rate,
+            cacheRead: row.cache_read_rate
+          },
+          updatedAt: row.updated_at
+        };
+      }
+      saveCustomModelRate(rate) {
+        const byId = this.#database.prepare("SELECT id FROM custom_model_rates WHERE id = ?").get(rate.id);
+        const byKey = this.#database.prepare(
+          `SELECT id FROM custom_model_rates
+         WHERE provider_id = ? AND COALESCE(billing_domain_id, '') = COALESCE(?, '') AND lower(model) = lower(?)`
+        ).get(rate.providerId, rate.billingDomainId, rate.model);
+        if (byId && byKey && byId.id !== byKey.id) {
+          this.#database.prepare("DELETE FROM custom_model_rates WHERE id = ?").run(byKey.id);
+        }
+        const existingId = byId?.id ?? byKey?.id;
+        if (existingId) {
+          this.#database.prepare(
+            `UPDATE custom_model_rates SET
+             provider_id = ?, billing_domain_id = ?, model = ?,
+             input_rate = ?, output_rate = ?, cache_read_rate = ?, updated_at = ?
+           WHERE id = ?`
+          ).run(
+            rate.providerId,
+            rate.billingDomainId,
+            rate.model,
+            rate.ratesPerMillion.input,
+            rate.ratesPerMillion.output,
+            rate.ratesPerMillion.cacheRead,
+            rate.updatedAt,
+            existingId
+          );
+        } else {
+          this.#database.prepare(
+            `INSERT INTO custom_model_rates (
+             id, provider_id, billing_domain_id, model,
+             input_rate, output_rate, cache_read_rate, updated_at
+           ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+          ).run(
+            rate.id,
+            rate.providerId,
+            rate.billingDomainId,
+            rate.model,
+            rate.ratesPerMillion.input,
+            rate.ratesPerMillion.output,
+            rate.ratesPerMillion.cacheRead,
+            rate.updatedAt
+          );
+        }
+      }
+      deleteCustomModelRate(id) {
+        const result = this.#database.prepare("DELETE FROM custom_model_rates WHERE id = ?").run(id);
+        return result.changes > 0;
+      }
       getNotificationState(key) {
         const row = this.#database.prepare("SELECT value FROM notification_state WHERE key = ?").get(key);
         return row?.value ?? null;
@@ -8976,7 +10170,7 @@ var init_sqlite_usage_repository = __esm({
          FROM billing_domains WHERE provider_id = ? ORDER BY id`
         ).all(provider.id);
         const summaryBillingDomainId = selectSummaryBillingDomainId(provider.id, domainRows);
-        const billingDomains2 = domainRows.map(
+        const billingDomains3 = domainRows.map(
           (domain) => this.#getBillingDomainOverview(
             provider.id,
             domain,
@@ -8988,7 +10182,7 @@ var init_sqlite_usage_repository = __esm({
             domainRows.length === 1 ? provider : null
           )
         );
-        const summaryDomain = billingDomains2.find((domain) => domain.id === summaryBillingDomainId);
+        const summaryDomain = billingDomains3.find((domain) => domain.id === summaryBillingDomainId);
         const emptyTotals = zeroTokenTotals();
         const emptyEvidence = finishTokenEvidence(emptyTokenEvidence());
         const emptyCoverage = {
@@ -9003,6 +10197,23 @@ var init_sqlite_usage_repository = __esm({
           message: provider.last_error,
           recovery: provider.last_recovery
         } : { status: "healthy", errorCode: null, message: null, recovery: null };
+        let providerTokenTotals = summaryDomain?.tokenTotals ?? emptyTotals;
+        let providerTokenEvidence = summaryDomain?.tokenEvidence ?? emptyEvidence;
+        if (provider.id === "dsh" && billingDomains3.length > 1) {
+          const combinedTotals = zeroTokenTotals();
+          const combinedEvidence = emptyTokenEvidence();
+          for (const d of billingDomains3) {
+            combinedTotals.total += d.tokenTotals.total;
+            combinedTotals.input += d.tokenTotals.input;
+            combinedTotals.output += d.tokenTotals.output;
+            combinedTotals.reasoning += d.tokenTotals.reasoning;
+            combinedTotals.cacheRead += d.tokenTotals.cacheRead;
+            combinedTotals.cacheWrite += d.tokenTotals.cacheWrite;
+            addAggregatedTokenEvidence(combinedEvidence, d.tokenEvidence);
+          }
+          providerTokenTotals = combinedTotals;
+          providerTokenEvidence = finishTokenEvidence(combinedEvidence);
+        }
         return {
           id: provider.id,
           displayName: provider.display_name,
@@ -9014,10 +10225,10 @@ var init_sqlite_usage_repository = __esm({
           health: summaryDomain?.health ?? providerFallbackHealth,
           coverage: summaryDomain?.coverage ?? emptyCoverage,
           quotaBuckets: summaryDomain?.quotaBuckets ?? [],
-          tokenTotals: summaryDomain?.tokenTotals ?? emptyTotals,
-          tokenEvidence: summaryDomain?.tokenEvidence ?? emptyEvidence,
+          tokenTotals: providerTokenTotals,
+          tokenEvidence: providerTokenEvidence,
           tokenAuthority: summaryDomain?.tokenAuthority ?? null,
-          billingDomains: billingDomains2,
+          billingDomains: billingDomains3,
           forecasts: summaryDomain?.forecasts ?? [],
           forecastCoverage: summaryDomain?.forecastCoverage ?? "insufficient"
         };
@@ -9049,7 +10260,7 @@ var init_sqlite_usage_repository = __esm({
          FROM usage_observations
          WHERE provider_id = ? AND billing_domain_id = ? AND ${additiveUsagePredicate()}`
         ).get(providerId, domain.id);
-        const costs = this.#database.prepare(
+        const costs = query.auditEvidence ? this.#database.prepare(
           `SELECT id, source_id, billing_domain_id, observed_at, kind, amount, currency, authority,
                 price_snapshot_id, price_snapshot_version, price_snapshot_source,
                 price_snapshot_canonical_model, price_snapshot_effective_at,
@@ -9058,7 +10269,11 @@ var init_sqlite_usage_repository = __esm({
                 price_snapshot_context_tier, model, usage_observation_id, priced_tokens,
                 line_items_json, calculated_at
          FROM cost_records WHERE provider_id = ? AND billing_domain_id = ? ORDER BY observed_at DESC, id`
-        ).all(providerId, domain.id);
+        ).all(providerId, domain.id) : null;
+        const lastCostObservedAt = this.#database.prepare(
+          `SELECT MAX(observed_at) AS observed_at FROM cost_records
+             WHERE provider_id = ? AND billing_domain_id = ?`
+        ).get(providerId, domain.id).observed_at ?? null;
         const balances = this.#database.prepare(
           `SELECT id, source_id, billing_domain_id, observed_at, kind, amount, currency, authority
          FROM balance_records WHERE provider_id = ? AND billing_domain_id = ? ORDER BY observed_at DESC, id`
@@ -9067,7 +10282,12 @@ var init_sqlite_usage_repository = __esm({
           `SELECT id, billing_domain_id, created_at, number, status, amount, currency, authority
          FROM invoice_records WHERE provider_id = ? AND billing_domain_id = ? ORDER BY created_at DESC, id`
         ).all(providerId, domain.id);
-        const actualCostCount = costs.filter((cost) => cost.kind === "actual").length;
+        const actualCostCount = Number(
+          this.#database.prepare(
+            `SELECT COUNT(*) AS count FROM cost_records
+             WHERE provider_id = ? AND billing_domain_id = ? AND kind = 'actual'`
+          ).get(providerId, domain.id).count
+        );
         const nonAdditiveTokenCount = this.#database.prepare(
           `SELECT COUNT(*) AS count FROM usage_observations
          WHERE provider_id = ? AND billing_domain_id = ?
@@ -9097,22 +10317,25 @@ var init_sqlite_usage_repository = __esm({
           tokenTotals: mapTokenTotals(tokens),
           tokenEvidence: mapTokenEvidence(tokens),
           tokenAuthority: tokenAuthority(tokens.authorities),
-          costs: costs.map((row) => ({
-            id: row.id,
-            sourceId: row.source_id,
-            billingDomainId: row.billing_domain_id,
-            observedAt: row.observed_at,
-            kind: row.kind,
-            amount: row.amount,
-            currency: row.currency,
-            authority: row.authority,
-            priceSnapshot: priceSnapshotFromRow(row),
-            model: row.model,
-            usageObservationId: row.usage_observation_id,
-            pricedTokens: row.priced_tokens,
-            lineItems: parseLineItems(row.line_items_json),
-            calculatedAt: row.calculated_at
-          })),
+          ...costs ? {
+            costs: costs.map((row) => ({
+              id: row.id,
+              sourceId: row.source_id,
+              billingDomainId: row.billing_domain_id,
+              observedAt: row.observed_at,
+              kind: row.kind,
+              amount: row.amount,
+              currency: row.currency,
+              authority: row.authority,
+              priceSnapshot: priceSnapshotFromRow(row),
+              model: row.model,
+              usageObservationId: row.usage_observation_id,
+              pricedTokens: row.priced_tokens,
+              lineItems: parseLineItems(row.line_items_json),
+              calculatedAt: row.calculated_at
+            }))
+          } : {},
+          lastCostObservedAt,
           balances: balances.map((row) => ({
             id: row.id,
             sourceId: row.source_id,
@@ -9733,6 +10956,18 @@ var init_sqlite_usage_repository = __esm({
         updated_at TEXT NOT NULL,
         PRIMARY KEY (provider_id, billing_domain_id)
       );
+      CREATE TABLE IF NOT EXISTS custom_model_rates (
+        id TEXT PRIMARY KEY,
+        provider_id TEXT NOT NULL,
+        billing_domain_id TEXT,
+        model TEXT NOT NULL,
+        input_rate REAL NOT NULL,
+        output_rate REAL NOT NULL,
+        cache_read_rate REAL NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_custom_model_rates_key
+        ON custom_model_rates(provider_id, COALESCE(billing_domain_id, ''), lower(model));
     `);
         const usageColumns = this.#database.prepare("PRAGMA table_info(usage_observations)").all();
         if (!usageColumns.some((column) => column.name === "total_tokens")) {
@@ -9890,9 +11125,9 @@ var init_sqlite_usage_repository = __esm({
     `);
         const quotaColumns = this.#database.prepare("PRAGMA table_info(quota_buckets)").all();
         for (const [name, type] of [
+          ["window_duration_minutes", "INTEGER"],
           ["scope", "TEXT"],
           ["status", "TEXT"],
-          ["window_duration_minutes", "INTEGER"],
           ["limit_amount", "REAL"],
           ["limit_currency", "TEXT"],
           ["fallback_status", "TEXT"]
@@ -9916,14 +11151,14 @@ __export(runtime_exports, {
   runDaemon: () => runDaemon
 });
 import { existsSync as existsSync2 } from "fs";
-import { mkdir as mkdir4, rm as rm2 } from "fs/promises";
-import { homedir as homedir3 } from "os";
-import { isAbsolute as isAbsolute3, join as join8, resolve as resolve3 } from "path";
+import { mkdir as mkdir5, rm as rm2 } from "fs/promises";
+import { homedir as homedir4 } from "os";
+import { isAbsolute as isAbsolute3, join as join10, resolve as resolve3 } from "path";
 import { fileURLToPath } from "url";
 async function runDaemon(home) {
-  await mkdir4(home, { recursive: true, mode: 448 });
+  await mkdir5(home, { recursive: true, mode: 448 });
   const demoEnabled = process.env.AGENT_USAGE_DEMO === "1";
-  const repository = new SqliteUsageRepository(join8(home, "usage.sqlite"), {
+  const repository = new SqliteUsageRepository(join10(home, "usage.sqlite"), {
     hideDemoProvider: !demoEnabled
   });
   const keychainService = process.env.AGENT_USAGE_KEYCHAIN_SERVICE;
@@ -9958,7 +11193,16 @@ async function runDaemon(home) {
         historyClient: localTranscriptClient("grok", home)
       }),
       new XaiApiConnector({ accountClient: new XaiManagementApiClient({ secretStore }) }),
-      new DshConnector({ historyClient: localTranscriptClient("dsh", home) })
+      new DshConnector({ historyClient: localTranscriptClient("dsh", home) }),
+      new AntigravityConnector({
+        historyClient: new AntigravitySqliteUsageClient({
+          roots: [
+            join10(homedir4(), ".gemini/antigravity-cli"),
+            join10(homedir4(), ".gemini/antigravity")
+          ],
+          cachePath: join10(home, "antigravity-usage-cache.json")
+        })
+      })
     ],
     connectorDefinitions: defaultConnectorDefinitions,
     discoveryProbe: new PathDiscoveryProbe(),
@@ -9966,7 +11210,7 @@ async function runDaemon(home) {
     exchangeRateProvider: new EcbExchangeRateProvider(),
     notifier: new MacOsNotifier(),
     startAtLoginManager: new MacOsStartAtLoginManager({
-      userHome: homedir3(),
+      userHome: homedir4(),
       executable: process.execPath,
       cliPath: process.argv[1],
       applicationHome: home,
@@ -9981,7 +11225,16 @@ async function runDaemon(home) {
       }
     }),
     connectorPolicies: Object.fromEntries(
-      ["codex", "claude-code", "opencode-go", "opencode", "grok", "xai-api", "dsh"].map((id) => [
+      [
+        "codex",
+        "claude-code",
+        "opencode-go",
+        "opencode",
+        "grok",
+        "xai-api",
+        "dsh",
+        "antigravity"
+      ].map((id) => [
         id,
         { minimumIntervalMs: 5 * 60 * 1e3, timeoutMs: id === "claude-code" ? 25e3 : 2e4 }
       ])
@@ -10032,7 +11285,7 @@ async function runDaemon(home) {
       scheduler.stop();
       await server.close();
       repository.close();
-      await rm2(join8(home, "daemon.json"), { force: true });
+      await rm2(join10(home, "daemon.json"), { force: true });
       resolveStop();
     };
     process.once("SIGTERM", () => void stop());
@@ -10043,27 +11296,27 @@ function localTranscriptClient(provider, applicationHome) {
   return new LocalTranscriptUsageClient({
     provider,
     roots: localTranscriptRoots(provider),
-    cachePath: join8(applicationHome, "cache", `${provider}-transcripts.json`)
+    cachePath: join10(applicationHome, "cache", `${provider}-transcripts.json`)
   });
 }
 function localTranscriptRoots(provider) {
   if (provider === "codex") {
     const home = resolveHomeOverride(process.env.CODEX_HOME, ".codex");
-    return [join8(home, "sessions"), join8(home, "archived_sessions")];
+    return [join10(home, "sessions"), join10(home, "archived_sessions")];
   }
   if (provider === "claude-code") {
-    return [join8(resolveHomeOverride(process.env.CLAUDE_CONFIG_DIR, ".claude"), "projects")];
+    return [join10(resolveHomeOverride(process.env.CLAUDE_CONFIG_DIR, ".claude"), "projects")];
   }
   if (provider === "dsh") {
-    return [join8(resolveHomeOverride(process.env.DSH_HOME, ".dsh"), "sessions")];
+    return [join10(resolveHomeOverride(process.env.DSH_HOME, ".dsh"), "sessions")];
   }
-  return [join8(resolveHomeOverride(process.env.GROK_HOME, ".grok"), "sessions")];
+  return [join10(resolveHomeOverride(process.env.GROK_HOME, ".grok"), "sessions")];
 }
 function resolveHomeOverride(value, fallback) {
   const configured = value?.trim();
-  if (!configured) return join8(homedir3(), fallback);
-  if (configured === "~") return homedir3();
-  if (configured.startsWith("~/")) return join8(homedir3(), configured.slice(2));
+  if (!configured) return join10(homedir4(), fallback);
+  if (configured === "~") return homedir4();
+  if (configured.startsWith("~/")) return join10(homedir4(), configured.slice(2));
   return isAbsolute3(configured) ? configured : resolve3(configured);
 }
 function createDemoConnector() {
@@ -10109,7 +11362,7 @@ function locateStaticDirectory() {
     fileURLToPath(new URL("./web", import.meta.url)),
     fileURLToPath(new URL("../../dist/web", import.meta.url))
   ];
-  return candidates.find((candidate) => existsSync2(join8(candidate, "index.html")));
+  return candidates.find((candidate) => existsSync2(join10(candidate, "index.html")));
 }
 var init_runtime = __esm({
   "src/server/runtime.ts"() {
@@ -10127,6 +11380,8 @@ var init_runtime = __esm({
     init_opencode_auth_reader();
     init_opencode_go_connector();
     init_dsh_connector();
+    init_antigravity_connector();
+    init_antigravity_sqlite_usage_client();
     init_grok_build_connector();
     init_grok_telemetry();
     init_stdio_grok_billing_client();
@@ -10149,8 +11404,8 @@ init_redaction();
 init_daemon_state();
 import { spawn as spawn6 } from "child_process";
 import { connect as tcpConnect } from "net";
-import { homedir as homedir4 } from "os";
-import { join as join9, resolve as resolve4 } from "path";
+import { homedir as homedir5 } from "os";
+import { join as join11, resolve as resolve4 } from "path";
 import { Command } from "commander";
 import open2 from "open";
 var program = new Command();
@@ -10332,6 +11587,97 @@ program.command("start-at-login <action>").description("enable, disable, or show
   process.stdout.write(`${status.settings.startAtLogin ? "enabled" : "disabled"}
 `);
 });
+var ratesCommand = program.command("rates").description("view and manage custom model rates for custom endpoints");
+ratesCommand.command("list").description("list configured custom model rates").option("--json", "emit machine-readable JSON").action(async (options) => {
+  const home = resolve4(program.opts().home);
+  const state = await requireDaemonState(home);
+  const response = await fetch(`${state.origin}/api/custom-rates`, {
+    headers: { authorization: `Bearer ${state.apiToken}` }
+  });
+  if (!response.ok) throw new Error(`Daemon returned HTTP ${response.status}`);
+  const data = await response.json();
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify(data.rates, null, 2)}
+`);
+    return;
+  }
+  if (data.rates.length === 0) {
+    process.stdout.write("No custom model rates configured.\n");
+    return;
+  }
+  for (const rate of data.rates) {
+    const domain = rate.billingDomainId ?? "*";
+    process.stdout.write(
+      `${rate.id} | ${rate.providerId} | domain: ${domain} | model: ${rate.model} | in: $${rate.ratesPerMillion.input}/M | out: $${rate.ratesPerMillion.output}/M | cache: $${rate.ratesPerMillion.cacheRead}/M
+`
+    );
+  }
+});
+ratesCommand.command("set <model>").description("set custom model rate").requiredOption("--provider <provider>", "provider id (e.g. dsh)").option("--domain <domain>", "billing domain id (omit for wildcard across all routes)").requiredOption("--input <rate>", "input rate in USD per million tokens", parseFloat).requiredOption("--output <rate>", "output rate in USD per million tokens", parseFloat).option("--cache-read <rate>", "cache read rate in USD per million tokens", parseFloat, 0).option("--id <id>", "custom model rate ID to update").action(
+  async (model, options) => {
+    const home = resolve4(program.opts().home);
+    const state = await requireDaemonState(home);
+    const response = await fetch(`${state.origin}/api/custom-rates`, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${state.apiToken}`,
+        "content-type": "application/json",
+        origin: state.origin
+      },
+      body: JSON.stringify({
+        ...options.id ? { id: options.id } : {},
+        providerId: options.provider,
+        billingDomainId: options.domain || null,
+        model,
+        inputRate: options.input,
+        outputRate: options.output,
+        cacheReadRate: options.cacheRead
+      })
+    });
+    if (!response.ok) throw new Error(`Daemon returned HTTP ${response.status}`);
+    const data = await response.json();
+    process.stdout.write(
+      `Custom model rate configured for ${data.rate.model} (ID: ${data.rate.id})
+`
+    );
+  }
+);
+ratesCommand.command("get <id>").description("get details of a custom model rate by ID").option("--json", "emit machine-readable JSON").action(async (id, options) => {
+  const home = resolve4(program.opts().home);
+  const state = await requireDaemonState(home);
+  const response = await fetch(`${state.origin}/api/custom-rates/${encodeURIComponent(id)}`, {
+    headers: { authorization: `Bearer ${state.apiToken}` }
+  });
+  if (!response.ok) {
+    if (response.status === 404) throw new Error(`Custom model rate not found: ${id}`);
+    throw new Error(`Daemon returned HTTP ${response.status}`);
+  }
+  const data = await response.json();
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify(data.rate, null, 2)}
+`);
+    return;
+  }
+  const domain = data.rate.billingDomainId ?? "*";
+  process.stdout.write(
+    `${data.rate.id} | ${data.rate.providerId} | domain: ${domain} | model: ${data.rate.model} | in: $${data.rate.ratesPerMillion.input}/M | out: $${data.rate.ratesPerMillion.output}/M | cache: $${data.rate.ratesPerMillion.cacheRead}/M | updated: ${data.rate.updatedAt}
+`
+  );
+});
+ratesCommand.command("delete <id>").description("delete custom model rate by ID").action(async (id) => {
+  const home = resolve4(program.opts().home);
+  const state = await requireDaemonState(home);
+  const response = await fetch(`${state.origin}/api/custom-rates/${encodeURIComponent(id)}`, {
+    method: "DELETE",
+    headers: {
+      authorization: `Bearer ${state.apiToken}`,
+      origin: state.origin
+    }
+  });
+  if (!response.ok) throw new Error(`Daemon returned HTTP ${response.status}`);
+  process.stdout.write(`Deleted custom model rate ${id}
+`);
+});
 program.command("serve").description("run the internal local daemon").action(async () => {
   const home = resolve4(program.opts().home);
   const { runDaemon: runDaemon2 } = await Promise.resolve().then(() => (init_runtime(), runtime_exports));
@@ -10515,6 +11861,6 @@ function formatDoctor(report) {
   ].join("\n");
 }
 function defaultHome() {
-  return join9(homedir4(), "Library", "Application Support", "Agent Usage");
+  return join11(homedir5(), "Library", "Application Support", "Agent Usage");
 }
 //# sourceMappingURL=cli.js.map