@moneysiren/app 0.1.0-alpha.9

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

@@ -0,0 +1,400 @@
+export const NOTIFICATION_WIDGET_KEYS = [
+    "month_forecast",
+    "today_live_cost",
+    "risk_high_count",
+    "stale_connection_count",
+    "aws_month_forecast",
+    "openai_today_cost",
+    "openai_today_tokens",
+    "claude_five_hour_percent",
+    "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",
+];
+export const LOCAL_CLI_DASHBOARD_METRIC_KEYS = [
+    "context_percent",
+    "last_request_tokens",
+    "total_tokens",
+    "five_hour_limit_percent",
+    "weekly_limit_percent",
+    "five_hour_remaining_tokens",
+    "weekly_remaining_tokens",
+    "usage_reset_credits",
+    "usage_reset_credit_estimate",
+    "context_tokens",
+    "input_tokens",
+    "output_tokens",
+    "cache_tokens",
+    "reasoning_tokens",
+    "sessions",
+    "turns",
+    "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",
+    "risk_high_count",
+    "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",
+        operator: "gte",
+        value: 1,
+        cooldownMinutes: 60,
+    },
+    {
+        widgetKey: "today_live_cost",
+        operator: "gte",
+        value: 10,
+        cooldownMinutes: 180,
+    },
+    {
+        widgetKey: "codex_weekly_percent",
+        operator: "gte",
+        value: 90,
+        cooldownMinutes: 360,
+    },
+];
+export const DEFAULT_NOTIFICATION_PREFERENCES = {
+    enabled: true,
+    digestEnabled: true,
+    digestInterval: "daily",
+    quietHours: {
+        start: "22:00",
+        end: "08:00",
+    },
+    selectedWidgets: DEFAULT_SELECTED_NOTIFICATION_WIDGET_KEYS,
+    thresholdRules: DEFAULT_NOTIFICATION_THRESHOLD_RULES,
+    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,
+        fontScale: 0.95,
+        opacity: 0.94,
+        selectedWidgets: DEFAULT_SELECTED_NOTIFICATION_WIDGET_KEYS,
+    },
+};
+export function parseNotificationPreferences(value) {
+    if (!isRecord(value)) {
+        return cloneNotificationPreferences(DEFAULT_NOTIFICATION_PREFERENCES);
+    }
+    const selectedWidgets = parseSelectedWidgets(value.selectedWidgets);
+    return {
+        enabled: typeof value.enabled === "boolean" ? value.enabled : DEFAULT_NOTIFICATION_PREFERENCES.enabled,
+        digestEnabled: typeof value.digestEnabled === "boolean"
+            ? value.digestEnabled
+            : DEFAULT_NOTIFICATION_PREFERENCES.digestEnabled,
+        digestInterval: parseDigestInterval(value.digestInterval),
+        quietHours: parseQuietHours(value.quietHours),
+        selectedWidgets,
+        thresholdRules: parseThresholdRules(value.thresholdRules),
+        desktopEnabled: typeof value.desktopEnabled === "boolean"
+            ? value.desktopEnabled
+            : DEFAULT_NOTIFICATION_PREFERENCES.desktopEnabled,
+        dashboard: parseDashboardDisplayPreferences(value.dashboard),
+        hud: parseHudPreferences(value.hud, selectedWidgets),
+    };
+}
+export function cloneNotificationPreferences(preferences) {
+    return {
+        enabled: preferences.enabled,
+        digestEnabled: preferences.digestEnabled,
+        digestInterval: preferences.digestInterval,
+        quietHours: {
+            ...preferences.quietHours,
+        },
+        selectedWidgets: [...preferences.selectedWidgets],
+        thresholdRules: preferences.thresholdRules.map((rule) => ({ ...rule })),
+        desktopEnabled: preferences.desktopEnabled,
+        dashboard: parseDashboardDisplayPreferences(preferences.dashboard),
+        hud: parseHudPreferences(preferences.hud),
+    };
+}
+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) {
+    const record = isRecord(value) ? value : {};
+    return {
+        alwaysOnTop: typeof record.alwaysOnTop === "boolean"
+            ? record.alwaysOnTop
+            : DEFAULT_NOTIFICATION_PREFERENCES.hud.alwaysOnTop,
+        fontScale: clampNumber(record.fontScale, 0.8, 1.3, DEFAULT_NOTIFICATION_PREFERENCES.hud.fontScale),
+        opacity: clampNumber(record.opacity, 0, 1, DEFAULT_NOTIFICATION_PREFERENCES.hud.opacity),
+        selectedWidgets: parseSelectedWidgets(record.selectedWidgets, fallbackSelectedWidgets),
+    };
+}
+function parseLocalCliDashboardMetricKeys(value, fallbackMetricKeys = DEFAULT_LOCAL_CLI_DASHBOARD_METRIC_KEYS) {
+    const metricKeys = new Set(LOCAL_CLI_DASHBOARD_METRIC_KEYS);
+    const selected = Array.isArray(value)
+        ? value.filter((item) => typeof item === "string" && metricKeys.has(item))
+        : [...fallbackMetricKeys];
+    return selected.length === 0 ? [...fallbackMetricKeys] : [...new Set(selected)];
+}
+function parseDigestInterval(value) {
+    return value === "six-hours" || value === "daily" || value === "weekly"
+        ? value
+        : DEFAULT_NOTIFICATION_PREFERENCES.digestInterval;
+}
+function parseQuietHours(value) {
+    const record = isRecord(value) ? value : {};
+    return {
+        start: parseTime(record.start, DEFAULT_NOTIFICATION_PREFERENCES.quietHours.start),
+        end: parseTime(record.end, DEFAULT_NOTIFICATION_PREFERENCES.quietHours.end),
+    };
+}
+function parseSelectedWidgets(value, fallbackSelectedWidgets = DEFAULT_SELECTED_NOTIFICATION_WIDGET_KEYS) {
+    const widgetKeys = new Set(NOTIFICATION_WIDGET_KEYS);
+    const selected = Array.isArray(value)
+        ? value.filter((item) => typeof item === "string" && widgetKeys.has(item))
+        : [...fallbackSelectedWidgets];
+    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)) {
+        return DEFAULT_NOTIFICATION_THRESHOLD_RULES.map((rule) => ({ ...rule }));
+    }
+    const rules = value
+        .map((item) => isRecord(item) ? item : null)
+        .filter((item) => item !== null)
+        .map((item) => {
+        const widgetKey = parseWidgetKey(item.widgetKey);
+        const operator = parseOperator(item.operator);
+        const numericValue = parseNonNegativeNumber(item.value);
+        const cooldownMinutes = parseNonNegativeNumber(item.cooldownMinutes);
+        if (widgetKey === null || operator === null || numericValue === null || cooldownMinutes === null) {
+            return null;
+        }
+        return {
+            widgetKey,
+            operator,
+            value: numericValue,
+            cooldownMinutes,
+        };
+    })
+        .filter((item) => item !== null);
+    return rules.length === 0 ? DEFAULT_NOTIFICATION_THRESHOLD_RULES.map((rule) => ({ ...rule })) : rules;
+}
+function parseWidgetKey(value) {
+    return typeof value === "string" && NOTIFICATION_WIDGET_KEYS.includes(value)
+        ? value
+        : null;
+}
+function parseOperator(value) {
+    return value === "gte" || value === "lte" || value === "eq" ? value : null;
+}
+function parseNonNegativeNumber(value) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return null;
+    }
+    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;
+    }
+    return Math.min(max, Math.max(min, Math.round(value * 100) / 100));
+}
+function parseTime(value, fallback) {
+    return typeof value === "string" && /^\d{2}:\d{2}$/.test(value) ? value : fallback;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=notification-preferences-model.js.map

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

@@ -0,0 +1,6 @@
+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_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;
+//# sourceMappingURL=notification-preferences.d.ts.map

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

@@ -0,0 +1,36 @@
+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_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 = {}) {
+    try {
+        const parsed = JSON.parse(await readFile(resolveNotificationPreferencesPath(options), "utf8"));
+        return parseNotificationPreferences(parsed);
+    }
+    catch {
+        return cloneNotificationPreferences(DEFAULT_NOTIFICATION_PREFERENCES);
+    }
+}
+export async function writeNotificationPreferencesFile(preferences, options = {}) {
+    const normalized = parseNotificationPreferences(preferences);
+    const path = resolveNotificationPreferencesPath(options);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${JSON.stringify(normalized, null, 2)}\n`, "utf8");
+    return normalized;
+}
+export function resolveNotificationPreferencesPath(options = {}) {
+    if (options.path !== undefined && options.path.trim().length > 0) {
+        return resolveLocalPath(options.path, options.cwd);
+    }
+    const configuredPath = options.env?.[PREFERENCES_PATH_ENV]?.trim();
+    if (configuredPath !== undefined && configuredPath.length > 0) {
+        return resolveLocalPath(configuredPath, options.cwd);
+    }
+    return resolveLocalPath(DEFAULT_PREFERENCES_PATH, options.cwd);
+}
+function resolveLocalPath(path, cwd = process.cwd()) {
+    return isAbsolute(path) ? path : join(cwd, path);
+}
+//# sourceMappingURL=notification-preferences.js.map

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