Show a daily target for monthly allowances

CHANGELOG.md

@@ -10,6 +10,7 @@
 ## [Windows] Unreleased
 
 - Charts: the Muse token chart, the OpenAI API daily history and the Groq console history keep every day of the 30-day window, so idle days show as zero bars instead of disappearing. Unpriced or incomplete days stay unknown (upstream #4689).
+- Pace: a monthly allowance shows a per-day target, the remaining allowance divided by the local days left including today, in its own unit (credits, requests or %). It appears on the pace line when pace is on, and shows nothing when usage or the reset is unknown or the reset has passed. Notion's credit allowances and FutureAGI's credit and request allowances report their limits (upstream #4692).
 - Overview: disabling a provider, in Settings or from the tray menu, removes its card and account rows at once instead of after a relaunch. claude-swap and tcr Overview rows now fill from a background read during refresh (at most every 5 minutes), so you no longer need to open Settings first.
 - **Claude**: built-in price rows choose one long-context tier per request from input plus all cache tokens and bill the whole request at that tier, as upstream does. Opus 4.6 and Sonnet 4.6 use long-context rates only for usage dated before the upstream cutoff.
 - Tray and Settings: percentages always say "left" or "used" and follow **Show usage as used** (the tray tooltip, tray status rows, the Claude accounts menu and the claude-swap/tcr list). "1 minute ago" is singular in every language. Under **Hide personal information**, Claude and Grok accounts are numbered in list order, and the claude-swap list masks emails as soon as the setting changes.

apps/desktop-tauri/scripts/proof-scenarios.json

@@ -497,6 +497,15 @@
         { "screenshot": "flyout-kimi-bonus-credits", "clip": "panel" }
       ]
     },
+    {
+      "name": "flyout-copilot-daily-target",
+      "query": "window=flyout&fixture=copilot-daily-target&theme=dark",
+      "size": [310, 1032],
+      "steps": [
+        { "expectText": ["Copilot", "Premium", "≈ 2.9% / day to last until reset"] },
+        { "screenshot": "flyout-copilot-daily-target", "clip": "panel" }
+      ]
+    },
     {
       "name": "settings-gemini-usage-source",
       "query": "window=settings&tab=providers:gemini&fixture=default&theme=dark",

apps/desktop-tauri/src-tauri/src/commands/bridge.rs

@@ -59,6 +59,12 @@ pub struct RateWindowSnapshot {
     pub reserve_eta_seconds: Option<f64>,
     #[serde(default)]
     pub pace: Option<pace::WindowPaceSnapshot>,
+    /// Per-day share of a monthly allowance (upstream `monthlyTargetMetrics`).
+    /// Set under the same pace gate as `pace`, but also when the lane has no
+    /// pace (an exhausted allowance). Absent outside monthly windows and when
+    /// usage or the reset is unknown.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub daily_target: Option<pace::DailyTargetSnapshot>,
     /// Set while a longer exhausted pool (Kimi's monthly membership) blocks
     /// this window; presentation only, the raw percentages above stay as is.
     #[serde(default)]
@@ -112,6 +118,7 @@ impl RateWindowSnapshot {
             reserve_will_last_to_reset: false,
             reserve_eta_seconds: None,
             pace: None,
+            daily_target: None,
             monthly_limit_block: None,
             description_is_detail: rw.description_is_detail,
             reset_regenerates: rw.reset_regenerates,
@@ -606,6 +613,9 @@ impl ProviderUsageSnapshot {
                     )
                 })
                 .flatten(),
+            daily_target: allows_pace
+                .then(|| pace::daily_target(Some(id), window, now))
+                .flatten(),
             ..RateWindowSnapshot::from_rate_window(window).with_quota_block(is_blocked, &blocked)
         };
         let primary_snap = lane(

apps/desktop-tauri/src-tauri/src/commands/bridge/pace.rs

@@ -38,6 +38,24 @@ pub struct WindowPaceSnapshot {
     pub reset_window: bool,
 }
 
+/// Remaining allowance divided by the local calendar days left, in the
+/// allowance's own unit (`%`, `credits` or `requests`).
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DailyTargetSnapshot {
+    pub amount: f64,
+    pub unit: String,
+}
+
+impl From<codexbar::core::MonthlyDailyTarget> for DailyTargetSnapshot {
+    fn from(target: codexbar::core::MonthlyDailyTarget) -> Self {
+        Self {
+            amount: target.amount,
+            unit: target.unit,
+        }
+    }
+}
+
 /// Where a window is rendered. Reset-window pace applies to the card's
 /// primary, secondary and tertiary bars only, as on the Mac; extra windows
 /// keep plain lane pace.
@@ -117,6 +135,24 @@ impl WindowPaceSnapshot {
     }
 }
 
+/// Daily target of a monthly window in local calendar days (the Mac uses
+/// `Calendar.current`). Upstream `monthlyTargetMetrics` reads the same
+/// window, so the target never estimates today's consumption. It does not
+/// depend on a lane pace: an exhausted allowance has no pace but still has
+/// a target.
+pub(crate) fn daily_target(
+    id: Option<ProviderId>,
+    window: &RateWindow,
+    now: DateTime<Utc>,
+) -> Option<DailyTargetSnapshot> {
+    let capability = id.map_or(codexbar::core::ProviderPaceCapability::UNSUPPORTED, |id| {
+        id.pace_capability()
+    });
+    capability
+        .monthly_daily_target(window, now, &chrono::Local)
+        .map(DailyTargetSnapshot::from)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -547,6 +583,74 @@ mod tests {
         assert!(!cached.pace_authoritative);
     }
 
+    /// A calendar-month credit allowance carries its daily target on the card
+    /// lane: 200 remaining credits over the 14 local days to the Mar 1 reset.
+    /// Local-day counting varies by zone, so the bound allows one day either way.
+    #[test]
+    fn monthly_credit_allowance_carries_a_daily_target_on_the_card_lane() {
+        let window = monthly(20.0, Some(43_200)).with_quota(250.0, "credits");
+
+        let snap = snapshot_at(ProviderId::Notion, UsageSnapshot::new(window));
+
+        let target = snap.primary.daily_target.expect("daily target");
+        assert_eq!(target.unit, "credits");
+        let days = 200.0 / target.amount;
+        assert!((13.0..=15.0).contains(&days), "{days}");
+    }
+
+    /// An exhausted allowance has no lane pace, but the card still shows its
+    /// target, as upstream computes the target apart from pace.
+    #[test]
+    fn exhausted_monthly_allowance_keeps_a_zero_daily_target_without_pace() {
+        let window = monthly(100.0, Some(43_200)).with_quota(250.0, "credits");
+
+        let snap = snapshot_at(ProviderId::Notion, UsageSnapshot::new(window));
+
+        assert_eq!(snap.primary.pace, None);
+        assert_eq!(
+            snap.primary.daily_target,
+            Some(DailyTargetSnapshot {
+                amount: 0.0,
+                unit: "credits".to_string(),
+            })
+        );
+    }
+
+    #[test]
+    fn weekly_window_has_no_daily_target() {
+        // Reset five days out, inside the seven-day window.
+        let reset = Utc.with_ymd_and_hms(2026, 2, 20, 0, 0, 0).unwrap();
+        let window = RateWindow::with_details(20.0, Some(10_080), Some(reset), None)
+            .with_quota(250.0, "credits");
+
+        let snap = snapshot_at(ProviderId::Notion, UsageSnapshot::new(window));
+
+        assert!(snap.primary.pace.is_some());
+        assert_eq!(snap.primary.daily_target, None);
+    }
+
+    /// A provider that opts out of pace gets no daily target either, so the
+    /// target follows the same pace visibility as the rest of the lane.
+    #[test]
+    fn non_authoritative_monthly_allowance_has_no_daily_target() {
+        let metadata = instantiate_provider(ProviderId::Notion).metadata().clone();
+        let window = monthly(20.0, Some(43_200)).with_quota(250.0, "credits");
+        let result = ProviderFetchResult::new(UsageSnapshot::new(window), "web")
+            .with_non_authoritative_pace();
+
+        let snap = ProviderUsageSnapshot::from_fetch_result_at(
+            ProviderId::Notion,
+            &metadata,
+            &result,
+            None,
+            None,
+            february_now(),
+        );
+
+        assert_eq!(snap.primary.pace, None);
+        assert_eq!(snap.primary.daily_target, None);
+    }
+
     #[test]
     fn exhausted_reset_window_has_no_pace() {
         let usage = UsageSnapshot::new(monthly(100.0, None));

apps/desktop-tauri/src-tauri/src/proof_harness.rs

@@ -627,7 +627,7 @@ fn fill_window_pace(
     now: chrono::DateTime<chrono::Utc>,
     work_days: Option<u8>,
 ) {
-    if w.pace.is_some() || w.is_informational {
+    if (w.pace.is_some() && w.daily_target.is_some()) || w.is_informational {
         return;
     }
     let Some(resets_at) = w
@@ -637,12 +637,19 @@ fn fill_window_pace(
     else {
         return;
     };
-    let window = codexbar::core::RateWindow::with_details(
+    let mut window = codexbar::core::RateWindow::with_details(
         w.used_percent,
         w.window_minutes,
         Some(resets_at.with_timezone(&chrono::Utc)),
         w.reset_description.clone(),
     );
+    window.reset_regenerates = w.reset_regenerates;
+    if w.daily_target.is_none() {
+        w.daily_target = crate::commands::pace::daily_target(id, &window, now);
+    }
+    if w.pace.is_some() {
+        return;
+    }
     w.pace = match id {
         Some(id) => crate::commands::pace::WindowPaceSnapshot::for_lane(
             id,
@@ -979,6 +986,25 @@ mod tests {
         assert!(snapshot.extra_rate_windows[0].window.pace.is_none());
     }
 
+    #[test]
+    fn seed_daily_target_skips_regenerating_windows() {
+        use chrono::TimeZone;
+        let now = chrono::Utc.with_ymd_and_hms(2026, 2, 15, 0, 0, 0).unwrap();
+        let seed = |regenerates: bool| {
+            let json = format!(
+                r#"{{"providerId":"copilot","displayName":"Copilot",
+                "primary":{{"usedPercent":60.0,"resetsAt":"2026-03-01T00:00:00Z",
+                            "resetRegenerates":{regenerates}}}}}"#
+            );
+            let mut snapshot: ProviderUsageSnapshot = serde_json::from_str(&json).unwrap();
+            normalize_seed_snapshot(&mut snapshot);
+            fill_seed_pace(&mut snapshot, now, None);
+            snapshot.primary.daily_target
+        };
+        assert!(seed(false).is_some());
+        assert_eq!(seed(true), None);
+    }
+
     #[test]
     fn seed_pace_keeps_explicit_pace() {
         let json = r#"{"providerId":"codex","displayName":"Codex",

apps/desktop-tauri/src/i18n/keyGroups/core.ts

@@ -249,6 +249,9 @@ export const CORE_LOCALE_KEYS = [
   "PaceInReserve",
   "PaceInDeficit",
   "PaceLastsUntilReset",
+  "PaceDailyTargetPercent",
+  "PaceDailyTargetCredits",
+  "PaceDailyTargetRequests",
   "PaceRunsOutIn",
   "PaceRunsOutNow",
   "PaceProjectedEmptyIn",

apps/desktop-tauri/src/lib/metricRowModel.test.ts

@@ -510,3 +510,58 @@ describe("metricRowPresentation bar", () => {
     ).toBe("63%");
   });
 });
+
+describe("monthly daily target", () => {
+  // A calendar-month allowance on the secondary lane with a synthetic target.
+  function monthly(dailyTarget: RateWindowSnapshot["dailyTarget"]): RateWindowSnapshot {
+    return rateWindow({
+      usedPercent: 79,
+      remainingPercent: 21,
+      windowMinutes: 43_200,
+      pace: pace(),
+      dailyTarget,
+    });
+  }
+
+  it("shows the per-day share when the window has no pace", () => {
+    const snap = { ...monthly({ amount: 0, unit: "%" }), pace: null };
+    expect(metricRowPresentation(input({ lane: "secondary", snap }), en).metaText).toContain(
+      "≈ 0% / day to last until reset",
+    );
+  });
+
+  it("shows a credit allowance's per-day share in the allowance's unit", () => {
+    const row = metricRowPresentation(
+      input({ lane: "secondary", snap: monthly({ amount: 21.0909, unit: "credits" }) }),
+      en,
+    );
+    expect(row.metaText).toContain("≈ 21.09 credits / day to last until reset");
+  });
+
+  it("formats percent, request and unknown units", () => {
+    const text = (dailyTarget: RateWindowSnapshot["dailyTarget"]) =>
+      metricRowPresentation(input({ lane: "secondary", snap: monthly(dailyTarget) }), en).metaText ?? "";
+
+    expect(text({ amount: 2.46, unit: "%" })).toContain("≈ 2.5% / day to last until reset");
+    expect(text({ amount: 10.714, unit: "requests" })).toContain(
+      "≈ 10.71 requests / day to last until reset",
+    );
+    expect(text({ amount: 5, unit: "tokens" })).not.toContain("/ day");
+  });
+
+  it("follows the pace setting and hides on compact rows", () => {
+    const target = { amount: 21.09, unit: "credits" };
+    expect(
+      metricRowPresentation(input({ lane: "secondary", snap: monthly(target), paceEnabled: false }), en)
+        .metaText,
+    ).toBeNull();
+    expect(
+      metricRowPresentation(input({ lane: "secondary", snap: monthly(target), compact: true }), en).metaText,
+    ).toBeNull();
+  });
+
+  it("shows nothing when the window carries no target", () => {
+    const row = metricRowPresentation(input({ lane: "secondary", snap: monthly(null) }), en);
+    expect(row.metaText ?? "").not.toContain("/ day");
+  });
+});

apps/desktop-tauri/src/lib/metricRowModel.ts

@@ -1,6 +1,7 @@
 import { normalizeResetDescription } from "../hooks/useFormattedResetTime";
 import type { LocaleKey } from "../i18n/keys";
 import type {
+  DailyTargetSnapshot,
   PaceStage,
   RateWindowSnapshot,
   WindowPaceSnapshot,
@@ -267,6 +268,26 @@ function paceMetaText(pace: WindowPaceSnapshot, kind: PaceKind, t: Translate): s
   return right ? `${left} · ${right}` : left;
 }
 
+const DAILY_TARGET_KEYS: Record<string, LocaleKey> = {
+  "%": "PaceDailyTargetPercent",
+  credits: "PaceDailyTargetCredits",
+  requests: "PaceDailyTargetRequests",
+};
+
+/**
+ * Upstream `UsagePaceText.dailyTarget`: the per-day share in the allowance's
+ * own unit. Units without a key (for example a currency) show no target.
+ */
+function dailyTargetText(target: DailyTargetSnapshot, t: Translate): string | null {
+  const key = DAILY_TARGET_KEYS[target.unit];
+  if (!key || !Number.isFinite(target.amount)) return null;
+  const digits = target.unit === "%" ? 1 : 2;
+  const amount = new Intl.NumberFormat(intlLocale(t), { maximumFractionDigits: digits }).format(
+    Math.max(0, target.amount),
+  );
+  return fill(t(key), amount);
+}
+
 function normalizedMarkerPercents(values: number[]): number[] {
   const kept: number[] = [];
   for (const value of values.map(clampPercent)) {
@@ -342,6 +363,15 @@ export function metricRowPresentation(input: MetricRowInput, t: Translate): Metr
     input.showResetWhenExhausted && snap.isExhausted && resetTarget > input.now && input.resetText !== null;
   const visible = visiblePace(input);
   const markers = barMarkers(input);
+  // The daily target shares the pace setting and the non-compact meta line.
+  const dailyTarget =
+    input.paceEnabled && !input.compact && snap.dailyTarget
+      ? dailyTargetText(snap.dailyTarget, t)
+      : null;
+  const metaParts = [
+    visible && !input.compact ? paceMetaText(visible.pace, visible.kind, t) : null,
+    dailyTarget,
+  ].filter((part): part is string => part !== null);
   const valuePercent = Math.round(shown);
   const pacePercent =
     visible && PACE_DIRECTION[visible.pace.stage] !== "onPace"
@@ -352,7 +382,7 @@ export function metricRowPresentation(input: MetricRowInput, t: Translate): Metr
       ? null
       : percentLabel(shown, t(showAsUsed ? "PanelUsedSuffix" : "PanelLeftSuffix")),
     resetText: input.compact && !replacesPercent ? null : input.resetText,
-    metaText: visible && !input.compact ? paceMetaText(visible.pace, visible.kind, t) : null,
+    metaText: metaParts.length > 0 ? metaParts.join(" · ") : null,
     bar: {
       fillPercent: renderedFillPercent(shown),
       valuePercent,