nguyenphutrong/quotio

Quotio is a macOS application that aggregates and monitors usage quotas for various AI providers, including Claude, Codex, and GitHub Copilot. It manages user accounts, CLI agent configurations, and proxy lifecycles through a layered architecture backed by a Rust-based CLI host. The system also supports companion device pairing for iPhone sharing and provides a native menu bar interface for real-time quota visibility.

Added domain models, an infrastructure service, and a presentation model to manage the Cloudflare Tunnel lifecycle. The new \CloudflaredService\ detects the \cloudflared\ binary, starts and stops the tunnel process, and parses the public URL from its output. The \TunnelScreenModel\ exposes the tunnel's state (idle, starting, active, stopping, error) and installation status to the UI, allowing users to start, stop, and monitor the tunnel's health.

Packages/QuotioCore/Sources/QuotioDomain/Tunnel, Packages/QuotioCore/Sources/QuotioInfrastructure/Tunnel, Packages/QuotioCore/Sources/QuotioPresentation/Tunnel · high confidence

This change adds the Quotio CLI infrastructure layer, which now serves as the primary backend for managing accounts, coordinating quota refreshes, and handling companion device sharing. The new \QuotioCLIBackend\ actor communicates with the Rust host via HTTP (v2 API) to discover native sources, authorize keychain access, and fetch quota snapshots, replacing previous direct storage mechanisms. A new \QuotioCLILegacyAccountMigration\ actor handles the import of existing accounts from local JSON metadata and the Codex Keychain, ensuring a smooth transition for existing users. Additionally, \QuotioCompanionService\ enables iPhone pairing and LAN/Tailscale sharing controls, while \QuotioCLIServerProcess\ manages the lifecycle of the embedded CLI helper binary. This shift centralizes account and quota logic in the CLI, allowing the UI to remain thin and focused on presentation.

Packages/QuotioCore/Sources/QuotioInfrastructure/QuotioCLI · high confidence

The app now features a new Dashboard screen that provides a high-level overview of configured providers, the lowest remaining quota percentage, and the last refresh time, while highlighting providers that need attention (failed, partial, or outdated status). Quota details are presented via a redesigned ProviderQuotaView that merges accounts from auth files and quota data, supports both 'used' and 'remaining' display modes with distinct color coding, and groups metrics for clearer readability. The underlying QuotaScreenModel and QuotaFeatureController manage state, refresh cycles, and provider settings, ensuring that quota data is accurately reflected and updated.

Packages/QuotioCore/Sources/QuotioPresentation/Quota · high confidence

This change introduces the core application-layer services for managing custom API providers and automating model warmup. It adds \CustomProviderService\ to handle the lifecycle (create, save, delete, validate) of custom provider configurations, including logic to normalize base URLs for OpenAI-compatible endpoints. Additionally, it implements the \WarmupSchedulerService\ and \ProxyWarmupExecutor\ to automatically schedule and execute warmup requests against Google's Antigravity API, ensuring models are primed according to configurable cadences and daily minute limits. The warmup executor includes specific model alias mappings for preview versions of Gemini and Claude models.

Packages/QuotioCore/Sources/QuotioApplication/Warmup · high confidence

The companion service now supports connecting via local network, Tailscale, or proxy, allowing users to pair iPhones over these networks. New domain models define connection endpoints, network addresses, and device pairing credentials, enabling simultaneous LAN and Tailscale sharing while managing device access and expiration.

Packages/QuotioCore/Sources/QuotioDomain/Companion · high confidence

Added a new set of protocols in the application layer to define cross-cutting concerns, including logging, time, URL opening, clipboard access, notifications, and lifecycle management. This establishes a standardized interface for these system interactions within the application's architecture.

Packages/QuotioCore/Sources/QuotioApplication/Ports · high confidence

The domain layer now models accounts as a composite of an identity and multiple login sources, allowing a single account to maintain several authentication methods (such as native credentials, API keys, or legacy proxies) simultaneously. This change introduces new domain types like \AccountLoginSource\ and \AccountIdentity\ to track the status, capabilities, and credential metadata of each source independently, while also adding support for custom API providers (e.g., OpenAI, Claude, Gemini) with specific configuration options like model mapping and custom headers.

Packages/QuotioCore/Sources/QuotioDomain/Accounts · high confidence

This change adds a new infrastructure layer for managing CLI agents (Claude Code, Codex CLI, Amp, OpenCode, and FactoryDroid). It introduces \AgentDetectionAdapter\ to automatically discover installed agent binaries and their configuration status, and \AgentFileStore\ to safely read, write, and backup agent configuration files with rollback support. Specific configuration adapters are provided for each agent to inspect, preview, apply, and reset settings in their respective config files (JSON, TOML) and shell profiles, along with \AgentModelCatalogHTTPAdapter\ to fetch available models from a proxy and \CopilotAvailableModelCatalog\ to retrieve GitHub Copilot model IDs.

Packages/QuotioCore/Sources/QuotioInfrastructure/Agents · high confidence

This change adds the initial iOS application and WidgetKit extensions, establishing the native iPhone companion for Quotio. The app connects to a local host via HTTPS with delegated read credentials, supporting direct LAN and Tailscale pairing modes. It features a dedicated design system with shared tokens for consistent UI across the app and widgets, including components like quota bars, tiles, and connection status indicators. The implementation includes account detail screens with usage analytics, privacy-focused account name blurring, and support for multiple widget families to display quota and usage data directly on the home screen.

apps/ios · high confidence

The Quotio macOS interface now includes dedicated screens for managing API keys (with generation, editing, and deletion), configuring CLI agents (with installation status and setup flows), and organizing provider connections (grouping accounts by provider and supporting native login rescans). An updated About screen displays version/build info and links, while the Dashboard adapts to local proxy and quota-only modes, and the Quota screen provides a unified view of usage with filtering and display customization.

Packages/QuotioCore/Sources/QuotioPresentation/Screens · high confidence

The CLI now persists provider usage data to disk via a new \UsageCache\ (apps/cli/src/cache.rs), allowing the local HTTP server (apps/cli/src/server.rs) to serve cached usage reports without immediate provider fetches. This is supported by a new TOML configuration system (apps/cli/src/config.rs) for managing provider enablement, cache TTL, and refresh intervals, alongside a new v2 API contract (apps/cli/src/contract.rs) for structured account and usage snapshots. The CLI also gains new commands for managing companion devices and LAN/Tailscale sharing (apps/cli/src/devices.rs), enabling read-only access for other local tools.

apps/cli/src · high confidence

The proxy subsystem now includes explicit lifecycle state management (idle, starting, active, stopping, downloading, testing, promoting, rolling back) with strict transition rules enforced by a state machine. New domain models define proxy endpoints, status, version information (including SHA256 and download URLs), and usage statistics. Authentication file management is modeled with detailed provider-specific lookup keys and status tracking. Proxy failure modes are explicitly enumerated (binary not found, startup failed, network errors, checksum mismatches, etc.) and notifications for crashes, upgrades, and rollbacks are standardized.

Packages/QuotioCore/Sources/QuotioDomain/Proxy · high confidence

The application now includes a new \TunnelLifecycleController\ and associated protocols (\TunnelControlling\, \TunnelRemoteAccessControlling\, \TunnelLifecycleControlling\) to manage the Cloudflare tunnel's state. This controller handles starting, stopping, and monitoring the tunnel, including automatic restart attempts with configurable timeouts and delays. It exposes the tunnel's status via an \AsyncStream\ of snapshots, allowing the UI to react to changes in the tunnel's connection state.

Packages/QuotioCore/Sources/QuotioApplication/Tunnel · high confidence

This change adds the core domain types that define how Quotio manages AI agent setups and model discovery. It introduces \CLIAgent\ and \AgentConfigType\ to structure configuration for agents like Claude Code, Codex CLI, and OpenCode, specifying whether they use environment variables or config files. It also defines \CodexReasoningEffort\ to handle Codex's reasoning levels, including a \custom\ case for unknown values, and \AvailableModel\ to represent models available for routing. Additionally, it adds \ModelCatalog\ and \ModelCatalogState\ to parse and display the live list of models from the proxy's \/v1/models\ endpoint, ensuring the UI accurately reflects whether the catalog is live, stale, or unavailable.

Packages/QuotioCore/Sources/QuotioDomain/Agents · high confidence

This change adds new infrastructure for persisting application state and managing custom AI providers. It introduces a layered architecture for preferences, moving storage from a single flat structure to dedicated repositories for operating mode, menu bar settings, refresh/warmup schedules, and provider tracking, including migrations for legacy macOS provider IDs. It also adds support for custom providers, allowing users to configure and persist third-party API endpoints via YAML files or local storage, with logic to serialize, deserialize, and manage these configurations. Additionally, it implements secure, atomic file writing for account metadata and snapshots, and introduces repositories for managing proxy configuration, versioning, and authentication files.

Packages/QuotioCore/Sources/QuotioInfrastructure/Persistence · high confidence

This change adds a new set of platform adapter implementations for macOS within the QuotioInfrastructure package, enabling native integration with the operating system. Users benefit from proper handling of system features including URL opening, clipboard access, launch-at-login registration, application appearance (light/dark mode), dock visibility, and icon updates for beta channels via AppKit. The update also introduces a new logging mechanism using OSLog, a memory-managed image cache for provider assets, and a Sparkle-based adapter for application update checking. Additionally, it implements the UserNotificationCenterAdapter to deliver localized system notifications for quota limits, account cooling, and proxy lifecycle events (start, crash, upgrade, rollback), alongside the GitHubAtomProxyUpdateFeed to check for CLIProxyAPI updates via Atom feeds with caching support.

Packages/QuotioCore/Sources/QuotioInfrastructure/Platform · high confidence

This change adds new platform-layer components in QuotioCore that manage core macOS application behaviors. The ApplicationUpdateController handles update checking, channel switching (stable/beta), and icon updates. The LaunchAtLoginController manages the app's login item registration and provides a path to system settings. The NotificationController centralizes notification logic, including authorization requests, preference storage, and deduplication of specific alerts like quota warnings and proxy status changes. These controllers are backed by new domain models (snapshots) and protocol-based ports to decouple platform specifics from the core domain logic.

Packages/QuotioCore/Sources/QuotioApplication/Platform, Packages/QuotioCore/Sources/QuotioDomain/Platform · high confidence

Added \snapshot.rs\ and \summary.rs\ to the CLI contract layer to define how usage data is projected onto resolved accounts and how quota metrics are summarized for clients. The snapshot module handles mapping provider usage reports to account sources, including logic for external refresh sources and handling of provider errors, while the summary module computes session and combined quota totals and pairs metrics (such as Session/Weekly or Daily/Weekly) for specific providers like Claude, Codex, and Cursor.

apps/cli/src/contract · high confidence

The CLI now includes a complete set of scripts to build, sign, and package the application for distribution. This adds macOS code signing and notarization (via \ci-sign-macos.sh\ and \sign-macos.sh\), an npm launcher (\distribution/npm/bin/quotio.cjs\) that bundles native binaries for macOS and Linux, and a release packaging script (\package-release.py\) that generates Homebrew formulae and npm tarballs. It also introduces dependency security scanning against OSV advisories (\check-advisories.py\) and automated generation of third-party license notices (\third-party-notices.py\).

apps/cli/scripts · high confidence

The CLI now exposes a comprehensive account management system via a new API layer in \apps/cli/src/accounts\. Users can add, list, use, and remove accounts through explicit commands, supporting both API keys and native credential sources (such as GitHub Keychain, Claude Code, and Factory) discovered automatically by the host. The system introduces a new \AccountDto\ for structured account data and supports patching account properties like labels and enabled status. Security is enhanced with a new encrypted file backend for headless Linux environments, allowing vault storage with a separate master key file or file descriptor. Additionally, a migration module allows importing legacy Quotio monitor credentials, and a companion TLS identity system enables secure local network communication for the CLI.

apps/cli/src/accounts · high confidence

A new \scripts/dev\ shell script has been added to centralize local development workflows. This tool provides a unified interface for running the CLI application, building and launching the macOS app, and managing iOS simulator and device builds. It also supports running tests for the CLI, macOS, and iOS targets, allowing developers to easily manage and test the application across all supported platforms from a single entry point.

scripts · high confidence

The application now exposes a \CompanionControlling\ protocol that defines the interface for managing iPhone companion devices. This interface allows the system to check connection status, configure network settings (including local network or Tailscale), retrieve paired devices, and issue or revoke pairing permissions, laying the groundwork for the new iPhone pairing and sharing controls.

Packages/QuotioCore/Sources/QuotioApplication/Companion · high confidence

The CLI now includes a local HTTP server that exposes a versioned v2 API for account management, native source discovery, and companion sharing. Users can discover and register native credentials (e.g., Grok, Copilot, ClinePass) via the /v2/sources/discover endpoint, manage accounts and sources through /v2/accounts and /v2/sources, and control read-only companion access over local network or Tailscale via the sharing module. The server enforces strict security policies, including HMAC-based authentication, idempotency keys for mutations, and owner-only restrictions for sensitive operations, and publishes its OpenAPI contract at /openapi.json.

apps/cli/src/server · high confidence

The Accounts infrastructure now supports authenticating via a local proxy CLI for Copilot and Kiro providers, replacing or supplementing previous methods. This introduces a new \LocalProxyOAuthAuthorizer\ that manages the authorization lifecycle, including browser-based flows for Copilot and specific device-code or import flows for Kiro. A new \ProcessProxyCLIAuthenticator\ handles the execution of the proxy CLI commands, capturing output to extract device codes and reporting standardized authentication statuses. Additionally, a \FileAntigravityAuthWorkaround\ component automatically patches local authentication configuration files to point to the correct Google API base URL, ensuring seamless integration with the proxy.

Packages/QuotioCore/Sources/QuotioInfrastructure/Accounts · high confidence

Added shell scripts to streamline macOS development and distribution: \build\_and\_run.sh\ builds the Debug app and launches it with optional debugging, logging, or verification modes; \build\_dmg.sh\ handles Release builds, including version bumping, Developer ID signing, Apple notarization, and DMG/ZIP artifact creation when distribution credentials are provided; \build\_cli\_helper.sh\ compiles the Rust CLI helper, creates a universal binary, signs it, and embeds it into the app bundle; and \check\_architecture.sh\ enforces layering rules and prevents legacy code from persisting in the codebase.

apps/macos/scripts · high confidence

The onboarding experience has been replaced with a structured, multi-step wizard that guides users through connecting providers, managing native source permissions, and configuring quota monitoring. The flow includes a welcome screen, a provider connection step for OAuth and API key setup, an access step for resolving permission requests, and a completion step that summarizes connected providers and allows toggling the menu bar quota display. This change introduces new presentation components (OnboardingFlow, AccessStep, CompletionStep, ProviderStep, WelcomeStep) and supporting models (OnboardingProviderOverview, OnboardingViewModel) to manage the state and navigation of this guided setup process.

Packages/QuotioCore/Sources/QuotioPresentation/Onboarding · high confidence

The CLI now includes dedicated provider adapters for Amp, Antigravity, and Codex, enabling the tool to fetch and display usage quotas and account details for these services. The Amp adapter parses local CLI output to present usage windows and balances, while the Antigravity adapter supports both API-based quota fetching and local service discovery on macOS to read subscription metadata and usage limits. The Codex adapter integrates with the local application server and external API to report session and weekly rate limits, alongside extra usage credits. These adapters are registered in the provider capabilities system, exposing specific actions like API key addition and native source discovery to the user.

apps/cli/src/providers · high confidence

The CLI now includes a comprehensive provider catalog in \apps/cli/src/providers/catalog\ that automatically discovers and fetches usage data for a wide range of AI providers. This new module adds support for Azure OpenAI (via Cost Management), balance-based providers like DeepSeek and Moonshot, coding plan providers such as Alibaba and Warp, infrastructure providers like Fireworks and Groq, and gateway aggregators including LiteLLM and OpenAI organization usage. It also introduces native credential handling for Devin Desktop and secure SQLite WAL reading for Cursor login recovery, along with a shared \common\ module for standardized usage parsing and a test suite for file-safety guarantees.

apps/cli/src/providers/catalog · high confidence

This change introduces the presentation-layer components for managing API providers, including the ProvidersScreenModel for handling custom provider CRUD operations and validation, and the WarpTokenScreenModel for managing Warp authentication tokens. It also adds ConnectionPresentation and CustomProviderPresentation files that define user-facing labels, error messages, icons, and colors for various native and custom provider types, ensuring consistent localization and visual feedback in the UI.

Packages/QuotioCore/Sources/QuotioPresentation/Providers · high confidence

The CLI now includes dedicated output modules for rendering usage data. A new \text.rs\ module provides a human-readable report that displays provider usage, account details, quota limits (including unlimited, disabled, and unknown states), reset credits, and any provider failures, while safely stripping control characters from provider metadata. A new \json.rs\ module serializes the internal snapshot contract into pretty-printed JSON. These changes replace or supplement previous output mechanisms by introducing structured rendering for both consumption metrics and error states.

apps/cli/src/output · high confidence

The macOS app is now available as a standalone product in the apps/macos/Quotio directory, featuring a native SwiftUI interface for managing provider accounts, monitoring usage quotas, and handling onboarding flows. Users can pair iPhones to share quota data over local networks or Tailscale, with the app managing device access, pairing codes, and connection settings directly from the main window. The application includes built-in auto-updates via Sparkle, supports multiple languages, and requires macOS 14.0 or later.

apps/macos/Quotio · high confidence

The shared presentation layer now centralizes how AI providers and account sources are displayed. For each supported provider (such as Claude, Codex, and GitHub Copilot), the system defines specific display names, SF Symbols, logo asset names, brand colors, menu bar icons, and OAuth endpoints, ensuring consistent visual identity across the app. Additionally, account sources (like Quotio Keychain or Local IDE) now have localized display names, and the \Color\ type includes a hex initializer to support these brand colors.

Packages/QuotioCore/Sources/QuotioPresentation/Shared · high confidence

The default \ContentView\ and \QuotioApp\ entry point files have been removed from the Quotio module. This eliminates the boilerplate "Hello, world!" SwiftUI window that was previously the application's main interface, indicating that the app's UI structure is being redefined or replaced by other components.

Quotio · high confidence

The application now uses a new \AgentConfigurationService\ actor to manage agent setup, detection, and shell profile integration, replacing the previous monolithic or legacy structure. This change introduces a clean architecture with explicit protocols (\AgentConfigurationRepository\, \AgentDetecting\, \ShellProfileRepository\, \AgentModelCatalogRepository\) that decouple the service logic from specific implementations. Users benefit from a more robust and testable configuration flow for CLI agents, including improved handling of shell profile updates and model catalog interactions.

Packages/QuotioCore/Sources/QuotioApplication/Agents · high confidence

The QuotioCore package now defines a layered architecture consisting of Domain, Application, Infrastructure, and Presentation modules. Each layer is represented by a dedicated module file that declares its name and explicit dependencies on other layers (e.g., Infrastructure depends on both Application and Domain), establishing the foundational structure for the application's code organization.

(repo-wide) · high confidence

The Agent Setup screen now presents user-facing text through a localization system rather than hardcoded English strings. Configuration instructions, error messages, and connection status updates for agents like Claude Code, Codex CLI, and OpenCode are now pulled from localized bundles, ensuring they adapt to the user's language settings. Additionally, the interface displays clear, human-readable display names, descriptions, and icons for each supported CLI agent, along with descriptive labels for configuration modes (Automatic/Manual) and model slots (Opus, Sonnet, Haiku), improving clarity during the agent configuration process.

Packages/QuotioCore/Sources/QuotioPresentation/Agents · high confidence

The app now uses a dedicated \LanguageManager\ to handle localization, ensuring all state updates occur on the main actor to prevent concurrency issues. When a user changes their language preference, the system automatically updates the localization bundle and notifies observers, providing a consistent and thread-safe experience for switching between English, Vietnamese, Chinese, and French.

Packages/QuotioCore/Sources/QuotioPresentation/Resources · high confidence

The Antigravity account switcher now handles token refresh failures and machine identity sync errors more gracefully, ensuring that switch operations can be rolled back safely if they fail midway. Additionally, token refresh logic has been updated to handle cases where the expiry time is unknown, preventing potential authentication issues during account switches.

Packages/QuotioCore/Sources/QuotioInfrastructure/Antigravity · high confidence

The Lifecycle module now includes concrete infrastructure implementations for core lifecycle primitives. ContinuousSleeper provides the Sleeping protocol by wrapping async task sleeping, and SystemDateProvider provides the DateProviding protocol by returning the current system date, enabling the application to manage time-based operations and date access through these new infrastructure components.

Packages/QuotioCore/Sources/QuotioInfrastructure/Lifecycle · high confidence

This change restructures the proxy logging system into a layered architecture, introducing a domain model (LogEntry with automatic level detection), application use cases (loading with retention policies and clearing), and an infrastructure client (ManagementAPIClient) that fetches and clears logs via a management API. On the presentation side, a new SwiftUI LogsScreen allows users to view, search, and filter logs by level (info, warn, error, debug), with auto-scrolling, manual refresh, and clear functionality.

(repo-wide) · high confidence

The application's settings management has been restructured into a layered architecture. This change introduces a new \MonitoringSettingsManaging\ protocol to handle monitoring provider configurations and establishes a comprehensive set of typed preference repositories (e.g., \ProviderTrackingPreferencesRepository\, \ProxyPreferencesRepository\, \AppShellPreferencesRepository\) to manage specific user preferences such as appearance, language, notifications, and proxy settings.

Packages/QuotioCore/Sources/QuotioApplication/Settings · high confidence

The Settings domain has been restructured into a layered architecture, introducing new domain models to manage configuration and state more explicitly. This includes \MonitoringProvider\ and \MonitoringSettings\ to handle provider-specific monitoring configurations, \ProviderTrackingPreferences\ to manage provider enablement and login discovery, and \OperatingModePreferences\ to replace the previous operating mode selection with a simplified monitor/local proxy choice. Additionally, \PreferenceValues\ now defines granular preferences for the menu bar (including quota display modes, styles, and color themes), refresh cadences, and warmup intervals, providing a more structured foundation for user settings.

Packages/QuotioCore/Sources/QuotioDomain/Settings · high confidence

The QuotioHostClient package now provides a native Swift implementation for communicating with the Rust host, replacing previous transport mechanisms. It introduces a new discovery protocol that allows the client to independently scan for and register host sources, and adds support for companion device status and revocation via dedicated API endpoints. Security is strengthened by enforcing HTTPS for remote connections, rejecting plaintext HTTP for non-loopback hosts, and validating TLS connections against specific paired trust anchors rather than system defaults. The client also decodes a comprehensive v2 snapshot containing account, source, and quota metrics, along with supplemental usage data like reset credits and subscription status, ensuring type-safe and validated data exchange with the host.

Packages/QuotioHostClient · high confidence

The Quota domain layer now uses explicit Swift structs and enums to represent quota data, replacing previous ad-hoc or opaque representations. QuotaProvider defines supported AI providers (e.g., claude, codex, cursor) with specific capabilities such as quota-only tracking, browser-based auth, CLI usage, and API-key auth. QuotaMetric and QuotaMetricPresentation model usage metrics with units (usd, credits, requests, searches) and presentation modes (progress, amount, status). QuotaRefreshState and QuotaRefreshFailureReason standardize refresh outcomes and error reasons. Additionally, WarpToken models named, enabled/disabled API tokens. These changes provide a consistent, type-safe foundation for quota tracking and display across the app.

Packages/QuotioCore/Sources/QuotioDomain/Quota · high confidence

The Accounts module now uses a new layered architecture that separates account metadata, credential storage, and authentication logic. Users benefit from automatic discovery of native login sources (such as macOS Keychain entries) and the ability to authorize or manage these sources directly within the app. The new AccountService and CredentialVault handle credential persistence with generation-based conflict resolution, while the OAuthFlowController and OperatingModeOAuthAuthorizer manage authentication states, supporting both monitor and local-proxy modes. This change also introduces explicit handling for auth file sources and provider-specific settings, allowing users to see which accounts need identification or re-authentication and to trigger rescans of native logins.

Packages/QuotioCore/Sources/QuotioApplication/Accounts · high confidence

This change introduces new Swift types and protocols in the Quota package to support a layered architecture for quota management. Specifically, it adds \AccountMonitoringState\ to track individual account connection and refresh status, and \QuotaSnapshot\ to aggregate provider names, account states, quotas, subscriptions, and refresh issues into a single view. It also defines \QuotaPorts.swift\, which contains the \QuotaCoordinating\ protocol for managing quota operations (bootstrap, refresh, cancel) and request structures like \QuotaFetchRequest\ and \QuotaRefreshIssue\. Additionally, a \WarpTokenRepository\ protocol is added to abstract token persistence. These changes provide the structural foundation for the new quota state management and monitoring capabilities.

Packages/QuotioCore/Sources/QuotioApplication/Quota · high confidence

The credentials infrastructure now automatically migrates protected credentials previously stored in YubiKey envelopes to the standard macOS Keychain. Existing users will see their legacy YubiKey-protected secrets read once and then saved to the new Keychain service, after which the system stops writing to the YubiKey vault. This migration is transparent and preserves access to existing credentials while retiring the legacy hardware-backed write path.

Packages/QuotioCore/Sources/QuotioInfrastructure/Credentials · high confidence

The Accounts presentation layer now uses new, dedicated screen models to manage account state, native source permissions, and credential flows. AccountsScreenModel handles core account lifecycle actions (reload, scan, authorize, delete, rename) and tracks native discovery states. AntigravityAccountScreenModel manages the specific logic for switching Antigravity IDE accounts and handling switch failures. OAuthScreenModel encapsulates the OAuth authorization flow state. Additionally, WarmupScreenModel manages the background warmup scheduling and settings for accounts. These changes reflect a migration to a layered architecture where the UI layer interacts with specific service abstractions for accounts, OAuth, and warmup tasks.

Packages/QuotioCore/Sources/QuotioPresentation/Accounts · high confidence

The proxy presentation layer now uses dedicated screen models to manage the proxy lifecycle and configuration. ProxyScreenModel exposes the proxy's operational state (running status, port, version info, upgrade availability) and handles actions like starting, stopping, toggling, and managing binary versions. ProxyManagementScreenModel coordinates the broader management context, including account and OAuth states, tunnel preferences, and quota refresh settings. It manages the connection to the CLIProxyAPI management interface, fetching and syncing authentication files, usage statistics, and API keys, while handling errors and configuration updates such as proxy URLs and routing strategies.

Packages/QuotioCore/Sources/QuotioPresentation/Proxy · high confidence

The proxy management system has been refactored to use a layered architecture, introducing a new \ProxyLifecycleController\ that coordinates process control, version management, and configuration via explicit protocols (defined in \ProxyPorts.swift\). This change centralizes the proxy's state machine and health monitoring, while a new \ProxyUpdatePollingController\ handles periodic upgrade checks and notification delivery. Users benefit from more robust proxy startup, health recovery, and update notification flows, with the management API and configuration logic now clearly separated from the core lifecycle logic.

Packages/QuotioCore/Sources/QuotioApplication/Proxy · high confidence

The proxy infrastructure now handles GitHub API rate limits gracefully. When fetching release information (latest, specific tag, or list) via the API fails due to rate limiting (HTTP 429 or 403 with remaining=0), the system automatically falls back to parsing the corresponding GitHub web pages to retrieve the release tags and details. This ensures that proxy version checks continue to work even when the GitHub API is throttled, preventing update failures for users.

Packages/QuotioCore/Sources/QuotioInfrastructure/HTTP · high confidence

The macOS app has been reorganized into a new \Quotio/App\ module, introducing a dedicated \AppDelegate\ and \AppRuntime\ to manage the application lifecycle, window visibility, and status bar integration. This change includes a new \AppIdentity\ system that migrates user preferences and keychain credentials from legacy bundle identifiers (\dev.quotio.desktop\, \proseek.io.vn.Quotio\) to the production identity (\app.bytrong.quotio\), ensuring seamless continuity for existing users. The app now supports accessory mode (hiding from the Dock) while correctly promoting to regular mode when the main window is activated, and it handles clean shutdowns by managing proxy cleanup and OAuth sessions.

apps/macos/Quotio/App · high confidence

The macOS menu bar interface has been rebuilt to use a native NSMenu with SwiftUI hosting views, providing a more integrated Liquid Glass appearance and improved multi-monitor support. Users can now pair iPhones directly from the menu bar via a new companion popover, and quota metrics are rendered with native tooltips and provider-specific filtering. The display logic has been refined to show only enabled quota accounts, separate extra usage from host metric groups, and preserve host-resolved plan names, while settings for refresh cadence and appearance are now persisted and applied consistently.

Packages/QuotioCore/Sources/QuotioPresentation/MenuBar · high confidence

The Settings screen has been reorganized to group accounts by provider, displaying login sources and connection status within expandable rows. Users can now manage Keychain access, pin accounts to the menu bar, and handle authentication issues directly from the list. A new Companion section allows pairing iPhones over local network or Tailscale, generating QR codes for secure connection setup. The About page now includes version copying and update controls, while the Proxy settings page manages CLIProxyAPI installation and configuration.

Packages/QuotioCore/Sources/QuotioPresentation/Settings · high confidence

The macOS settings interface has been reorganized to center around provider management. A new sidebar navigation structure now distinguishes between provider-related accounts (displayed via the 'Providers' section) and general application settings (such as General, Proxy, and Notifications). This change introduces a dedicated navigation model that manages state between the provider list and specific account details, allowing users to select a provider to view its associated settings and quota information, while maintaining access to global app preferences in a separate section.

Packages/QuotioCore/Sources/QuotioPresentation/App · high confidence

The presentation layer has been restructured to consolidate account display and provider management. A new unified AccountRow component replaces previous specialized rows, supporting proxy, direct, auto-detected, and monitor sources with specific capabilities like disable, edit, and switch actions. The interface now includes an empty state view for new users, a grid-based popover for adding providers (including IDE scanning and custom providers), and dedicated sheets for configuring CLI agents and custom API providers (such as GLM). Additionally, a sidebar mode badge provides quick access to settings based on the current operating mode.

Packages/QuotioCore/Sources/QuotioPresentation/Components · high confidence

The macOS Quotio project has been moved to the apps/macos directory and reconfigured to embed the Quotio CLI helper binary into the application bundle. The project now includes a dedicated QuotioTests target for unit testing, references local Swift packages (QuotioCore), and adds localization support for Vietnamese and Simplified Chinese alongside existing languages.

apps/macos/Quotio.xcodeproj · high confidence

Added integration and unit tests for CLI cache, collection, and server management; Added presentation-layer tests for account, companion, and agent setup screens; Added tests for account persistence, agent configuration, and infrastructure components; Added tests for app identity, runtime lifecycle, and localization; Added unit tests for QuotioDomain models and configuration; Added unit tests for application core services and state management.

The project now includes the initial dependency configuration files for its core components. The Rust-based CLI (apps/cli) is defined with Cargo.toml and Cargo.lock, specifying dependencies such as axum 0.8, rustls 0.23, and clap 4, and targeting Rust edition 2024. Swift package manifests (Package.swift) and resolved lock files (Package.resolved) are added for the QuotioCore, QuotioHostClient, and QuotioMobile packages, establishing a shared host client dependency and pinning the Sparkle update framework to version 2.8.1 for macOS and iOS targets.

(dependencies) · high confidence

The per-user scheme management file (xcschememanagement.plist) has been deleted from the repository. This change ensures that individual developer settings, such as scheme order hints, are no longer tracked in version control, preventing unnecessary merge conflicts and keeping the project configuration clean for all collaborators.

Quotio.xcodeproj · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 49 → 74 (+25.3)
• Rubric changed (rubric-2026.09.11 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 90 → 89 (-0.4)
• Architecture 98 → 92 (-6.2)
• Maturity 65 → 66 (+1.1)
• Readiness 50 → 70 (+19.7)
• Security 30 → 89 (+59.0)
• Domain Modelling 95 → 100 (+5.2)
• Performance 100 (new)

• AccountSelectionPolicy.mergingQuotaAccounts (cognitive 20) (Packages/QuotioCore/Sources/QuotioDomain/Accounts/AccountModels.swift)
• AmpQuotaFetcher.fetch (cognitive 16) (Packages/QuotioCore/Sources/QuotioInfrastructure/Quota/AmpQuotaFetcher.swift)
• AmpQuotaFetcher.parse (cognitive 29) (Packages/QuotioCore/Sources/QuotioInfrastructure/Quota/AmpQuotaFetcher.swift)
• AmpQuotaFetcher.parse (cyclomatic 28) (Packages/QuotioCore/Sources/QuotioInfrastructure/Quota/AmpQuotaFetcher.swift)
• AntigravityQuotaFetcher.fetchModels (cognitive 25) (Packages/QuotioCore/Sources/QuotioInfrastructure/Quota/AntigravityQuotaFetcher.swift)
• Change coupling: DashboardScreen.swift ↔ SettingsScreen.swift (Packages/QuotioCore/Sources/QuotioPresentation/Screens/DashboardScreen.swift)
• ClassTooLong: CompositionRoot (Quotio/App/CompositionRoot.swift)
• ClassTooLong: DashboardScreen (Packages/QuotioCore/Sources/QuotioPresentation/Screens/DashboardScreen.swift)
• ClaudeDesktopCredentialReader.activeOrganization (cognitive 21) (Packages/QuotioCore/Sources/QuotioInfrastructure/Quota/ClaudeDesktopCredentialReader.swift)
• ClaudeDesktopCredentialReader.bestCredential (cognitive 17) (Packages/QuotioCore/Sources/QuotioInfrastructure/Quota/ClaudeDesktopCredentialReader.swift)
• CodexQuotaFetcher.mapUsage (cognitive 38) (Packages/QuotioCore/Sources/QuotioInfrastructure/Quota/CodexQuotaFetcher.swift)
• CodexQuotaFetcher.mapUsage (cyclomatic 18) (Packages/QuotioCore/Sources/QuotioInfrastructure/Quota/CodexQuotaFetcher.swift)
• CompositeCodexQuotaCredentialLoader.credentials (cognitive 31) (Packages/QuotioCore/Sources/QuotioInfrastructure/Quota/CompositeCodexQuotaCredentialLoader.swift)
• CompositeCodexQuotaCredentialLoader.credentials (cyclomatic 20) (Packages/QuotioCore/Sources/QuotioInfrastructure/Quota/CompositeCodexQuotaCredentialLoader.swift)
• CopilotQuotaFetcher.fetch (cognitive 25) (Packages/QuotioCore/Sources/QuotioInfrastructure/Quota/CopilotQuotaFetcher.swift)
• CopilotQuotaFetcher.fetch (cyclomatic 18) (Packages/QuotioCore/Sources/QuotioInfrastructure/Quota/CopilotQuotaFetcher.swift)
• CopilotQuotaFetcher.map (cognitive 16) (Packages/QuotioCore/Sources/QuotioInfrastructure/Quota/CopilotQuotaFetcher.swift)
• DevinQuotaFetcher.tomlString (cognitive 27) (Packages/QuotioCore/Sources/QuotioInfrastructure/Quota/DevinQuotaFetcher.swift)
• DevinQuotaFetcher.tomlString (cyclomatic 19) (Packages/QuotioCore/Sources/QuotioInfrastructure/Quota/DevinQuotaFetcher.swift)
• Documentation: no architecture or design documentation (README.md)
• …and 99 more

• AccountQuotaCardV2.accountHeader (cognitive 35) (Packages/QuotioCore/Sources/QuotioPresentation/Quota/ProviderQuotaView.swift)
• AccountQuotaCardV2.accountHeader (cyclomatic 23) (Packages/QuotioCore/Sources/QuotioPresentation/Quota/ProviderQuotaView.swift)
• AccountRow.body (cognitive 33) (Packages/QuotioCore/Sources/QuotioPresentation/Components/AccountRow.swift)
• AccountRow.body (cyclomatic 29) (Packages/QuotioCore/Sources/QuotioPresentation/Components/AccountRow.swift)
• AccountsSettingsScreen.body (cognitive 26) (Packages/QuotioCore/Sources/QuotioPresentation/Settings/AccountsSettingsScreen.swift)
• AccountsSettingsScreen.body (cyclomatic 27) (Packages/QuotioCore/Sources/QuotioPresentation/Settings/AccountsSettingsScreen.swift)
• AppSettingsPage.body (cognitive 21) (Packages/QuotioCore/Sources/QuotioPresentation/Settings/AppSettingsPage.swift)
• AppSettingsPage.body (cyclomatic 16) (Packages/QuotioCore/Sources/QuotioPresentation/Settings/AppSettingsPage.swift)
• Boundary-crossing change coupling: RootNavigationView.swift ↔ CompositionRoot.swift (Packages/QuotioCore/Sources/QuotioPresentation/App/RootNavigationView.swift)
• Boundary-crossing change coupling: StatusBarManager.swift ↔ QuotioApp.swift (Packages/QuotioCore/Sources/QuotioPresentation/MenuBar/StatusBarManager.swift)
• Change coupling: QuotaCard.swift ↔ QuotaScreen.swift (Packages/QuotioCore/Sources/QuotioPresentation/Components/QuotaCard.swift)
• Change coupling: QuotioCLIBackend.swift ↔ AccountsScreenModel.swift (Packages/QuotioCore/Sources/QuotioInfrastructure/QuotioCLI/QuotioCLIBackend.swift)
• Change coupling: QuotioCLIBackend.swift ↔ QuotioCLIServerProcess.swift (Packages/QuotioCore/Sources/QuotioInfrastructure/QuotioCLI/QuotioCLIBackend.swift)
• Change coupling: config.rs ↔ tests.rs (apps/cli/src/config.rs)
• CompanionConnectionSetupView.body (cognitive 18) (Packages/QuotioCore/Sources/QuotioPresentation/Settings/CompanionConnectionSetupView.swift)
• Coverage not measured — Swift suite
• DisplayNames.metricLabel (cognitive 16) (apps/ios/Sources/QuotioMobile/DisplayNames.swift)
• DisplayNames.resetHint (cognitive 16) (apps/ios/Sources/QuotioMobile/DisplayNames.swift)
• Duplicated block (10 lines × 2) (Packages/QuotioCore/Sources/QuotioPresentation/Components/AgentConfigSheet.swift)
• Duplicated block (10 lines × 2) (Packages/QuotioCore/Sources/QuotioPresentation/MenuBar/StatusBarMenuRenderer.swift)
• …and 129 more

• 300 commits — 148 feature/other, 152 fixes

• apps/cli — 145 commits
• Packages/QuotioCore — 101 commits
• apps/macos — 18 commits
• apps/ios — 14 commits
• .github/workflows — 11 commits
• (root) — 7 commits
• Packages/QuotioHostClient — 3 commits
• .codex/environments — 1 commit

• fix: fix(accounts): classify originless helper accounts as native
• fix: fix(accounts): continue discovery after a native source fails
• fix: fix(accounts): display fetched labels for local providers
• fix: fix(accounts): group matching login sources
• fix: fix(accounts): honor disable capability in monitor rows
• fix: fix(accounts): honor native source suppression during quota collection
• fix: fix(accounts): keep custom provider references read-only
• fix: fix(accounts): keep every login source under one account identity
• fix: fix(accounts): keep local Warp mirrors read-only
• fix: fix(accounts): preserve disabled helper accounts during deduplication
• fix: fix(accounts): preserve independent Antigravity local selection
• fix: fix(accounts): preserve provider settings during key rotation
• fix: fix(accounts): reconcile usage by identity and omit failed probes
• fix: fix(accounts): register only verified native sources
• fix: fix(accounts): resume provider naming after an explicit label reset
• fix: fix(accounts): retain failed borrowed accounts in monitor
• fix: fix(accounts): retain first-refresh identity and native profile names
• fix: fix(accounts): retain refresh lineage after concurrent removal
• fix: fix(accounts): retry native discovery and isolate source failures
• fix: fix(accounts): scope native permissions to their source location
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

nguyenphutrong/quotio was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.