@moneysiren/cli 0.1.0-alpha.0 → 0.1.0-alpha.10

package/dist/packages/view-model/src/notification-preferences-model.js

@@ -10,6 +10,8 @@ export const NOTIFICATION_WIDGET_KEYS = [
     "claude_weekly_percent",
     "codex_five_hour_percent",
     "codex_weekly_percent",
+    "codex_reset_credit_count",
+    "codex_reset_credit_expiry",
     "supabase_usage_health",
     "cloudflare_month_to_date",
 ];
@@ -21,6 +23,8 @@ export const LOCAL_CLI_DASHBOARD_METRIC_KEYS = [
     "weekly_limit_percent",
     "five_hour_remaining_tokens",
     "weekly_remaining_tokens",
+    "usage_reset_credits",
+    "usage_reset_credit_estimate",
     "context_tokens",
     "input_tokens",
     "output_tokens",
@@ -31,6 +35,31 @@ export const LOCAL_CLI_DASHBOARD_METRIC_KEYS = [
     "tool_calls",
     "log_files",
 ];
+export const DASHBOARD_VIEW_KEYS = ["overview", "today", "forecast", "risks"];
+export const DASHBOARD_WIDGET_SIZES = ["compact", "normal", "wide", "full"];
+export const DASHBOARD_WIDGET_KEYS_BY_VIEW = {
+    overview: [
+        "overview_meta",
+        "overview_metrics",
+        "overview_trend",
+        "overview_grouping",
+        "overview_services",
+        "overview_insights",
+    ],
+    today: [
+        "today_main",
+        "today_rail",
+    ],
+    forecast: [
+        "forecast_metrics",
+        "forecast_table",
+        "forecast_breakdown",
+    ],
+    risks: [
+        "risks_summary",
+        "risks_table",
+    ],
+};
 export const DEFAULT_SELECTED_NOTIFICATION_WIDGET_KEYS = [
     "month_forecast",
     "today_live_cost",
@@ -38,12 +67,40 @@ export const DEFAULT_SELECTED_NOTIFICATION_WIDGET_KEYS = [
     "stale_connection_count",
     "openai_today_tokens",
     "codex_five_hour_percent",
+    "codex_reset_credit_count",
+    "codex_reset_credit_expiry",
+];
+const LEGACY_SELECTED_NOTIFICATION_WIDGET_KEY_SETS = [
+    [
+        "month_forecast",
+        "today_live_cost",
+        "risk_high_count",
+        "stale_connection_count",
+        "openai_today_tokens",
+        "codex_five_hour_percent",
+    ],
+    [
+        "month_forecast",
+        "today_live_cost",
+        "risk_high_count",
+        "stale_connection_count",
+        "openai_today_tokens",
+        "codex_five_hour_percent",
+        "codex_reset_credit_expiry",
+    ],
 ];
 export const DEFAULT_LOCAL_CLI_DASHBOARD_METRIC_KEYS = [
     "context_percent",
     "last_request_tokens",
     "total_tokens",
+    "usage_reset_credits",
 ];
+export const DEFAULT_DASHBOARD_WIDGET_LAYOUTS = {
+    overview: defaultDashboardWidgetLayout("overview"),
+    today: defaultDashboardWidgetLayout("today"),
+    forecast: defaultDashboardWidgetLayout("forecast"),
+    risks: defaultDashboardWidgetLayout("risks"),
+};
 export const DEFAULT_NOTIFICATION_THRESHOLD_RULES = [
     {
         widgetKey: "risk_high_count",
@@ -77,6 +134,13 @@ export const DEFAULT_NOTIFICATION_PREFERENCES = {
     desktopEnabled: false,
     dashboard: {
         localCliMetricKeys: DEFAULT_LOCAL_CLI_DASHBOARD_METRIC_KEYS,
+        widgetLayouts: DEFAULT_DASHBOARD_WIDGET_LAYOUTS,
+        budget: {
+            monthlyBudgetMinor: null,
+            currency: "USD",
+            warningPercent: 80,
+            criticalPercent: 100,
+        },
     },
     hud: {
         alwaysOnTop: true,
@@ -125,6 +189,84 @@ function parseDashboardDisplayPreferences(value) {
     const record = isRecord(value) ? value : {};
     return {
         localCliMetricKeys: parseLocalCliDashboardMetricKeys(record.localCliMetricKeys),
+        budget: parseDashboardBudgetPreferences(record.budget),
+        widgetLayouts: parseDashboardWidgetLayouts(record.widgetLayouts),
+    };
+}
+function parseDashboardWidgetLayouts(value) {
+    const record = isRecord(value) ? value : {};
+    return {
+        overview: parseDashboardWidgetLayout("overview", record.overview),
+        today: parseDashboardWidgetLayout("today", record.today),
+        forecast: parseDashboardWidgetLayout("forecast", record.forecast),
+        risks: parseDashboardWidgetLayout("risks", record.risks),
+    };
+}
+function parseDashboardWidgetLayout(viewKey, value) {
+    const validWidgetKeys = new Set(DASHBOARD_WIDGET_KEYS_BY_VIEW[viewKey]);
+    const defaults = defaultDashboardWidgetLayout(viewKey);
+    const defaultByKey = new Map(defaults.map((item) => [item.widgetKey, item]));
+    const parsed = Array.isArray(value)
+        ? value
+            .map((item) => {
+            if (!isRecord(item) || typeof item.widgetKey !== "string" || !validWidgetKeys.has(item.widgetKey)) {
+                return null;
+            }
+            const widgetKey = item.widgetKey;
+            const fallback = defaultByKey.get(widgetKey);
+            return {
+                widgetKey,
+                visible: typeof item.visible === "boolean" ? item.visible : fallback?.visible ?? true,
+                size: parseDashboardWidgetSize(item.size, fallback?.size ?? "normal"),
+            };
+        })
+            .filter((item) => item !== null)
+        : [];
+    const seen = new Set();
+    const normalized = parsed.filter((item) => {
+        if (seen.has(item.widgetKey)) {
+            return false;
+        }
+        seen.add(item.widgetKey);
+        return true;
+    });
+    const missing = defaults.filter((item) => !seen.has(item.widgetKey));
+    return [...normalized, ...missing];
+}
+function defaultDashboardWidgetLayout(viewKey) {
+    return DASHBOARD_WIDGET_KEYS_BY_VIEW[viewKey].map((widgetKey) => ({
+        widgetKey,
+        visible: true,
+        size: defaultDashboardWidgetSize(widgetKey),
+    }));
+}
+function defaultDashboardWidgetSize(widgetKey) {
+    if (widgetKey === "overview_metrics" || widgetKey === "overview_services" || widgetKey === "risks_table") {
+        return "full";
+    }
+    if (widgetKey === "today_main" || widgetKey === "forecast_table") {
+        return "wide";
+    }
+    if (widgetKey === "forecast_breakdown" || widgetKey === "today_rail") {
+        return "compact";
+    }
+    return "normal";
+}
+function parseDashboardWidgetSize(value, fallback) {
+    return typeof value === "string" && DASHBOARD_WIDGET_SIZES.includes(value)
+        ? value
+        : fallback;
+}
+function parseDashboardBudgetPreferences(value) {
+    const record = isRecord(value) ? value : {};
+    const monthlyBudgetMinor = parseOptionalPositiveInteger(record.monthlyBudgetMinor);
+    const warningPercent = clampNumber(record.warningPercent, 1, 999, DEFAULT_NOTIFICATION_PREFERENCES.dashboard.budget.warningPercent);
+    const criticalPercent = clampNumber(record.criticalPercent, warningPercent, 999, DEFAULT_NOTIFICATION_PREFERENCES.dashboard.budget.criticalPercent);
+    return {
+        monthlyBudgetMinor,
+        currency: parseCurrency(record.currency, DEFAULT_NOTIFICATION_PREFERENCES.dashboard.budget.currency),
+        warningPercent,
+        criticalPercent,
     };
 }
 function parseHudPreferences(value, fallbackSelectedWidgets = DEFAULT_NOTIFICATION_PREFERENCES.hud.selectedWidgets) {
@@ -162,7 +304,31 @@ function parseSelectedWidgets(value, fallbackSelectedWidgets = DEFAULT_SELECTED_
     const selected = Array.isArray(value)
         ? value.filter((item) => typeof item === "string" && widgetKeys.has(item))
         : [...fallbackSelectedWidgets];
-    return selected.length === 0 ? [...fallbackSelectedWidgets] : [...new Set(selected)];
+    if (selected.length === 0) {
+        return [...fallbackSelectedWidgets];
+    }
+    const uniqueSelected = [...new Set(selected)];
+    return isLegacySelectedWidgetDefault(uniqueSelected)
+        ? [...DEFAULT_SELECTED_NOTIFICATION_WIDGET_KEYS]
+        : migrateSelectedWidgets(uniqueSelected);
+}
+function migrateSelectedWidgets(selectedWidgets) {
+    if (!selectedWidgets.includes("codex_reset_credit_expiry") ||
+        selectedWidgets.includes("codex_reset_credit_count")) {
+        return [...selectedWidgets];
+    }
+    const migrated = [];
+    for (const widgetKey of selectedWidgets) {
+        if (widgetKey === "codex_reset_credit_expiry") {
+            migrated.push("codex_reset_credit_count");
+        }
+        migrated.push(widgetKey);
+    }
+    return migrated;
+}
+function isLegacySelectedWidgetDefault(selectedWidgets) {
+    return LEGACY_SELECTED_NOTIFICATION_WIDGET_KEY_SETS.some((legacySet) => legacySet.length === selectedWidgets.length &&
+        legacySet.every((widgetKey, index) => selectedWidgets[index] === widgetKey));
 }
 function parseThresholdRules(value) {
     if (!Array.isArray(value)) {
@@ -203,6 +369,22 @@ function parseNonNegativeNumber(value) {
     }
     return Math.max(0, value);
 }
+function parseOptionalPositiveInteger(value) {
+    if (value === null || value === undefined || value === "") {
+        return null;
+    }
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+        return null;
+    }
+    return Math.round(value);
+}
+function parseCurrency(value, fallback) {
+    if (typeof value !== "string") {
+        return fallback;
+    }
+    const normalized = value.trim().toUpperCase();
+    return /^[A-Z]{3}$/.test(normalized) ? normalized : fallback;
+}
 function clampNumber(value, min, max, fallback) {
     if (typeof value !== "number" || !Number.isFinite(value)) {
         return fallback;

package/dist/packages/view-model/src/notification-preferences.d.ts

@@ -1,5 +1,5 @@
 import { type NotificationPreferenceFileOptions, type NotificationPreferences } from "./notification-preferences-model.js";
-export { cloneNotificationPreferences, DEFAULT_NOTIFICATION_PREFERENCES, DEFAULT_NOTIFICATION_THRESHOLD_RULES, DEFAULT_LOCAL_CLI_DASHBOARD_METRIC_KEYS, DEFAULT_SELECTED_NOTIFICATION_WIDGET_KEYS, LOCAL_CLI_DASHBOARD_METRIC_KEYS, NOTIFICATION_WIDGET_KEYS, parseNotificationPreferences, type DigestInterval, type DashboardDisplayPreferences, type LocalCliDashboardMetricKey, type NotificationPreferenceFileOptions, type NotificationPreferences, type NotificationThresholdRule, type NotificationWidgetKey, type ThresholdOperator, } from "./notification-preferences-model.js";
+export { cloneNotificationPreferences, DEFAULT_NOTIFICATION_PREFERENCES, DEFAULT_NOTIFICATION_THRESHOLD_RULES, DEFAULT_LOCAL_CLI_DASHBOARD_METRIC_KEYS, DEFAULT_DASHBOARD_WIDGET_LAYOUTS, DEFAULT_SELECTED_NOTIFICATION_WIDGET_KEYS, DASHBOARD_VIEW_KEYS, DASHBOARD_WIDGET_KEYS_BY_VIEW, DASHBOARD_WIDGET_SIZES, LOCAL_CLI_DASHBOARD_METRIC_KEYS, NOTIFICATION_WIDGET_KEYS, parseNotificationPreferences, type DashboardBudgetPreferences, type DashboardDisplayPreferences, type DashboardViewKey, type DashboardWidgetKey, type DashboardWidgetLayoutItem, type DashboardWidgetLayoutPreferences, type DashboardWidgetSize, type DigestInterval, type LocalCliDashboardMetricKey, type NotificationPreferenceFileOptions, type NotificationPreferences, type NotificationThresholdRule, type NotificationWidgetKey, type ThresholdOperator, } from "./notification-preferences-model.js";
 export declare function readNotificationPreferencesFile(options?: NotificationPreferenceFileOptions): Promise<NotificationPreferences>;
 export declare function writeNotificationPreferencesFile(preferences: NotificationPreferences, options?: NotificationPreferenceFileOptions): Promise<NotificationPreferences>;
 export declare function resolveNotificationPreferencesPath(options?: NotificationPreferenceFileOptions): string;

package/dist/packages/view-model/src/notification-preferences.js

@@ -1,7 +1,7 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join } from "node:path";
 import { cloneNotificationPreferences, DEFAULT_NOTIFICATION_PREFERENCES, parseNotificationPreferences, } from "./notification-preferences-model.js";
-export { cloneNotificationPreferences, DEFAULT_NOTIFICATION_PREFERENCES, DEFAULT_NOTIFICATION_THRESHOLD_RULES, DEFAULT_LOCAL_CLI_DASHBOARD_METRIC_KEYS, DEFAULT_SELECTED_NOTIFICATION_WIDGET_KEYS, LOCAL_CLI_DASHBOARD_METRIC_KEYS, NOTIFICATION_WIDGET_KEYS, parseNotificationPreferences, } from "./notification-preferences-model.js";
+export { cloneNotificationPreferences, DEFAULT_NOTIFICATION_PREFERENCES, DEFAULT_NOTIFICATION_THRESHOLD_RULES, DEFAULT_LOCAL_CLI_DASHBOARD_METRIC_KEYS, DEFAULT_DASHBOARD_WIDGET_LAYOUTS, DEFAULT_SELECTED_NOTIFICATION_WIDGET_KEYS, DASHBOARD_VIEW_KEYS, DASHBOARD_WIDGET_KEYS_BY_VIEW, DASHBOARD_WIDGET_SIZES, LOCAL_CLI_DASHBOARD_METRIC_KEYS, NOTIFICATION_WIDGET_KEYS, parseNotificationPreferences, } from "./notification-preferences-model.js";
 const PREFERENCES_PATH_ENV = "MONEYSIREN_NOTIFICATION_PREFS_PATH";
 const DEFAULT_PREFERENCES_PATH = ".moneysiren/notification-preferences.json";
 export async function readNotificationPreferencesFile(options = {}) {

package/dist/packages/view-model/src/sync-state.d.ts

@@ -0,0 +1,47 @@
+export type AggregateSyncStatus = "ok" | "partial" | "stale" | "error" | "empty";
+export type RiskSeverity = "info" | "warning" | "critical";
+export type SyncStateValue = "fresh" | "stale" | "error" | "not_configured" | "unavailable" | "locked";
+export type SyncErrorCode = "not_configured" | "auth_expired" | "permission_denied" | "rate_limited" | "timeout" | "network" | "upstream_unavailable" | "schema_changed" | "invalid_data" | "local_source_missing" | "local_io" | "internal";
+export interface SyncErrorView {
+    code: SyncErrorCode;
+    retryable: boolean;
+    userActionRequired: boolean;
+    message: string;
+}
+export interface ItemSyncView {
+    state: SyncStateValue;
+    observedAt: string | null;
+    lastAttemptAt: string | null;
+    lastSuccessAt: string | null;
+    freshUntil: string | null;
+    staleUntil: string | null;
+    ageSeconds: number | null;
+    source: string;
+    error: SyncErrorView | null;
+    lastRefreshFailed: boolean;
+}
+export declare function createSyncError(code: SyncErrorCode, message?: string): SyncErrorView;
+export declare function syncViewFromFreshness(options: {
+    freshness: "live" | "stale" | "error" | "unavailable" | "not_configured" | "locked";
+    checkedAt: string | null;
+    generatedAt: string;
+    ttlSeconds?: number | null;
+    source: string;
+    message?: string | null;
+    lastAttemptAt?: string | null;
+    lastSuccessAt?: string | null;
+    freshUntil?: string | null;
+    staleUntil?: string | null;
+    lastRefreshFailed?: boolean;
+}): ItemSyncView;
+export declare function summarizeAggregateSync(items: readonly ItemSyncView[]): {
+    status: AggregateSyncStatus;
+    freshCount: number;
+    staleCount: number;
+    errorCount: number;
+    neutralCount: number;
+    lastSuccessAt: string | null;
+};
+export declare function syncStateFromFreshness(freshness: "live" | "stale" | "error" | "unavailable" | "not_configured" | "locked"): SyncStateValue;
+export declare function isNeutralSyncState(state: SyncStateValue): boolean;
+//# sourceMappingURL=sync-state.d.ts.map

package/dist/packages/view-model/src/sync-state.js

@@ -0,0 +1,140 @@
+export function createSyncError(code, message) {
+    return {
+        code,
+        retryable: isRetryableSyncError(code),
+        userActionRequired: isUserActionRequiredSyncError(code),
+        message: sanitizeSyncMessage(message ?? defaultSyncErrorMessage(code)),
+    };
+}
+export function syncViewFromFreshness(options) {
+    const state = syncStateFromFreshness(options.freshness);
+    const observedAt = options.checkedAt;
+    const ageSeconds = observedAt === null
+        ? null
+        : Math.max(0, Math.floor((Date.parse(options.generatedAt) - Date.parse(observedAt)) / 1000));
+    const defaultFreshUntil = observedAt === null || options.ttlSeconds === null || options.ttlSeconds === undefined
+        ? null
+        : new Date(Date.parse(observedAt) + options.ttlSeconds * 1000).toISOString();
+    return {
+        state,
+        observedAt,
+        lastAttemptAt: options.lastAttemptAt ?? observedAt,
+        lastSuccessAt: options.lastSuccessAt ?? (state === "error" ? null : observedAt),
+        freshUntil: options.freshUntil ?? defaultFreshUntil,
+        staleUntil: options.staleUntil ?? null,
+        ageSeconds: Number.isFinite(ageSeconds) ? ageSeconds : null,
+        source: options.source,
+        error: state === "error" || state === "locked" || state === "not_configured"
+            ? createSyncError(errorCodeFromState(state, options.message), options.message ?? undefined)
+            : null,
+        lastRefreshFailed: options.lastRefreshFailed ?? state === "error",
+    };
+}
+export function summarizeAggregateSync(items) {
+    const actionable = items.filter((item) => !isNeutralSyncState(item.state));
+    const freshCount = actionable.filter((item) => item.state === "fresh").length;
+    const staleCount = actionable.filter((item) => item.state === "stale").length;
+    const errorCount = actionable.filter((item) => item.state === "error" || item.state === "locked").length;
+    const neutralCount = items.length - actionable.length;
+    const lastSuccessAt = latestIso(items.map((item) => item.lastSuccessAt).filter((value) => value !== null));
+    const status = actionable.length === 0
+        ? "empty"
+        : errorCount > 0 && (freshCount > 0 || staleCount > 0)
+            ? "partial"
+            : errorCount === actionable.length
+                ? "error"
+                : freshCount > 0 && staleCount > 0
+                    ? "partial"
+                    : staleCount === actionable.length
+                        ? "stale"
+                        : "ok";
+    return {
+        status,
+        freshCount,
+        staleCount,
+        errorCount,
+        neutralCount,
+        lastSuccessAt,
+    };
+}
+export function syncStateFromFreshness(freshness) {
+    if (freshness === "live") {
+        return "fresh";
+    }
+    if (freshness === "not_configured" || freshness === "unavailable" || freshness === "locked") {
+        return freshness;
+    }
+    return freshness;
+}
+export function isNeutralSyncState(state) {
+    return state === "not_configured" || state === "unavailable";
+}
+function errorCodeFromState(state, message) {
+    if (state === "not_configured") {
+        return "not_configured";
+    }
+    if (state === "locked") {
+        return "local_io";
+    }
+    if (message !== undefined && message !== null) {
+        const normalized = message.toLowerCase();
+        if (normalized.includes("permission") || normalized.includes("403")) {
+            return "permission_denied";
+        }
+        if (normalized.includes("401") || normalized.includes("expired")) {
+            return "auth_expired";
+        }
+        if (normalized.includes("429") || normalized.includes("rate limit")) {
+            return "rate_limited";
+        }
+        if (normalized.includes("timeout")) {
+            return "timeout";
+        }
+        if (normalized.includes("network") || normalized.includes("enotfound") || normalized.includes("econn")) {
+            return "network";
+        }
+    }
+    return "internal";
+}
+function isRetryableSyncError(code) {
+    return code === "rate_limited" || code === "timeout" || code === "network" || code === "upstream_unavailable";
+}
+function isUserActionRequiredSyncError(code) {
+    return code === "not_configured" ||
+        code === "auth_expired" ||
+        code === "permission_denied" ||
+        code === "local_source_missing" ||
+        code === "local_io";
+}
+function defaultSyncErrorMessage(code) {
+    if (code === "auth_expired") {
+        return "Login may have expired. Sign in again and retry.";
+    }
+    if (code === "permission_denied") {
+        return "Permission is not sufficient for this read-only check.";
+    }
+    if (code === "not_configured" || code === "local_source_missing") {
+        return "Local source or credential is not configured.";
+    }
+    if (code === "rate_limited") {
+        return "Provider request limit was reached. Retry later.";
+    }
+    if (code === "schema_changed") {
+        return "Provider response shape changed.";
+    }
+    return "Live sync failed.";
+}
+function sanitizeSyncMessage(value) {
+    return value
+        .replace(/https:\/\/hooks\.slack\.com\/services\/[A-Za-z0-9/_-]+/g, "[redacted]")
+        .replace(/\b(?:sk|sbp|xox[baprs])[-_][A-Za-z0-9_-]+\b/gi, "[redacted]")
+        .replace(/\bacct[_-][A-Za-z0-9_-]+\b/gi, "[redacted]")
+        .replace(/\b(?:proj|project|invoice)[_-][A-Za-z0-9_-]+\b/gi, "[redacted]")
+        .replace(/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/gi, "[redacted]");
+}
+function latestIso(values) {
+    return values.length === 0
+        ? null
+        : [...values].sort((first, second) => second.localeCompare(first))[0] ?? null;
+}
+//# sourceMappingURL=sync-state.js.map

package/dist/packages/view-model/src/usage-progress.d.ts

@@ -0,0 +1,22 @@
+export interface UsageProgressView {
+    usedPercent: number | null;
+    remainingPercent: number | null;
+    warningAtPercent: number;
+    criticalAtPercent: number;
+}
+export type UsageProgressSeverity = "info" | "warning" | "critical";
+export declare function usageProgressFromUsedPercent(value: number | null | undefined, thresholds?: {
+    warningAtPercent?: number;
+    criticalAtPercent?: number;
+}): UsageProgressView;
+export declare function usageProgressFromRemainingPercent(value: number | null | undefined, thresholds?: {
+    warningAtPercent?: number;
+    criticalAtPercent?: number;
+}): UsageProgressView;
+export declare function usageProgressFromTokens(usedTokens: number | null | undefined, remainingTokens: number | null | undefined, thresholds?: {
+    warningAtPercent?: number;
+    criticalAtPercent?: number;
+}): UsageProgressView;
+export declare function usageProgressSeverity(progress: UsageProgressView): UsageProgressSeverity;
+export declare function normalizePercent(value: number | null | undefined): number | null;
+//# sourceMappingURL=usage-progress.d.ts.map

package/dist/packages/view-model/src/usage-progress.js

@@ -0,0 +1,57 @@
+const DEFAULT_WARNING_AT_PERCENT = 80;
+const DEFAULT_CRITICAL_AT_PERCENT = 95;
+export function usageProgressFromUsedPercent(value, thresholds = {}) {
+    const usedPercent = normalizePercent(value);
+    const warningAtPercent = thresholds.warningAtPercent ?? DEFAULT_WARNING_AT_PERCENT;
+    const criticalAtPercent = thresholds.criticalAtPercent ?? DEFAULT_CRITICAL_AT_PERCENT;
+    return {
+        usedPercent,
+        remainingPercent: usedPercent === null ? null : clampPercent(100 - usedPercent),
+        warningAtPercent,
+        criticalAtPercent,
+    };
+}
+export function usageProgressFromRemainingPercent(value, thresholds = {}) {
+    const remainingPercent = normalizePercent(value);
+    const warningAtPercent = thresholds.warningAtPercent ?? DEFAULT_WARNING_AT_PERCENT;
+    const criticalAtPercent = thresholds.criticalAtPercent ?? DEFAULT_CRITICAL_AT_PERCENT;
+    return {
+        usedPercent: remainingPercent === null ? null : clampPercent(100 - remainingPercent),
+        remainingPercent,
+        warningAtPercent,
+        criticalAtPercent,
+    };
+}
+export function usageProgressFromTokens(usedTokens, remainingTokens, thresholds = {}) {
+    const used = normalizeNonNegativeNumber(usedTokens);
+    const remaining = normalizeNonNegativeNumber(remainingTokens);
+    if (used === null || remaining === null) {
+        return usageProgressFromUsedPercent(null, thresholds);
+    }
+    const total = used + remaining;
+    return usageProgressFromUsedPercent(total <= 0 ? null : (used / total) * 100, thresholds);
+}
+export function usageProgressSeverity(progress) {
+    if (progress.usedPercent === null) {
+        return "info";
+    }
+    if (progress.usedPercent >= progress.criticalAtPercent) {
+        return "critical";
+    }
+    if (progress.usedPercent >= progress.warningAtPercent) {
+        return "warning";
+    }
+    return "info";
+}
+export function normalizePercent(value) {
+    return value === null || value === undefined || !Number.isFinite(value)
+        ? null
+        : clampPercent(value);
+}
+function normalizeNonNegativeNumber(value) {
+    return value === null || value === undefined || !Number.isFinite(value) || value < 0 ? null : value;
+}
+function clampPercent(value) {
+    return Math.max(0, Math.min(100, Number(value.toFixed(2))));
+}
+//# sourceMappingURL=usage-progress.js.map

package/dist/packages/view-model/src/view-model.d.ts

@@ -112,6 +112,15 @@ export interface TodayLiveProviderInput {
     providerKey: string;
     displayName: string;
     checkedAt: string | null;
+    expiresAt?: string | null;
+    ttlSeconds?: number;
+    lastAttemptAt?: string | null;
+    lastSuccessAt?: string | null;
+    freshUntil?: string | null;
+    staleUntil?: string | null;
+    lastRefreshFailed?: boolean;
+    revision?: number;
+    message?: string;
     freshness: "live" | "stale" | "error" | "unavailable" | "not_configured" | "locked";
     confidence: "high" | "medium" | "low" | "none";
     todayLiveAmountMinor: number | null;
@@ -126,6 +135,11 @@ export interface TodayLiveMetric {
     key: string;
     value: number;
     unit: string;
+    resetAt?: string;
+    resetAtLatest?: string;
+    itemKey?: string;
+    accuracy?: "exact" | "estimated" | "bounded" | "unknown";
+    source?: string;
 }
 export interface NotificationDigest extends LocalSafeEnvelope {
     title: string;
@@ -139,6 +153,14 @@ export interface NotificationDigestItem {
     severity: ViewModelRiskSeverity;
     label: string;
     value: string;
+    numericValue?: number;
+    unit?: string;
+    usedPercent?: number;
+    remainingPercent?: number;
+    resetAt?: string;
+    resetAtLatest?: string;
+    providerKey?: string;
+    accuracy?: "exact" | "estimated" | "bounded" | "unknown";
     freshness?: TodayLiveProviderView["freshness"];
     confidence?: TodayLiveProviderView["confidence"];
     clickPath?: string;