agent-usage-all-in-one 0.3.0 → 0.4.0

package/dist/cli.js

@@ -749,16 +749,15 @@ function priceObservation(providerId, observation, catalog, calculatedAt) {
       ratePerMillion: entry.cacheWriteRatesPerMillion.oneHour
     }
   ].filter((item) => item.tokens > 0) : null;
-  if (cacheWriteTokens > 0 && entry.ratesPerMillion["cache-write"] === null && !exactCacheWriteItems) {
-    return unavailable("pricing-tier-ambiguous");
-  }
-  if (cacheWriteTokens > 0 && !exactCacheWriteItems) {
+  const cacheWriteFree = cacheWriteTokens > 0 && !exactCacheWriteItems && entry.ratesPerMillion["cache-write"] === null && !entry.cacheWriteRatesPerMillion;
+  const cacheWriteBillable = cacheWriteTokens > 0 && !exactCacheWriteItems && !cacheWriteFree;
+  if (cacheWriteBillable) {
     billableTokens.push({ tokenKind: "cache-write", tokens: cacheWriteTokens });
   }
   const nonZero = billableTokens.filter((item) => item.tokens > 0);
   if (nonZero.some((item) => entry.ratesPerMillion[item.tokenKind] === null)) {
     return unavailable(
-      normalized.cacheWriteTokens > 0 ? "pricing-tier-ambiguous" : "token-kinds-incomplete"
+      normalized.cacheWriteTokens > 0 && !cacheWriteFree ? "pricing-tier-ambiguous" : "token-kinds-incomplete"
     );
   }
   const lineItems = nonZero.map((item) => {
@@ -777,6 +776,14 @@ function priceObservation(providerId, observation, catalog, calculatedAt) {
       }))
     );
   }
+  if (cacheWriteFree) {
+    lineItems.push({
+      tokenKind: "cache-write",
+      tokens: cacheWriteTokens,
+      ratePerMillion: 0,
+      amount: 0
+    });
+  }
   const pricedTokens = lineItems.reduce((total, item) => total + item.tokens, 0);
   if (pricedTokens !== normalized.recordedTokens) return unavailable("token-kinds-incomplete");
   const amount = preciseMoney(lineItems.reduce((total, item) => total + item.amount, 0));
@@ -1184,6 +1191,382 @@ var init_retail_pricing = __esm({
   }
 });
 
+// src/core/plan-pricing.ts
+function buildBillingPeriod(subscription, summary, comparisonCurrency, rates) {
+  if (!summary) return null;
+  const start = new Date(summary.start).getTime();
+  const end = new Date(summary.end).getTime();
+  const observedThrough = new Date(summary.observedThrough).getTime();
+  const totalDays = (end - start) / MILLISECONDS_PER_DAY;
+  const elapsedDays = Math.max(0, Math.min(observedThrough, end) - start) / MILLISECONDS_PER_DAY;
+  const periodCost = planMoneyAmount(
+    preciseAmount(subscription.amount),
+    subscription.currency,
+    comparisonCurrency,
+    // The period's own rate evidence first, so a short rolling window cannot
+    // leave a cycle amount unconverted.
+    [...summary.retailEquivalent.exchangeRates, ...rates],
+    summary.observedThrough
+  );
+  const retailAmount = summary.retailEquivalent.status === "available" ? summary.retailEquivalent.amount : null;
+  const breakEvenRatio = periodCost.amount !== null && periodCost.amount > 0 && retailAmount !== null ? preciseAmount(retailAmount / periodCost.amount) : null;
+  return {
+    start: summary.start,
+    end: summary.end,
+    elapsedDays: preciseAmount(elapsedDays),
+    totalDays: preciseAmount(totalDays),
+    progress: totalDays > 0 ? preciseAmount(Math.min(1, elapsedDays / totalDays)) : 0,
+    periodCost,
+    recordedTokens: summary.observationCount > 0 ? summary.recordedTokens : null,
+    retailEquivalent: summary.retailEquivalent,
+    breakEvenRatio,
+    ratioBound: ratioBoundFor(breakEvenRatio, summary.retailEquivalent.pricingCoverage)
+  };
+}
+function planCatalogEntry(catalog, id) {
+  return catalog.entries.find((entry) => entry.id === id) ?? null;
+}
+function planCatalogEntriesForDomain(catalog, providerId, billingDomainId) {
+  return catalog.entries.filter(
+    (entry) => entry.providerId === providerId && entry.billingDomainId === billingDomainId
+  );
+}
+function addMonths(date, months) {
+  const day = date.getUTCDate();
+  const shifted = new Date(
+    Date.UTC(
+      date.getUTCFullYear(),
+      date.getUTCMonth() + months,
+      1,
+      date.getUTCHours(),
+      date.getUTCMinutes(),
+      date.getUTCSeconds(),
+      date.getUTCMilliseconds()
+    )
+  );
+  const lastDayOfMonth = new Date(
+    Date.UTC(shifted.getUTCFullYear(), shifted.getUTCMonth() + 1, 0)
+  ).getUTCDate();
+  shifted.setUTCDate(Math.min(day, lastDayOfMonth));
+  return shifted;
+}
+function billingPeriodContaining(anchorDate, billingPeriod, at) {
+  const anchor = new Date(anchorDate.length === 10 ? `${anchorDate}T00:00:00.000Z` : anchorDate);
+  if (Number.isNaN(anchor.getTime())) return null;
+  const step = billingPeriod === "monthly" ? 1 : 12;
+  const monthsApart = (at.getUTCFullYear() - anchor.getUTCFullYear()) * 12 + (at.getUTCMonth() - anchor.getUTCMonth());
+  let index = Math.floor(monthsApart / step);
+  let start = addMonths(anchor, index * step);
+  while (start.getTime() > at.getTime()) {
+    index -= 1;
+    start = addMonths(anchor, index * step);
+  }
+  let end = addMonths(anchor, (index + 1) * step);
+  while (end.getTime() <= at.getTime()) {
+    index += 1;
+    start = end;
+    end = addMonths(anchor, (index + 1) * step);
+  }
+  return { start, end };
+}
+function windowDays(start, end) {
+  const span = new Date(end).getTime() - new Date(start).getTime();
+  return span > 0 ? span / MILLISECONDS_PER_DAY : 0;
+}
+function proratePlanPrice(amount, billingPeriod, days) {
+  return amount * days / PLAN_PERIOD_DAYS[billingPeriod];
+}
+function convertPlanAmount(amount, currency, comparisonCurrency, rates, end) {
+  if (currency.toUpperCase() === comparisonCurrency.toUpperCase()) {
+    return { amount, reason: null, rate: null };
+  }
+  const rate = rates.find(
+    (candidate) => candidate.baseCurrency.toUpperCase() === currency.toUpperCase() && candidate.quoteCurrency.toUpperCase() === comparisonCurrency.toUpperCase()
+  );
+  if (!rate) return { amount: null, reason: "missing-rate", rate: null };
+  if (new Date(end).getTime() - new Date(rate.observedAt).getTime() > STALE_RATE_MILLISECONDS) {
+    return { amount: null, reason: "stale-rate", rate };
+  }
+  return { amount: amount * rate.rate, reason: null, rate };
+}
+function preciseAmount(value) {
+  return Number(value.toPrecision(12));
+}
+function planMoneyAmount(nativeAmount, nativeCurrency, comparisonCurrency, rates, end) {
+  const converted = convertPlanAmount(nativeAmount, nativeCurrency, comparisonCurrency, rates, end);
+  return {
+    status: converted.amount === null ? "unavailable" : "available",
+    amount: converted.amount === null ? null : preciseAmount(converted.amount),
+    nativeAmount,
+    nativeCurrency,
+    comparisonCurrency,
+    conversionUnavailableReason: converted.reason,
+    exchangeRates: converted.rate ? [converted.rate] : []
+  };
+}
+function ratioBoundFor(ratio, pricingCoverage) {
+  if (ratio === null) return "unavailable";
+  return pricingCoverage !== null && pricingCoverage < 0.999 ? "lower" : "exact";
+}
+function unitPricePerMillion(amount, tokens) {
+  if (amount === null || tokens <= 0) return null;
+  return preciseAmount(amount / (tokens / 1e6));
+}
+function buildWorkbenchPlanValue(options) {
+  const { comparisonCurrency, start, end, rates } = options;
+  const days = windowDays(start, end);
+  const subscriptionByDomain = new Map(
+    options.subscriptions.map((subscription) => [
+      `${subscription.providerId}:${subscription.billingDomainId}`,
+      subscription
+    ])
+  );
+  const entries = [];
+  const metered = [];
+  const unconfigured = [];
+  for (const domain of options.domains) {
+    const subscription = subscriptionByDomain.get(`${domain.providerId}:${domain.billingDomainId}`);
+    if (!subscription) {
+      if (domain.actualCost.records > 0) {
+        metered.push({
+          providerId: domain.providerId,
+          providerDisplayName: domain.providerDisplayName,
+          billingDomainId: domain.billingDomainId,
+          billingDomainDisplayName: domain.billingDomainDisplayName,
+          recordedTokens: domain.observationCount > 0 ? domain.recordedTokens : null,
+          actualCost: domain.actualCost,
+          retailEquivalent: domain.retailEquivalent
+        });
+        continue;
+      }
+      if (domain.observationCount > 0) {
+        unconfigured.push({
+          providerId: domain.providerId,
+          providerDisplayName: domain.providerDisplayName,
+          billingDomainId: domain.billingDomainId,
+          billingDomainDisplayName: domain.billingDomainDisplayName,
+          recordedTokens: domain.recordedTokens
+        });
+      }
+      continue;
+    }
+    const windowPlanCost = planMoneyAmount(
+      preciseAmount(proratePlanPrice(subscription.amount, subscription.billingPeriod, days)),
+      subscription.currency,
+      comparisonCurrency,
+      rates,
+      end
+    );
+    const retail = domain.retailEquivalent;
+    const retailAmount = retail.status === "available" ? retail.amount : null;
+    const valueRatio = windowPlanCost.amount !== null && windowPlanCost.amount > 0 && retailAmount !== null ? preciseAmount(retailAmount / windowPlanCost.amount) : null;
+    const ratioBound = ratioBoundFor(valueRatio, retail.pricingCoverage);
+    const billingPeriod = buildBillingPeriod(
+      subscription,
+      options.billingPeriods?.get(`${domain.providerId}:${domain.billingDomainId}`),
+      comparisonCurrency,
+      rates
+    );
+    entries.push({
+      providerId: domain.providerId,
+      providerDisplayName: domain.providerDisplayName,
+      billingDomainId: domain.billingDomainId,
+      billingDomainDisplayName: domain.billingDomainDisplayName,
+      includedInHeadline: domain.includedInHeadline,
+      plan: {
+        planId: subscription.planId,
+        displayName: subscription.displayName,
+        amount: subscription.amount,
+        currency: subscription.currency,
+        billingPeriod: subscription.billingPeriod,
+        anchorDate: subscription.anchorDate,
+        priceSource: subscription.priceSource,
+        updatedAt: subscription.updatedAt
+      },
+      windowDays: preciseAmount(days),
+      windowPlanCost,
+      billingPeriod,
+      recordedTokens: domain.observationCount > 0 ? domain.recordedTokens : null,
+      retailEquivalent: retail,
+      valueRatio,
+      ratioBound,
+      status: valueRatio === null ? "unavailable" : ratioBound === "lower" ? "partial" : "available",
+      effectiveUnitPrice: unitPricePerMillion(windowPlanCost.amount, domain.recordedTokens),
+      retailUnitPrice: unitPricePerMillion(retailAmount, retail.pricedTokens),
+      pricingCoverage: retail.pricingCoverage,
+      authorities: domain.authorities,
+      lastObservedAt: domain.lastObservedAt
+    });
+  }
+  const rank = (entry) => entry.valueRatio ?? -1;
+  entries.sort(
+    (left, right) => rank(right) - rank(left) || `${left.providerId}:${left.billingDomainId}`.localeCompare(
+      `${right.providerId}:${right.billingDomainId}`
+    )
+  );
+  metered.sort(
+    (left, right) => `${left.providerId}:${left.billingDomainId}`.localeCompare(
+      `${right.providerId}:${right.billingDomainId}`
+    )
+  );
+  unconfigured.sort(
+    (left, right) => right.recordedTokens - left.recordedTokens || `${left.providerId}:${left.billingDomainId}`.localeCompare(
+      `${right.providerId}:${right.billingDomainId}`
+    )
+  );
+  return {
+    windowDays: preciseAmount(days),
+    comparisonCurrency,
+    catalogVersion: SUBSCRIPTION_PLAN_CATALOG.version,
+    entries,
+    meteredDomains: metered,
+    unconfiguredDomains: unconfigured
+  };
+}
+var PLAN_PERIOD_DAYS, MILLISECONDS_PER_DAY, STALE_RATE_MILLISECONDS, SUBSCRIPTION_PLAN_CATALOG;
+var init_plan_pricing = __esm({
+  "src/core/plan-pricing.ts"() {
+    "use strict";
+    PLAN_PERIOD_DAYS = {
+      monthly: 365.25 / 12,
+      annual: 365.25
+    };
+    MILLISECONDS_PER_DAY = 24 * 60 * 60 * 1e3;
+    STALE_RATE_MILLISECONDS = 7 * MILLISECONDS_PER_DAY;
+    SUBSCRIPTION_PLAN_CATALOG = {
+      version: "2026-08-30",
+      entries: [
+        {
+          id: "claude-pro-monthly",
+          providerId: "claude-code",
+          billingDomainId: "subscription",
+          displayName: "Claude Pro",
+          amount: 20,
+          currency: "USD",
+          billingPeriod: "monthly",
+          source: {
+            title: "Claude plans and pricing",
+            url: "https://claude.com/pricing",
+            retrievedAt: "2026-08-30"
+          }
+        },
+        {
+          id: "claude-pro-annual",
+          providerId: "claude-code",
+          billingDomainId: "subscription",
+          displayName: "Claude Pro (annual billing)",
+          amount: 17 * 12,
+          currency: "USD",
+          billingPeriod: "annual",
+          source: {
+            title: "Claude plans and pricing",
+            url: "https://claude.com/pricing",
+            retrievedAt: "2026-08-30"
+          }
+        },
+        {
+          id: "claude-max-5x",
+          providerId: "claude-code",
+          billingDomainId: "subscription",
+          displayName: "Claude Max 5x",
+          amount: 100,
+          currency: "USD",
+          billingPeriod: "monthly",
+          source: {
+            title: "What is the Max plan?",
+            url: "https://support.claude.com/en/articles/11049741-what-is-the-max-plan",
+            retrievedAt: "2026-08-30"
+          }
+        },
+        {
+          id: "claude-max-20x",
+          providerId: "claude-code",
+          billingDomainId: "subscription",
+          displayName: "Claude Max 20x",
+          amount: 200,
+          currency: "USD",
+          billingPeriod: "monthly",
+          source: {
+            title: "What is the Max plan?",
+            url: "https://support.claude.com/en/articles/11049741-what-is-the-max-plan",
+            retrievedAt: "2026-08-30"
+          }
+        },
+        {
+          id: "chatgpt-plus",
+          providerId: "codex",
+          billingDomainId: "subscription",
+          displayName: "ChatGPT Plus",
+          amount: 20,
+          currency: "USD",
+          billingPeriod: "monthly",
+          source: {
+            title: "ChatGPT pricing",
+            url: "https://chatgpt.com/pricing/",
+            retrievedAt: "2026-08-30"
+          }
+        },
+        {
+          id: "chatgpt-pro-100",
+          providerId: "codex",
+          billingDomainId: "subscription",
+          displayName: "ChatGPT Pro (5x)",
+          amount: 100,
+          currency: "USD",
+          billingPeriod: "monthly",
+          source: {
+            title: "About ChatGPT Pro tiers",
+            url: "https://help.openai.com/en/articles/9793128-about-chatgpt-pro-tiers",
+            retrievedAt: "2026-08-30"
+          }
+        },
+        {
+          id: "chatgpt-pro-200",
+          providerId: "codex",
+          billingDomainId: "subscription",
+          displayName: "ChatGPT Pro (20x)",
+          amount: 200,
+          currency: "USD",
+          billingPeriod: "monthly",
+          source: {
+            title: "About ChatGPT Pro tiers",
+            url: "https://help.openai.com/en/articles/9793128-about-chatgpt-pro-tiers",
+            retrievedAt: "2026-08-30"
+          }
+        },
+        {
+          id: "chatgpt-business-seat",
+          providerId: "codex",
+          billingDomainId: "subscription",
+          displayName: "ChatGPT Business (one seat)",
+          amount: 25,
+          currency: "USD",
+          billingPeriod: "monthly",
+          source: {
+            title: "ChatGPT Business pricing",
+            url: "https://openai.com/business/chatgpt-pricing/",
+            retrievedAt: "2026-08-30"
+          }
+        },
+        {
+          id: "opencode-go-monthly",
+          providerId: "opencode-go",
+          billingDomainId: "go-subscription",
+          displayName: "OpenCode Go",
+          amount: 10,
+          currency: "USD",
+          billingPeriod: "monthly",
+          source: {
+            title: "OpenCode Go",
+            url: "https://opencode.ai/go",
+            retrievedAt: "2026-08-30"
+          }
+        }
+      ]
+    };
+  }
+});
+
 // src/core/usage-application.ts
 function safeConnectorFailure(error) {
   if (error instanceof Error && "code" in error && typeof error.code === "string" && "recovery" in error && typeof error.recovery === "string") {
@@ -1289,6 +1672,12 @@ async function withTimeout(promise, timeoutMs, message) {
 function notificationLevel(value) {
   return value === "5" ? 2 : value === "20" ? 1 : 0;
 }
+function pickAgentProviderIndex(overview) {
+  return {
+    generatedAt: overview.generatedAt,
+    providers: overview.providers.filter((provider) => provider.id !== "opencode").map(({ id, displayName }) => ({ id, displayName }))
+  };
+}
 var UsageApplication;
 var init_usage_application = __esm({
   "src/core/usage-application.ts"() {
@@ -1297,6 +1686,7 @@ var init_usage_application = __esm({
     init_redaction();
     init_usage_export();
     init_retail_pricing();
+    init_plan_pricing();
     UsageApplication = class {
       #repository;
       #connectors;
@@ -1310,10 +1700,13 @@ var init_usage_application = __esm({
       #notifier;
       #startAtLoginManager;
       #priceCatalog;
+      #planCatalog;
       #refreshPromise = null;
       #refreshMode = null;
       #backgroundPromise = null;
       #queuedHardRebuildPromise = null;
+      #queuedUserProcessingPromise = null;
+      #userInitiatedProcessing = false;
       #databaseWriteQueue = Promise.resolve();
       #processingStatus;
       constructor(options) {
@@ -1329,6 +1722,7 @@ var init_usage_application = __esm({
         this.#notifier = options.notifier;
         this.#startAtLoginManager = options.startAtLoginManager;
         this.#priceCatalog = options.priceCatalog === void 0 ? OFFICIAL_PRICING_CATALOG : options.priceCatalog;
+        this.#planCatalog = options.planCatalog ?? SUBSCRIPTION_PLAN_CATALOG;
         this.#processingStatus = createProcessingStatus(this.#clock().toISOString(), false);
       }
       async #backfillRetailCosts(mode) {
@@ -1375,40 +1769,50 @@ var init_usage_application = __esm({
       getProcessingStatus() {
         return structuredClone(this.#processingStatus);
       }
-      startBackgroundProcessing() {
-        return this.#startProcessing("incremental");
+      startBackgroundProcessing(options = {}) {
+        return this.#startProcessing("incremental", options.userInitiated === true);
       }
       startHardRebuild() {
-        return this.#startProcessing("hard-rebuild");
+        return this.#startProcessing("hard-rebuild", true);
       }
-      #startProcessing(mode) {
+      #startProcessing(mode, userInitiated) {
         if (this.#backgroundPromise) {
           if (mode === "hard-rebuild" && !this.#processingStatus.hardRebuild) {
             this.#queuedHardRebuildPromise ??= this.#backgroundPromise.then(
-              () => this.#startProcessing("hard-rebuild"),
-              () => this.#startProcessing("hard-rebuild")
+              () => this.#startProcessing("hard-rebuild", true),
+              () => this.#startProcessing("hard-rebuild", true)
             ).finally(() => {
               this.#queuedHardRebuildPromise = null;
             });
             return this.#queuedHardRebuildPromise;
           }
+          if (userInitiated && !this.#userInitiatedProcessing) {
+            this.#queuedUserProcessingPromise ??= this.#backgroundPromise.then(
+              () => this.#startProcessing(mode, true),
+              () => this.#startProcessing(mode, true)
+            ).finally(() => {
+              this.#queuedUserProcessingPromise = null;
+            });
+            return this.#queuedUserProcessingPromise;
+          }
           return this.#backgroundPromise;
         }
+        this.#userInitiatedProcessing = userInitiated || mode === "hard-rebuild";
         this.#processingStatus = createProcessingStatus(
           this.#clock().toISOString(),
           mode === "hard-rebuild"
         );
-        this.#backgroundPromise = this.#runProcessing(mode).finally(() => {
-          this.#backgroundPromise = null;
-        });
+        this.#backgroundPromise = this.#runProcessing(mode, this.#userInitiatedProcessing).finally(
+          () => {
+            this.#backgroundPromise = null;
+            this.#userInitiatedProcessing = false;
+          }
+        );
         return this.#backgroundPromise;
       }
-      async #runProcessing(mode) {
+      async #runProcessing(mode, userInitiated) {
         await this.#runModule("discovery", () => this.discoverConnectors().then(() => void 0));
-        await this.#runModule(
-          "usage",
-          () => this.refresh({ userInitiated: mode === "hard-rebuild", mode })
-        );
+        await this.#runModule("usage", () => this.refresh({ userInitiated, mode }));
         await this.#runModule(
           "pricing",
           () => this.#queueDatabaseWrite(async () => {
@@ -1619,6 +2023,83 @@ var init_usage_application = __esm({
           connectors: this.#repository.getConnectorRuntimeStates()
         };
       }
+      async getPlanSettings() {
+        return {
+          catalogVersion: this.#planCatalog.version,
+          domains: this.#planEligibleDomains(),
+          subscriptions: this.#repository.getPlanSubscriptions()
+        };
+      }
+      async updatePlanSubscription(input) {
+        const domain = this.#planEligibleDomains().find(
+          (candidate) => candidate.providerId === input.providerId && candidate.billingDomainId === input.billingDomainId
+        );
+        if (!domain) throw new Error("Unknown subscription billing domain");
+        if (input.plan === null) {
+          this.#repository.deletePlanSubscription(input.providerId, input.billingDomainId);
+          return this.getPlanSettings();
+        }
+        const preset = input.plan.planId ? planCatalogEntry(this.#planCatalog, input.plan.planId) : null;
+        if (input.plan.planId && !preset) throw new Error("Unknown plan preset");
+        if (preset && (preset.providerId !== input.providerId || preset.billingDomainId !== input.billingDomainId)) {
+          throw new Error("Plan preset belongs to another billing domain");
+        }
+        const amount = input.plan.amount ?? preset?.amount;
+        if (amount === void 0) throw new Error("A plan price is required");
+        if (!Number.isFinite(amount) || amount <= 0) {
+          throw new Error("A plan price must be a positive amount");
+        }
+        const currency = (input.plan.currency ?? preset?.currency ?? "USD").toUpperCase();
+        if (!/^[A-Z]{3}$/.test(currency)) throw new Error("A plan currency must be a 3-letter code");
+        const billingPeriod = input.plan.billingPeriod ?? preset?.billingPeriod ?? "monthly";
+        const anchorDate = input.plan.anchorDate ?? null;
+        if (anchorDate !== null && Number.isNaN((/* @__PURE__ */ new Date(`${anchorDate}T00:00:00.000Z`)).getTime())) {
+          throw new Error("A renewal date must be a calendar date");
+        }
+        const overridesPreset = preset !== null && (amount !== preset.amount || currency !== preset.currency.toUpperCase() || billingPeriod !== preset.billingPeriod);
+        this.#repository.savePlanSubscription({
+          providerId: input.providerId,
+          billingDomainId: input.billingDomainId,
+          planId: preset?.id ?? null,
+          displayName: preset?.displayName ?? "",
+          amount,
+          currency,
+          billingPeriod,
+          anchorDate,
+          priceSource: preset && !overridesPreset ? "catalog-preset" : "user-entered",
+          updatedAt: this.#clock().toISOString()
+        });
+        return this.getPlanSettings();
+      }
+      /**
+       * 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
+       * never receive a declared subscription price.
+       */
+      #planEligibleDomains() {
+        const domains = /* @__PURE__ */ new Map();
+        for (const definition of this.#connectorDefinitions) {
+          if (definition.expectedCoverage?.includes("actual-cost")) continue;
+          const key = `${definition.target.provider.id}:${definition.target.billingDomain.id}`;
+          if (domains.has(key)) continue;
+          domains.set(key, {
+            providerId: definition.target.provider.id,
+            providerDisplayName: definition.target.provider.displayName,
+            billingDomainId: definition.target.billingDomain.id,
+            billingDomainDisplayName: definition.target.billingDomain.displayName,
+            presets: planCatalogEntriesForDomain(
+              this.#planCatalog,
+              definition.target.provider.id,
+              definition.target.billingDomain.id
+            )
+          });
+        }
+        return [...domains.values()].sort(
+          (left, right) => `${left.providerId}:${left.billingDomainId}`.localeCompare(
+            `${right.providerId}:${right.billingDomainId}`
+          )
+        );
+      }
       async #sendNotificationTransitions() {
         if (!this.#notifier) return;
         const overview = this.#repository.getOverview(this.#clock());
@@ -1767,6 +2248,14 @@ var init_usage_application = __esm({
       async getOverview(query = {}) {
         return this.#repository.getOverview(this.#clock(), query);
       }
+      async getAgentProviderIndex() {
+        const now = this.#clock();
+        return this.#repository.getAgentProviderIndex?.(now) ?? pickAgentProviderIndex(this.#repository.getOverview(now));
+      }
+      async getProviderOverview(providerId, query = {}) {
+        const now = this.#clock();
+        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 accountIdentifiers = request.includeAccountIdentifiers ? this.#repository.getProviderAccountIdentifiers() : {};
@@ -5041,6 +5530,25 @@ async function startLocalServer(options) {
         sendOtlpProtobuf(response, 200);
         return;
       }
+      if (request.method === "GET" && requestUrl.pathname === "/api/overview/providers") {
+        sendJson(response, 200, await options.application.getAgentProviderIndex());
+        return;
+      }
+      if (request.method === "GET" && requestUrl.pathname.startsWith("/api/overview/providers/")) {
+        const providerId = decodeURIComponent(
+          requestUrl.pathname.slice("/api/overview/providers/".length)
+        );
+        const provider = await options.application.getProviderOverview(
+          providerId,
+          parseUsageQuery(requestUrl)
+        );
+        if (!provider) {
+          sendJson(response, 404, { error: "provider-not-found" });
+          return;
+        }
+        sendJson(response, 200, provider);
+        return;
+      }
       if (request.method === "GET" && requestUrl.pathname === "/api/overview") {
         const query = parseUsageQuery(requestUrl);
         sendJson(response, 200, await options.application.getOverview(query));
@@ -5051,6 +5559,13 @@ async function startLocalServer(options) {
           sendJson(response, 403, { error: "invalid-origin" });
           return;
         }
+        if (requestUrl.searchParams.get("background") === "true") {
+          void options.application.startBackgroundProcessing({
+            userInitiated: requestUrl.searchParams.get("mode") !== "automatic"
+          });
+          sendJson(response, 202, { accepted: true });
+          return;
+        }
         await options.application.refresh({
           userInitiated: requestUrl.searchParams.get("mode") !== "automatic"
         });
@@ -5103,6 +5618,19 @@ async function startLocalServer(options) {
         sendJson(response, 200, await options.application.clearData(input));
         return;
       }
+      if (request.method === "GET" && requestUrl.pathname === "/api/plans") {
+        sendJson(response, 200, await options.application.getPlanSettings());
+        return;
+      }
+      if (request.method === "PATCH" && requestUrl.pathname === "/api/plans") {
+        if (!validMutationOrigin(authentication, request, origin)) {
+          sendJson(response, 403, { error: "invalid-origin" });
+          return;
+        }
+        const input = planSubscriptionSchema.parse(await readJsonBody(request));
+        sendJson(response, 200, await options.application.updatePlanSubscription(input));
+        return;
+      }
       if (request.method === "GET" && requestUrl.pathname === "/api/monitoring") {
         sendJson(response, 200, await options.application.getMonitoringStatus());
         return;
@@ -5301,7 +5829,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, clearDataSchema, hardRebuildSchema;
+var SESSION_COOKIE, connectorActionSchema, usageQuerySchema, monitoringSettingsSchema, planSubscriptionSchema, clearDataSchema, hardRebuildSchema;
 var init_local_server = __esm({
   "src/server/local-server.ts"() {
     "use strict";
@@ -5324,6 +5852,17 @@ var init_local_server = __esm({
       notificationsEnabled: z9.boolean().optional(),
       startAtLogin: z9.boolean().optional()
     }).refine((value) => Object.keys(value).length > 0, "At least one setting is required");
+    planSubscriptionSchema = z9.object({
+      providerId: z9.string().min(1),
+      billingDomainId: z9.string().min(1),
+      plan: z9.object({
+        planId: z9.string().min(1).nullable(),
+        amount: z9.number().positive().finite().optional(),
+        currency: z9.string().length(3).optional(),
+        billingPeriod: z9.enum(["monthly", "annual"]).optional(),
+        anchorDate: z9.string().regex(/^\d{4}-\d{2}-\d{2}$/).nullable().optional()
+      }).nullable()
+    });
     clearDataSchema = z9.object({ deleteProductSecrets: z9.boolean().default(false) });
     hardRebuildSchema = z9.object({ confirmExpensiveOperation: z9.literal(true) });
   }
@@ -6253,7 +6792,7 @@ function buildGlobalSummary(providers, riskSummary, now, query) {
     tokenEvidence,
     apiRetailEquivalent: {
       status: sawRetailEquivalent ? "available" : "unavailable",
-      amount: sawRetailEquivalent ? preciseAmount(retailAmount) : null,
+      amount: sawRetailEquivalent ? preciseAmount2(retailAmount) : null,
       currency: "USD",
       pricingCoverage: tokenEvidence.recordedTokens === 0 ? null : retailPricedTokens / tokenEvidence.recordedTokens
     },
@@ -6263,7 +6802,7 @@ function buildGlobalSummary(providers, riskSummary, now, query) {
     contributions
   };
 }
-function buildTokenMoneyWorkbench(providers, now, query) {
+function buildTokenMoneyWorkbench(providers, now, query, planSubscriptions, planBillingPeriods) {
   const normalized = normalizeUsageQuery(now, query);
   const allHistories = allDomainHistories(providers);
   const headlineHistories = allHistories.filter(({ includedInHeadline }) => includedInHeadline);
@@ -6454,9 +6993,43 @@ function buildTokenMoneyWorkbench(providers, now, query) {
       observationCount > 0 ? recordedTokens : null,
       retailEquivalent,
       reportedEstimate
-    )
+    ),
+    planValue: buildWorkbenchPlanValue({
+      domains: planValueDomains(allHistories, comparisonCurrency),
+      subscriptions: planSubscriptions,
+      comparisonCurrency,
+      start: normalized.start.toISOString(),
+      end: normalized.end.toISOString(),
+      rates: uniqueExchangeRates(allHistories.flatMap(({ history }) => history.exchangeRates)),
+      billingPeriods: planBillingPeriods
+    })
   };
 }
+function planValueDomains(histories, comparisonCurrency) {
+  return histories.map(({ provider, domain, history, includedInHeadline }) => {
+    const domainTokens = history.tokenEvidence.recordedTokens;
+    const metric = (purpose) => buildWorkbenchMetric(
+      history.costs,
+      purpose,
+      comparisonCurrency,
+      domainTokens,
+      history.exchangeRates
+    );
+    return {
+      providerId: provider.id,
+      providerDisplayName: provider.displayName,
+      billingDomainId: domain.id,
+      billingDomainDisplayName: domain.displayName,
+      includedInHeadline,
+      recordedTokens: domainTokens,
+      observationCount: history.tokenEvidence.observationCount,
+      retailEquivalent: metric("retail-equivalent"),
+      actualCost: metric("actual"),
+      authorities: history.authorities ?? [],
+      lastObservedAt: history.lastObservedAt ?? null
+    };
+  });
+}
 function allDomainHistories(providers) {
   return providers.flatMap(
     (provider) => provider.billingDomains.map((domain) => ({
@@ -6512,11 +7085,11 @@ function buildWorkbenchMetric(costs, purpose, comparisonCurrency, recordedTokens
   return {
     purpose,
     status,
-    amount: status === "available" ? preciseAmount(convertedAmount) : null,
+    amount: status === "available" ? preciseAmount2(convertedAmount) : null,
     comparisonCurrency,
     nativeAmounts: [...native.entries()].map(([currency, amount]) => ({
       currency,
-      amount: amount.complete ? preciseAmount(amount.amount) : null,
+      amount: amount.complete ? preciseAmount2(amount.amount) : null,
       records: amount.records,
       knownRecords: amount.knownRecords
     })).sort((left, right) => left.currency.localeCompare(right.currency)),
@@ -7108,7 +7681,7 @@ function round(value) {
 function pricingInputsChanged(existing, observation) {
   return existing.billing_domain_id !== observation.billingDomainId || existing.model !== (observation.model?.trim() || "__unclassified__") || existing.observed_at !== observation.observedAt || Number(existing.total_tokens) !== observation.recordedTokens || Number(existing.input_tokens) !== observation.inputTokens || Number(existing.output_tokens) !== observation.outputTokens || Number(existing.reasoning_tokens) !== observation.reasoningTokens || Number(existing.cache_read_tokens) !== observation.cacheReadTokens || Number(existing.cache_write_tokens) !== observation.cacheWriteTokens || (existing.cache_write_5m_tokens === null ? null : Number(existing.cache_write_5m_tokens)) !== (observation.cacheWriteTokenBreakdown?.fiveMinute ?? null) || (existing.cache_write_1h_tokens === null ? null : Number(existing.cache_write_1h_tokens)) !== (observation.cacheWriteTokenBreakdown?.oneHour ?? null) || Number(existing.unclassified_tokens) !== observation.unclassifiedTokens || existing.reasoning_semantics !== observation.tokenSemantics.reasoning || existing.cache_read_semantics !== observation.tokenSemantics.cacheRead || existing.cache_write_semantics !== observation.tokenSemantics.cacheWrite || existing.model_attribution !== observation.modelAttribution || existing.time_precision !== observation.timePrecision || existing.aggregation_temporality !== observation.aggregationTemporality;
 }
-function preciseAmount(value) {
+function preciseAmount2(value) {
   return Number(value.toFixed(12));
 }
 function tokenAuthority(authorities) {
@@ -7144,6 +7717,7 @@ var init_sqlite_usage_repository = __esm({
   "src/server/sqlite-usage-repository.ts"() {
     "use strict";
     init_token_normalization();
+    init_plan_pricing();
     FRESHNESS_WINDOW_MS = 15 * 60 * 1e3;
     QUERY_INDEXES_SQL = `
   CREATE INDEX IF NOT EXISTS usage_observed_at_idx
@@ -7704,14 +8278,38 @@ var init_sqlite_usage_repository = __esm({
           (provider) => this.#getProviderOverview(provider, now, query)
         );
         const riskSummary = buildRiskSummary(overviews);
+        const planSubscriptions = this.getPlanSubscriptions();
         return {
           generatedAt: now.toISOString(),
           globalSummary: buildGlobalSummary(overviews, riskSummary, now, query),
-          workbench: buildTokenMoneyWorkbench(overviews, now, query),
+          workbench: buildTokenMoneyWorkbench(
+            overviews,
+            now,
+            query,
+            planSubscriptions,
+            this.#planBillingPeriodSummaries(planSubscriptions, now, query)
+          ),
           providers: overviews,
           riskSummary
         };
       }
+      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")
+          ).map((provider) => ({ id: provider.id, displayName: provider.display_name }))
+        };
+      }
+      getProviderOverview(now, providerId, query = {}) {
+        if (this.#hideDemoProvider && providerId === "demo") return null;
+        const provider = this.#database.prepare(
+          `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;
+      }
       saveExchangeRateSnapshot(snapshot2) {
         this.#database.prepare(
           `INSERT INTO exchange_rate_snapshots (
@@ -7787,6 +8385,57 @@ var init_sqlite_usage_repository = __esm({
           settings.startAtLogin ? 1 : 0
         );
       }
+      getPlanSubscriptions() {
+        const rows = this.#database.prepare(
+          `SELECT provider_id, billing_domain_id, plan_id, display_name, amount, currency,
+                billing_period, anchor_date, price_source, updated_at
+         FROM plan_subscriptions
+         ORDER BY provider_id, billing_domain_id`
+        ).all();
+        return rows.map((row) => ({
+          providerId: row.provider_id,
+          billingDomainId: row.billing_domain_id,
+          planId: row.plan_id,
+          displayName: row.display_name,
+          amount: row.amount,
+          currency: row.currency,
+          billingPeriod: row.billing_period,
+          anchorDate: row.anchor_date,
+          priceSource: row.price_source,
+          updatedAt: row.updated_at
+        }));
+      }
+      savePlanSubscription(subscription) {
+        this.#database.prepare(
+          `INSERT INTO plan_subscriptions (
+           provider_id, billing_domain_id, plan_id, display_name, amount, currency,
+           billing_period, anchor_date, price_source, updated_at
+         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(provider_id, billing_domain_id) DO UPDATE SET
+           plan_id = excluded.plan_id,
+           display_name = excluded.display_name,
+           amount = excluded.amount,
+           currency = excluded.currency,
+           billing_period = excluded.billing_period,
+           anchor_date = excluded.anchor_date,
+           price_source = excluded.price_source,
+           updated_at = excluded.updated_at`
+        ).run(
+          subscription.providerId,
+          subscription.billingDomainId,
+          subscription.planId,
+          subscription.displayName,
+          subscription.amount,
+          subscription.currency,
+          subscription.billingPeriod,
+          subscription.anchorDate,
+          subscription.priceSource,
+          subscription.updatedAt
+        );
+      }
+      deletePlanSubscription(providerId, billingDomainId) {
+        this.#database.prepare("DELETE FROM plan_subscriptions WHERE provider_id = ? AND billing_domain_id = ?").run(providerId, billingDomainId);
+      }
       getNotificationState(key) {
         const row = this.#database.prepare("SELECT value FROM notification_state WHERE key = ?").get(key);
         return row?.value ?? null;
@@ -8245,6 +8894,101 @@ var init_sqlite_usage_repository = __esm({
           coverageByDomain
         };
       }
+      /**
+       * Cycle-to-date evidence for every subscription that declares a renewal date.
+       * Each Provider is measured over its own billing period, which is why this
+       * cannot reuse the one rolling window the rest of the workbench shares.
+       */
+      #planBillingPeriodSummaries(subscriptions, now, query) {
+        const normalized = normalizeUsageQuery(now, query);
+        const summaries = /* @__PURE__ */ new Map();
+        for (const subscription of subscriptions) {
+          if (!subscription.anchorDate) continue;
+          const period = billingPeriodContaining(
+            subscription.anchorDate,
+            subscription.billingPeriod,
+            now
+          );
+          if (!period) continue;
+          const observedThrough = new Date(Math.min(now.getTime(), period.end.getTime()));
+          summaries.set(`${subscription.providerId}:${subscription.billingDomainId}`, {
+            start: period.start.toISOString(),
+            end: period.end.toISOString(),
+            observedThrough: observedThrough.toISOString(),
+            ...this.#rangeUsageSummary(
+              subscription.providerId,
+              subscription.billingDomainId,
+              period.start,
+              observedThrough,
+              normalized.comparisonCurrency
+            )
+          });
+        }
+        return summaries;
+      }
+      #rangeUsageSummary(providerId, billingDomainId, start, end, comparisonCurrency) {
+        const startIso = start.toISOString();
+        const endIso = end.toISOString();
+        const usage = this.#database.prepare(
+          `SELECT id, model, observed_at, authority, total_tokens, input_tokens, output_tokens,
+                reasoning_tokens, cache_read_tokens, cache_write_tokens, cache_write_5m_tokens,
+                cache_write_1h_tokens, source_reported_total_tokens,
+                unclassified_tokens, total_derivation, model_attribution, time_precision,
+                usage_scope, aggregation_temporality, reasoning_semantics,
+                cache_read_semantics, cache_write_semantics
+         FROM usage_observations
+         WHERE provider_id = ? AND billing_domain_id = ?
+           AND observed_at >= ? AND observed_at < ?
+           AND ${additiveUsagePredicate()}
+         ORDER BY observed_at, id`
+        ).all(providerId, billingDomainId, startIso, endIso);
+        const costs = 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,
+                price_snapshot_effective_until, price_snapshot_currency,
+                price_snapshot_rates_json, price_snapshot_source_url,
+                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 = ?
+           AND observed_at >= ? AND observed_at < ?
+         ORDER BY observed_at, id`
+        ).all(providerId, billingDomainId, startIso, endIso);
+        const rateRows = this.#database.prepare(
+          `SELECT id, base_currency, quote_currency, rate, observed_at, source
+         FROM exchange_rate_snapshots WHERE observed_at < ? ORDER BY observed_at DESC, id`
+        ).all(endIso);
+        const rateByCurrency = /* @__PURE__ */ new Map();
+        for (const row of rateRows) {
+          if (row.quote_currency === comparisonCurrency && !rateByCurrency.has(row.base_currency)) {
+            rateByCurrency.set(row.base_currency, row);
+          }
+        }
+        const evidence = emptyTokenEvidence();
+        for (const row of usage) addTokenEvidence(evidence, row);
+        const finished = finishTokenEvidence(evidence);
+        const usedRates = /* @__PURE__ */ new Map();
+        const historyCosts = summarizeHistoryCosts(
+          costs,
+          finished.recordedTokens,
+          rateByCurrency,
+          comparisonCurrency,
+          end,
+          usedRates
+        );
+        return {
+          recordedTokens: finished.recordedTokens,
+          observationCount: finished.observationCount,
+          retailEquivalent: buildWorkbenchMetric(
+            historyCosts,
+            "retail-equivalent",
+            comparisonCurrency,
+            finished.recordedTokens,
+            [...usedRates.values()]
+          )
+        };
+      }
       #getBillingHistory(providerId, billingDomainId, now, query) {
         const normalized = normalizeUsageQuery(now, query);
         const start = normalized.start.toISOString();
@@ -8653,6 +9397,19 @@ var init_sqlite_usage_repository = __esm({
         key TEXT PRIMARY KEY,
         value TEXT NOT NULL
       );
+      CREATE TABLE IF NOT EXISTS plan_subscriptions (
+        provider_id TEXT NOT NULL,
+        billing_domain_id TEXT NOT NULL,
+        plan_id TEXT,
+        display_name TEXT NOT NULL,
+        amount REAL NOT NULL,
+        currency TEXT NOT NULL,
+        billing_period TEXT NOT NULL,
+        anchor_date TEXT,
+        price_source TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        PRIMARY KEY (provider_id, billing_domain_id)
+      );
     `);
         const usageColumns = this.#database.prepare("PRAGMA table_info(usage_observations)").all();
         if (!usageColumns.some((column) => column.name === "total_tokens")) {
@@ -8821,6 +9578,10 @@ var init_sqlite_usage_repository = __esm({
             this.#database.exec(`ALTER TABLE quota_buckets ADD COLUMN ${name} ${type}`);
           }
         }
+        const planColumns = this.#database.prepare("PRAGMA table_info(plan_subscriptions)").all();
+        if (planColumns.length > 0 && !planColumns.some((column) => column.name === "anchor_date")) {
+          this.#database.exec("ALTER TABLE plan_subscriptions ADD COLUMN anchor_date TEXT");
+        }
       }
     };
   }