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

package/dist/cli.js

@@ -643,6 +643,41 @@ function xaiEntry(options) {
     source: XAI_PRICING_SOURCE
   };
 }
+function openCodeLocalHistoryEntries(entries) {
+  return entries.flatMap((entry) => {
+    const modelPrefix = openCodeLocalModelPrefix(entry);
+    if (!modelPrefix) return [];
+    const localModel = (model) => model.includes("/") ? model : `${modelPrefix}/${model}`;
+    const canonicalModel = localModel(entry.canonicalModel);
+    return [
+      {
+        ...entry,
+        id: `opencode-local-${entry.id}`,
+        providerId: "opencode",
+        billingDomainId: "local-history",
+        canonicalModel,
+        aliases: [
+          ...new Set(
+            [entry.canonicalModel, ...entry.aliases].map(localModel).filter((model) => model !== canonicalModel)
+          )
+        ]
+      }
+    ];
+  });
+}
+function openCodeLocalModelPrefix(entry) {
+  if (entry.providerId === "claude-code" && entry.billingDomainId === "subscription") {
+    return "anthropic";
+  }
+  if (entry.providerId === "codex" && entry.billingDomainId === "subscription") {
+    return "openai";
+  }
+  if (entry.providerId === "grok" && entry.billingDomainId === "xai-api") return "xai";
+  if (entry.providerId === "opencode-go" && entry.billingDomainId === "go-subscription") {
+    return "opencode-go";
+  }
+  return null;
+}
 function deriveRetailEquivalentCosts(snapshot2, catalog = ANTHROPIC_PRICING_CATALOG, calculatedAt = snapshot2.observedAt) {
   const costs = [];
   const decisions = [];
@@ -714,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) => {
@@ -742,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));
@@ -806,7 +848,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, 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, DIRECT_OFFICIAL_PRICING_CATALOG, OFFICIAL_PRICING_CATALOG;
 var init_retail_pricing = __esm({
   "src/core/retail-pricing.ts"() {
     "use strict";
@@ -1004,7 +1046,7 @@ var init_retail_pricing = __esm({
       { startHour: 1, endHour: 4 },
       { startHour: 6, endHour: 10 }
     ];
-    OFFICIAL_PRICING_CATALOG = {
+    DIRECT_OFFICIAL_PRICING_CATALOG = {
       version: "2026-08-28-grok-4.6-build",
       entries: [
         ...ANTHROPIC_PRICING_CATALOG.entries,
@@ -1139,6 +1181,389 @@ var init_retail_pricing = __esm({
         })
       ]
     };
+    OFFICIAL_PRICING_CATALOG = {
+      version: "2026-08-29-opencode-local-history",
+      entries: [
+        ...DIRECT_OFFICIAL_PRICING_CATALOG.entries,
+        ...openCodeLocalHistoryEntries(DIRECT_OFFICIAL_PRICING_CATALOG.entries)
+      ]
+    };
+  }
+});
+
+// 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"
+          }
+        }
+      ]
+    };
   }
 });
 
@@ -1247,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"() {
@@ -1255,6 +1686,7 @@ var init_usage_application = __esm({
     init_redaction();
     init_usage_export();
     init_retail_pricing();
+    init_plan_pricing();
     UsageApplication = class {
       #repository;
       #connectors;
@@ -1268,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) {
@@ -1287,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) {
@@ -1333,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 () => {
@@ -1577,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());
@@ -1725,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() : {};
@@ -1933,9 +2464,9 @@ var init_catalog = __esm({
       },
       {
         id: "opencode-go",
-        displayName: "OpenCode Go",
+        displayName: "OpenCode",
         command: "opencode",
-        permissionDescription: "Read account quota and local exports through official OpenCode surfaces.",
+        permissionDescription: "Read local usage and optional Go account quota through official OpenCode surfaces.",
         credentialOwner: "official-client",
         experimental: false,
         expectedCoverage: ["quota", "tokens", "history"],
@@ -1990,6 +2521,7 @@ function mapQuota(quota) {
     billingDomainId: "subscription",
     label: quota.label,
     usedPercent: quota.usedPercent,
+    windowDurationMinutes: quota.windowDurationMinutes,
     resetsAt: quota.resetsAt,
     authority: "official-client",
     scope: "account-wide"
@@ -2294,6 +2826,7 @@ function parseClaudeUsageScreen(text, now) {
       id,
       label: displayLabel(heading),
       usedPercent: Number(match[1]),
+      windowDurationMinutes: windowDurationMinutes(heading),
       resetsAt: resetLine ? parseReset(resetLine, now) : null
     });
   }
@@ -2326,6 +2859,11 @@ function displayLabel(heading) {
   const weekly = heading.match(/^Weekly\s*[·—-]\s*(.+)$/i);
   return weekly ? `Week \xB7 ${weekly[1]}` : heading;
 }
+function windowDurationMinutes(heading) {
+  if (/^(5[- ]hour limit|current session)$/i.test(heading)) return 300;
+  if (/^(Current week\s*\(.+\)|Weekly\s*[·—-]\s*.+)$/i.test(heading)) return 10080;
+  return null;
+}
 function parseReset(line, now) {
   const relative = line.match(/Resets\s+in\s+(?:(\d+)d\s*)?(?:(\d+)h\s*)?(?:(\d+)m)?/i);
   if (relative) {
@@ -2652,6 +3190,7 @@ function mapQuotaBuckets(response) {
         billingDomainId: "subscription",
         label: multipleLimits ? `${baseLabel} \xB7 ${windowLabel}` : windowLabel,
         usedPercent: window.usedPercent,
+        windowDurationMinutes: window.windowDurationMins,
         resetsAt: window.resetsAt === null ? null : new Date(window.resetsAt * 1e3).toISOString(),
         authority: "official-account"
       });
@@ -2989,6 +3528,119 @@ var init_stdio_codex_account_client = __esm({
   }
 });
 
+// src/connectors/opencode-local/opencode-local-connector.ts
+function mapLocalUsage(request) {
+  return {
+    id: `opencode-local-request:${request.id}`,
+    billingDomainId: "local-history",
+    model: request.model,
+    observedAt: new Date(request.observedAtMs).toISOString(),
+    inputTokens: request.inputTokens,
+    outputTokens: request.outputTokens,
+    reasoningTokens: request.reasoningTokens,
+    cacheReadTokens: request.cacheReadTokens,
+    cacheWriteTokens: request.cacheWriteTokens,
+    tokenSemantics: {
+      reasoning: "separate",
+      cacheRead: "separate",
+      cacheWrite: "separate"
+    },
+    modelAttribution: "known",
+    timePrecision: "event",
+    usageScope: "this-mac",
+    aggregationTemporality: "delta",
+    authority: "local-observation"
+  };
+}
+function mapLocalCost(request, cost) {
+  const usageObservationId = `opencode-local-request:${request.id}`;
+  return {
+    id: `opencode-local-request-cost:${request.id}`,
+    sourceId: usageObservationId,
+    billingDomainId: "local-history",
+    observedAt: new Date(request.observedAtMs).toISOString(),
+    kind: "reported-estimate",
+    amount: cost,
+    currency: "USD",
+    authority: "local-observation",
+    model: request.model,
+    usageObservationId,
+    priceSnapshot: {
+      id: "opencode-local-message-reported-cost-v1",
+      version: "2026-08-29",
+      source: "OpenCode local message history reported cost",
+      canonicalModel: request.model,
+      effectiveAt: "2026-08-29T00:00:00.000Z",
+      effectiveUntil: null,
+      currency: "USD",
+      ratesPerMillion: {
+        input: null,
+        output: null,
+        reasoning: null,
+        "cache-read": null,
+        "cache-write": null
+      }
+    }
+  };
+}
+function safeFailure3(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: "opencode-local-refresh-failed",
+    message: "OpenCode local history coverage is incomplete.",
+    recovery: "Run agent-usage doctor, then retry refresh."
+  };
+}
+var OpenCodeLocalConnector;
+var init_opencode_local_connector = __esm({
+  "src/connectors/opencode-local/opencode-local-connector.ts"() {
+    "use strict";
+    OpenCodeLocalConnector = class {
+      id = "opencode";
+      displayName = "OpenCode";
+      consentId = "opencode-go";
+      #localHistoryClient;
+      #clock;
+      constructor(options) {
+        this.#localHistoryClient = options.localHistoryClient;
+        this.#clock = options.clock ?? (() => /* @__PURE__ */ new Date());
+      }
+      async collect() {
+        const observedAt = this.#clock().toISOString();
+        try {
+          const requests = await this.#localHistoryClient.readHistory();
+          return {
+            provider: { id: this.id, displayName: this.displayName },
+            billingDomains: [{ id: "local-history", displayName: "Local history" }],
+            quotaBuckets: [],
+            usage: requests.map(mapLocalUsage),
+            usageReconciliation: {
+              authoritativeIdPrefix: "opencode-local-request:",
+              retiredIdPrefixes: []
+            },
+            costs: requests.flatMap(
+              (request) => request.cost === null ? [] : [mapLocalCost(request, request.cost)]
+            ),
+            observedAt
+          };
+        } catch (error) {
+          return {
+            provider: { id: this.id, displayName: this.displayName },
+            billingDomains: [{ id: "local-history", displayName: "Local history" }],
+            quotaBuckets: [],
+            usage: [],
+            costs: [],
+            warnings: [safeFailure3(error)],
+            observedAt
+          };
+        }
+      }
+    };
+  }
+});
+
 // src/connectors/opencode-go/local-opencode-history-client.ts
 import { execFile as execFileCallback } from "child_process";
 import { createHash } from "crypto";
@@ -3077,12 +3729,27 @@ var init_local_opencode_history_client = __esm({
       #command;
       #execFile;
       #readDatabase;
+      #activeRead = null;
       constructor(options = {}) {
         this.#command = options.command ?? "opencode";
         this.#execFile = options.execFile ?? executeOpenCode;
         this.#readDatabase = options.readDatabase ?? readDatabase;
       }
-      async readHistory() {
+      readHistory() {
+        if (this.#activeRead) return this.#activeRead;
+        const activeRead = this.#readHistory();
+        this.#activeRead = activeRead;
+        activeRead.then(
+          () => {
+            if (this.#activeRead === activeRead) this.#activeRead = null;
+          },
+          () => {
+            if (this.#activeRead === activeRead) this.#activeRead = null;
+          }
+        );
+        return activeRead;
+      }
+      async #readHistory() {
         let databasePath;
         try {
           const { stdout } = await this.#execFile(this.#command, ["db", "path"]);
@@ -3113,8 +3780,9 @@ var init_local_opencode_history_client = __esm({
             { cause: error }
           );
         }
-        return completedAssistantRows.filter((row) => row.providerId === "opencode-go").filter(hasCategorizedTokens).map((row) => ({
+        return completedAssistantRows.filter(hasCategorizedTokens).map((row) => ({
           id: `v2:${createHash("sha256").update(row.sourceId).digest("hex")}`,
+          providerId: row.providerId,
           model: `${row.providerId}/${row.modelId}`,
           cost: row.cost,
           inputTokens: row.inputTokens,
@@ -3317,6 +3985,7 @@ function mapQuota2(response) {
     billingDomainId: "go-subscription",
     label: LIMITS[id].label,
     usedPercent: response.usage[id].percent,
+    windowDurationMinutes: LIMITS[id].windowDurationMinutes,
     resetsAt: response.usage[id].resetsAt,
     authority: "official-account",
     scope: "account-wide",
@@ -3326,61 +3995,7 @@ function mapQuota2(response) {
     fallbackStatus: "unknown"
   }));
 }
-function mapLocalUsage(request) {
-  return {
-    id: `opencode-request:${request.id}`,
-    billingDomainId: "go-subscription",
-    model: request.model,
-    observedAt: new Date(request.observedAtMs).toISOString(),
-    inputTokens: request.inputTokens,
-    outputTokens: request.outputTokens,
-    reasoningTokens: request.reasoningTokens,
-    cacheReadTokens: request.cacheReadTokens,
-    cacheWriteTokens: request.cacheWriteTokens,
-    tokenSemantics: {
-      reasoning: "separate",
-      cacheRead: "separate",
-      cacheWrite: "separate"
-    },
-    modelAttribution: "known",
-    timePrecision: "event",
-    usageScope: "this-mac",
-    aggregationTemporality: "delta",
-    authority: "local-observation"
-  };
-}
-function mapLocalCost(request, cost) {
-  const usageObservationId = `opencode-request:${request.id}`;
-  return {
-    id: `opencode-request-cost:${request.id}`,
-    sourceId: usageObservationId,
-    billingDomainId: "go-subscription",
-    observedAt: new Date(request.observedAtMs).toISOString(),
-    kind: "reported-estimate",
-    amount: cost,
-    currency: "USD",
-    authority: "local-observation",
-    model: request.model,
-    usageObservationId,
-    priceSnapshot: {
-      id: "opencode-message-reported-cost-v2",
-      version: "2026-08-28",
-      source: "OpenCode local message history reported cost",
-      canonicalModel: request.model,
-      effectiveAt: "2026-08-28T00:00:00.000Z",
-      effectiveUntil: null,
-      currency: "USD",
-      ratesPerMillion: {
-        input: null,
-        output: null,
-        reasoning: null,
-        "cache-read": null,
-        "cache-write": null
-      }
-    }
-  };
-}
-function safeFailure3(error) {
+function safeFailure4(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 };
   }
@@ -3395,9 +4010,9 @@ var init_opencode_go_connector = __esm({
   "src/connectors/opencode-go/opencode-go-connector.ts"() {
     "use strict";
     LIMITS = {
-      rolling: { label: "5 hour", amount: 12 },
-      weekly: { label: "Week", amount: 30 },
-      monthly: { label: "Month", amount: 60 }
+      rolling: { label: "5 hour", amount: 12, windowDurationMinutes: 300 },
+      weekly: { label: "Week", amount: 30, windowDurationMinutes: 10080 },
+      monthly: { label: "Month", amount: 60, windowDurationMinutes: 43200 }
     };
     OpenCodeGoConnector = class {
       id = "opencode-go";
@@ -3418,24 +4033,21 @@ var init_opencode_go_connector = __esm({
           this.#localHistoryClient.readHistory()
         ]);
         const warnings = [];
-        if (accountResult.status === "rejected") warnings.push(safeFailure3(accountResult.reason));
-        if (localResult.status === "rejected") warnings.push(safeFailure3(localResult.reason));
+        if (accountResult.status === "rejected") warnings.push(safeFailure4(accountResult.reason));
+        if (localResult.status === "rejected") warnings.push(safeFailure4(localResult.reason));
         const account = accountResult.status === "fulfilled" ? accountResult.value : null;
-        const local = localResult.status === "fulfilled" ? localResult.value : [];
         return {
           provider: { id: this.id, displayName: this.displayName },
           billingDomains: [{ id: "go-subscription", displayName: "OpenCode Go subscription" }],
           quotaBuckets: account ? mapQuota2(account) : [],
-          usage: local.map(mapLocalUsage),
+          usage: [],
           ...localResult.status === "fulfilled" ? {
             usageReconciliation: {
               authoritativeIdPrefix: "opencode-request:",
               retiredIdPrefixes: ["opencode-session:"]
             }
           } : {},
-          costs: local.flatMap(
-            (request) => request.cost === null ? [] : [mapLocalCost(request, request.cost)]
-          ),
+          costs: [],
           warnings,
           observedAt
         };
@@ -3473,6 +4085,11 @@ function mapBillingQuota(billing) {
       billingDomainId: "grok-build-subscription",
       label: period.label,
       usedPercent,
+      windowDurationMinutes: nativeWindowDurationMinutes(
+        config.currentPeriod?.start ?? config.billingPeriodStart,
+        resetsAt,
+        period.id
+      ),
       resetsAt,
       authority: "official-client",
       scope: "account-wide",
@@ -3480,6 +4097,16 @@ function mapBillingQuota(billing) {
     }
   ];
 }
+function nativeWindowDurationMinutes(startsAt, resetsAt, period) {
+  const start = startsAt ? Date.parse(startsAt) : Number.NaN;
+  const end = resetsAt ? Date.parse(resetsAt) : Number.NaN;
+  if (Number.isFinite(start) && Number.isFinite(end) && end > start) {
+    return Math.round((end - start) / 6e4);
+  }
+  if (period === "weekly") return 10080;
+  if (period === "monthly") return 43200;
+  return null;
+}
 function nativePeriod(type, fallback) {
   if (type === "USAGE_PERIOD_TYPE_WEEKLY") return { id: "weekly", label: "Weekly limit" };
   if (type === "USAGE_PERIOD_TYPE_MONTHLY" || fallback === "monthly") {
@@ -3491,7 +4118,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 safeFailure4(error) {
+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 };
   }
@@ -3554,7 +4181,7 @@ var init_grok_build_connector = __esm({
             });
           }
         } catch (error) {
-          warnings.push(safeFailure4(error));
+          warnings.push(safeFailure5(error));
         }
         const history = this.#historyClient ? await this.#historyClient.readUsage(options) : { usage: [], costs: [], complete: true };
         if (!history.complete) warnings.push(incompleteTranscriptFailure3());
@@ -3698,6 +4325,50 @@ import { open } from "fs/promises";
 import { homedir as homedir2 } from "os";
 import { join as join3 } from "path";
 import { z as z7 } from "zod";
+function billingIsFresh(billing, now) {
+  if (!billing.sourceObservedAt) return false;
+  const observedAt = Date.parse(billing.sourceObservedAt);
+  if (!Number.isFinite(observedAt)) return false;
+  return now.getTime() - observedAt <= GROK_BILLING_FRESHNESS_MS;
+}
+async function refreshBillingLogViaDashboard(command, timeoutMs) {
+  if (process.platform !== "darwin") return;
+  const refreshTimeoutMs = Math.min(timeoutMs, 6e3);
+  const expectScript2 = [
+    `set timeout ${Math.max(1, Math.ceil(refreshTimeoutMs / 1e3))}`,
+    "log_user 0",
+    "set command $env(AGENT_USAGE_GROK_REFRESH_COMMAND)",
+    "spawn -noecho $command dashboard",
+    `after ${Math.min(2e3, Math.max(250, refreshTimeoutMs - 1e3))}`,
+    'send "\\021\\021"',
+    "expect eof"
+  ].join("\n");
+  await new Promise((resolve5) => {
+    const dashboard = spawn3("/usr/bin/expect", ["-c", expectScript2], {
+      env: {
+        ...process.env,
+        AGENT_USAGE_GROK_REFRESH_COMMAND: command,
+        TERM: process.env.TERM ?? "xterm-256color"
+      },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    dashboard.stdout.resume();
+    dashboard.stderr.resume();
+    let settled = false;
+    const stopTimer = setTimeout(() => {
+      dashboard.kill("SIGTERM");
+      finish();
+    }, refreshTimeoutMs);
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(stopTimer);
+      resolve5();
+    };
+    dashboard.once("error", finish);
+    dashboard.once("exit", finish);
+  });
+}
 function parseLatestBillingLog(text) {
   const lines = text.split(/\r?\n/);
   for (let index = lines.length - 1; index >= 0; index -= 1) {
@@ -3748,7 +4419,7 @@ function unavailableError3(cause) {
     { cause }
   );
 }
-var GrokBillingAdapterError, StdioGrokBillingClient, JsonRpcError, JsonLinePeer2;
+var GrokBillingAdapterError, StdioGrokBillingClient, GROK_BILLING_FRESHNESS_MS, JsonRpcError, JsonLinePeer2;
 var init_stdio_grok_billing_client = __esm({
   "src/connectors/grok-build/stdio-grok-billing-client.ts"() {
     "use strict";
@@ -3768,6 +4439,8 @@ var init_stdio_grok_billing_client = __esm({
       #timeoutMs;
       #spawnProcess;
       #readUnifiedLog;
+      #refreshBillingLog;
+      #clock;
       constructor(options = {}) {
         this.#command = options.command ?? "grok";
         this.#timeoutMs = options.timeoutMs ?? 8e3;
@@ -3777,13 +4450,15 @@ var init_stdio_grok_billing_client = __esm({
         this.#readUnifiedLog = options.readUnifiedLog ?? (() => readLogTail(
           join3(process.env.GROK_HOME ?? join3(homedir2(), ".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());
       }
       async readBilling() {
         let process2;
         try {
           process2 = this.#spawnProcess(this.#command, ["agent", "--no-leader", "stdio"]);
         } catch (error) {
-          const fallback = await this.#readLogFallback();
+          const fallback = await this.#readFreshLogFallback();
           if (fallback) return fallback;
           throw unavailableError3(error);
         }
@@ -3815,7 +4490,7 @@ var init_stdio_grok_billing_client = __esm({
           }
           return billing.data;
         } catch (error) {
-          const fallback = await this.#readLogFallback();
+          const fallback = await this.#readFreshLogFallback();
           if (fallback) return fallback;
           if (error instanceof GrokBillingAdapterError) throw error;
           if (error instanceof JsonRpcError && error.code === -32601) {
@@ -3846,7 +4521,18 @@ var init_stdio_grok_billing_client = __esm({
           return null;
         }
       }
+      async #readFreshLogFallback() {
+        const cached = await this.#readLogFallback();
+        if (cached && billingIsFresh(cached, this.#clock())) return cached;
+        try {
+          await this.#refreshBillingLog();
+        } catch {
+          return cached;
+        }
+        return await this.#readLogFallback() ?? cached;
+      }
     };
+    GROK_BILLING_FRESHNESS_MS = 5 * 60 * 1e3;
     JsonRpcError = class extends Error {
       code;
       constructor(body) {
@@ -4133,7 +4819,7 @@ function endpointFailure(error, label) {
     recovery: "Check network access and xAI status, then retry."
   };
 }
-function safeFailure5(error) {
+function safeFailure6(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 };
   }
@@ -4388,7 +5074,7 @@ var init_xai_api_connector = __esm({
             costs: [],
             balances: [],
             invoices: [],
-            warnings: [safeFailure5(error)],
+            warnings: [safeFailure6(error)],
             observedAt
           };
         }
@@ -4844,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));
@@ -4854,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"
         });
@@ -4906,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;
@@ -5104,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";
@@ -5127,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) });
   }
@@ -5677,6 +6413,16 @@ async function runDatabaseWorker(workerData) {
           if (workerData.operation === 'indexes') {
             database.exec(workerData.indexesSql);
             parentPort.postMessage({ ok: true, data: null });
+          } else if (workerData.operation === 'delete-demo-data') {
+            database.exec('BEGIN IMMEDIATE');
+            try {
+              database.exec(workerData.deleteDemoDataSql);
+              database.exec('COMMIT');
+              parentPort.postMessage({ ok: true, data: null });
+            } catch (error) {
+              database.exec('ROLLBACK');
+              throw error;
+            }
           } else if (workerData.operation === 'delete-derived-costs') {
             database.prepare(workerData.deleteDerivedCostsSql).run();
             parentPort.postMessage({ ok: true, data: null });
@@ -5844,6 +6590,7 @@ function mapQuotaRow(row) {
     billingDomainId: row.billing_domain_id,
     label: row.label,
     usedPercent: row.used_percent,
+    windowDurationMinutes: row.window_duration_minutes,
     resetsAt: row.resets_at,
     authority: row.authority,
     observedAt: row.observed_at,
@@ -6045,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
     },
@@ -6055,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);
@@ -6246,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) => ({
@@ -6304,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)),
@@ -6477,9 +7258,9 @@ function buildWorkbenchModelRanking(histories, buckets, comparisonCurrency, reco
     )
   );
   return {
-    byTokens: byTokens.slice(0, 5).map((entry) => entry.id),
-    byCost: byCost.slice(0, 5).map((entry) => entry.id),
-    byRetailEquivalent: byRetailEquivalent.slice(0, 5).map((entry) => entry.id),
+    byTokens: byTokens.map((entry) => entry.id),
+    byCost: byCost.map((entry) => entry.id),
+    byRetailEquivalent: byRetailEquivalent.map((entry) => entry.id),
     entries: byTokens,
     unclassified
   };
@@ -6900,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) {
@@ -6931,11 +7712,12 @@ 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, DatabaseSync2, RETENTION_AGGREGATE_SQL, SqliteUsageRepository;
+var FRESHNESS_WINDOW_MS, QUERY_INDEXES_SQL, DELETE_DERIVED_RETAIL_COSTS_SQL, DELETE_DEMO_PROVIDER_DATA_SQL, DatabaseSync2, RETENTION_AGGREGATE_SQL, SqliteUsageRepository;
 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
@@ -6964,6 +7746,12 @@ var init_sqlite_usage_repository = __esm({
       WHERE usage.provider_id = cost_records.provider_id
         AND usage.id = cost_records.usage_observation_id
     )
+`;
+    DELETE_DEMO_PROVIDER_DATA_SQL = `
+  DELETE FROM connector_diagnostics WHERE provider_id = 'demo';
+  DELETE FROM connector_runtime WHERE id = 'demo';
+  DELETE FROM connector_settings WHERE id = 'demo';
+  DELETE FROM providers WHERE id = 'demo';
 `;
     ({ DatabaseSync: DatabaseSync2 } = createRequire2(import.meta.url)(
       "node:sqlite"
@@ -6992,8 +7780,10 @@ var init_sqlite_usage_repository = __esm({
     SqliteUsageRepository = class {
       #database;
       #databasePath;
-      constructor(databasePath) {
+      #hideDemoProvider;
+      constructor(databasePath, options = {}) {
         this.#databasePath = databasePath;
+        this.#hideDemoProvider = options.hideDemoProvider ?? false;
         mkdirSync(dirname3(databasePath), { recursive: true });
         this.#database = new DatabaseSync2(databasePath);
         this.#database.exec("PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON;");
@@ -7041,13 +7831,15 @@ var init_sqlite_usage_repository = __esm({
           }
           const quotaStatement = this.#database.prepare(
             `INSERT INTO quota_buckets (
-           provider_id, id, billing_domain_id, label, used_percent, resets_at, authority, observed_at,
+           provider_id, id, billing_domain_id, label, used_percent, window_duration_minutes,
+           resets_at, authority, observed_at,
            scope, status, limit_amount, limit_currency, fallback_status
-         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
          ON CONFLICT(provider_id, id) DO UPDATE SET
            billing_domain_id = excluded.billing_domain_id,
            label = excluded.label,
            used_percent = excluded.used_percent,
+           window_duration_minutes = excluded.window_duration_minutes,
            resets_at = excluded.resets_at,
            authority = excluded.authority,
            observed_at = excluded.observed_at,
@@ -7064,6 +7856,7 @@ var init_sqlite_usage_repository = __esm({
               bucket.billingDomainId,
               bucket.label,
               bucket.usedPercent,
+              bucket.windowDurationMinutes ?? null,
               bucket.resetsAt,
               bucket.authority,
               snapshot2.observedAt,
@@ -7480,16 +8273,43 @@ var init_sqlite_usage_repository = __esm({
           `SELECT id, display_name, last_success_at, last_error, last_error_code, last_recovery
          FROM providers ORDER BY id`
         ).all();
-        const overviews = providers.map((provider) => this.#getProviderOverview(provider, now, query));
+        const visibleProviders = this.#hideDemoProvider ? providers.filter((provider) => provider.id !== "demo") : providers;
+        const overviews = visibleProviders.map(
+          (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 (
@@ -7565,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;
@@ -7720,6 +8591,13 @@ var init_sqlite_usage_repository = __esm({
           throw error;
         }
       }
+      async deleteDemoProviderDataAsync() {
+        await runDatabaseWorker({
+          databasePath: this.#databasePath,
+          operation: "delete-demo-data",
+          deleteDemoDataSql: DELETE_DEMO_PROVIDER_DATA_SQL
+        });
+      }
       deleteDerivedRetailCosts() {
         this.#database.prepare(DELETE_DERIVED_RETAIL_COSTS_SQL).run();
       }
@@ -7823,7 +8701,8 @@ var init_sqlite_usage_repository = __esm({
       }
       #getBillingDomainOverview(providerId, domain, now, query, forecasts, forecastCoverage, degradedDiagnostic, legacyProviderFailure = null) {
         const quotaRows = this.#database.prepare(
-          `SELECT id, billing_domain_id, label, used_percent, resets_at, authority, observed_at,
+          `SELECT id, billing_domain_id, label, used_percent, window_duration_minutes, resets_at,
+                authority, observed_at,
                 scope, status, limit_amount, limit_currency, fallback_status
          FROM quota_buckets WHERE provider_id = ? AND billing_domain_id = ? ORDER BY id`
         ).all(providerId, domain.id);
@@ -8015,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();
@@ -8238,6 +9212,7 @@ var init_sqlite_usage_repository = __esm({
         billing_domain_id TEXT NOT NULL,
         label TEXT NOT NULL,
         used_percent REAL,
+        window_duration_minutes INTEGER,
         resets_at TEXT,
         authority TEXT NOT NULL,
         observed_at TEXT NOT NULL,
@@ -8422,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")) {
@@ -8581,6 +9569,7 @@ var init_sqlite_usage_repository = __esm({
         for (const [name, type] of [
           ["scope", "TEXT"],
           ["status", "TEXT"],
+          ["window_duration_minutes", "INTEGER"],
           ["limit_amount", "REAL"],
           ["limit_currency", "TEXT"],
           ["fallback_status", "TEXT"]
@@ -8589,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");
+        }
       }
     };
   }
@@ -8606,17 +9599,21 @@ import { isAbsolute as isAbsolute3, join as join8, resolve as resolve3 } from "p
 import { fileURLToPath } from "url";
 async function runDaemon(home) {
   await mkdir4(home, { recursive: true, mode: 448 });
-  const repository = new SqliteUsageRepository(join8(home, "usage.sqlite"));
+  const demoEnabled = process.env.AGENT_USAGE_DEMO === "1";
+  const repository = new SqliteUsageRepository(join8(home, "usage.sqlite"), {
+    hideDemoProvider: !demoEnabled
+  });
   const keychainService = process.env.AGENT_USAGE_KEYCHAIN_SERVICE;
   const launchAgentLabel = process.env.AGENT_USAGE_LAUNCH_AGENT_LABEL;
   const nodeImport = process.env.AGENT_USAGE_NODE_IMPORT;
   const secretStore = new MacOsKeychainSecretStore(void 0, {
     service: keychainService
   });
+  const openCodeLocalHistoryClient = new CliOpenCodeLocalHistoryClient();
   const application = new UsageApplication({
     repository,
     connectors: [
-      ...process.env.AGENT_USAGE_DEMO === "1" ? [createDemoConnector()] : [],
+      ...demoEnabled ? [createDemoConnector()] : [],
       new CodexConnector(
         new StdioCodexAccountClient(),
         void 0,
@@ -8630,8 +9627,9 @@ async function runDaemon(home) {
         accountClient: new OfficialOpenCodeGoClient({
           authReader: new OpenCodeAuthFileReader()
         }),
-        localHistoryClient: new CliOpenCodeLocalHistoryClient()
+        localHistoryClient: openCodeLocalHistoryClient
       }),
+      new OpenCodeLocalConnector({ localHistoryClient: openCodeLocalHistoryClient }),
       new GrokBuildConnector({
         billingClient: new StdioGrokBillingClient(),
         historyClient: localTranscriptClient("grok", home)
@@ -8655,11 +9653,11 @@ async function runDaemon(home) {
         ...keychainService ? { AGENT_USAGE_KEYCHAIN_SERVICE: keychainService } : {},
         ...launchAgentLabel ? { AGENT_USAGE_LAUNCH_AGENT_LABEL: launchAgentLabel } : {},
         ...nodeImport ? { AGENT_USAGE_NODE_IMPORT: nodeImport } : {},
-        ...process.env.AGENT_USAGE_DEMO === "1" ? { AGENT_USAGE_DEMO: "1" } : {}
+        ...demoEnabled ? { AGENT_USAGE_DEMO: "1" } : {}
       }
     }),
     connectorPolicies: Object.fromEntries(
-      ["codex", "claude-code", "opencode-go", "grok", "xai-api"].map((id) => [
+      ["codex", "claude-code", "opencode-go", "opencode", "grok", "xai-api"].map((id) => [
         id,
         { minimumIntervalMs: 5 * 60 * 1e3, timeoutMs: id === "claude-code" ? 25e3 : 2e4 }
       ])
@@ -8687,6 +9685,13 @@ async function runDaemon(home) {
     origin: server.origin,
     apiToken: server.apiToken
   });
+  if (!demoEnabled) {
+    void repository.deleteDemoProviderDataAsync().catch(() => {
+      process.stderr.write(
+        "Agent Usage: stale demo data remains hidden and will be cleaned on a later startup.\n"
+      );
+    });
+  }
   process.stderr.write(`Agent Usage: web service ready at ${server.origin}
 `);
   process.stderr.write("Agent Usage: updating cached usage in the background\u2026\n");
@@ -8788,6 +9793,7 @@ var init_runtime = __esm({
     init_claude_usage_screen_client();
     init_codex_connector();
     init_stdio_codex_account_client();
+    init_opencode_local_connector();
     init_local_opencode_history_client();
     init_official_opencode_go_client();
     init_opencode_auth_reader();