@sriinnu/runic 1.0.0

package/Tests/RunicTests/PathBuilderTests.swift

@@ -0,0 +1,237 @@
+import RunicCore
+import Foundation
+import Testing
+@testable import Runic
+
+@Suite
+struct PathBuilderTests {
+    @Test
+    func mergesLoginShellPathWhenAvailable() {
+        let seeded = PathBuilder.effectivePATH(
+            purposes: [.rpc],
+            env: ["PATH": "/custom/bin:/usr/bin"],
+            loginPATH: ["/login/bin", "/login/alt"])
+        #expect(seeded == "/login/bin:/login/alt:/custom/bin:/usr/bin")
+    }
+
+    @Test
+    func fallsBackToExistingPathWhenNoLoginPath() {
+        let seeded = PathBuilder.effectivePATH(
+            purposes: [.tty],
+            env: ["PATH": "/custom/bin:/usr/bin"],
+            loginPATH: nil)
+        #expect(seeded == "/custom/bin:/usr/bin")
+    }
+
+    @Test
+    func usesFallbackWhenNoPathAvailable() {
+        let seeded = PathBuilder.effectivePATH(
+            purposes: [.tty],
+            env: [:],
+            loginPATH: nil)
+        #expect(seeded == "/usr/bin:/bin:/usr/sbin:/sbin")
+    }
+
+    @Test
+    func resolvesCodexFromEnvOverride() {
+        let overridePath = "/custom/bin/codex"
+        let fm = MockFileManager(executables: [overridePath])
+
+        let resolved = BinaryLocator.resolveCodexBinary(
+            env: ["CODEX_CLI_PATH": overridePath],
+            loginPATH: nil,
+            fileManager: fm,
+            home: "/home/test")
+        #expect(resolved == overridePath)
+    }
+
+    @Test
+    func resolvesCodexFromLoginPath() {
+        let fm = MockFileManager(executables: ["/login/bin/codex"])
+        let resolved = BinaryLocator.resolveCodexBinary(
+            env: ["PATH": "/env/bin"],
+            loginPATH: ["/login/bin"],
+            fileManager: fm,
+            home: "/home/test")
+        #expect(resolved == "/login/bin/codex")
+    }
+
+    @Test
+    func resolvesCodexFromEnvPath() {
+        let fm = MockFileManager(executables: ["/env/bin/codex"])
+        let resolved = BinaryLocator.resolveCodexBinary(
+            env: ["PATH": "/env/bin:/usr/bin"],
+            loginPATH: nil,
+            fileManager: fm,
+            home: "/home/test")
+        #expect(resolved == "/env/bin/codex")
+    }
+
+    @Test
+    func resolvesCodexFromInteractiveShell() {
+        let fm = MockFileManager(executables: ["/shell/bin/codex"])
+        let commandV: (String, String?, TimeInterval, FileManager) -> String? = { tool, shell, timeout, fileManager in
+            #expect(tool == "codex")
+            #expect(shell == "/bin/zsh")
+            #expect(timeout == 2.0)
+            _ = fileManager
+            return "/shell/bin/codex"
+        }
+
+        let resolved = BinaryLocator.resolveCodexBinary(
+            env: ["SHELL": "/bin/zsh"],
+            loginPATH: nil,
+            commandV: commandV,
+            fileManager: fm,
+            home: "/home/test")
+        #expect(resolved == "/shell/bin/codex")
+    }
+
+    @Test
+    func resolvesClaudeFromInteractiveShell() {
+        let fm = MockFileManager(executables: ["/shell/bin/claude"])
+        let commandV: (String, String?, TimeInterval, FileManager) -> String? = { tool, shell, timeout, fileManager in
+            #expect(tool == "claude")
+            #expect(shell == "/bin/zsh")
+            #expect(timeout == 2.0)
+            _ = fileManager
+            return "/shell/bin/claude"
+        }
+
+        let resolved = BinaryLocator.resolveClaudeBinary(
+            env: ["SHELL": "/bin/zsh"],
+            loginPATH: nil,
+            commandV: commandV,
+            fileManager: fm,
+            home: "/home/test")
+        #expect(resolved == "/shell/bin/claude")
+    }
+
+    @Test
+    func resolvesGeminiFromInteractiveShell() {
+        let fm = MockFileManager(executables: ["/shell/bin/gemini"])
+        let commandV: (String, String?, TimeInterval, FileManager) -> String? = { tool, shell, timeout, fileManager in
+            #expect(tool == "gemini")
+            #expect(shell == "/bin/zsh")
+            #expect(timeout == 2.0)
+            _ = fileManager
+            return "/shell/bin/gemini"
+        }
+
+        let resolved = BinaryLocator.resolveGeminiBinary(
+            env: ["SHELL": "/bin/zsh"],
+            loginPATH: nil,
+            commandV: commandV,
+            fileManager: fm,
+            home: "/home/test")
+        #expect(resolved == "/shell/bin/gemini")
+    }
+
+    @Test
+    func resolvesClaudeFromLoginPath() {
+        let fm = MockFileManager(executables: ["/login/bin/claude"])
+        let resolved = BinaryLocator.resolveClaudeBinary(
+            env: ["PATH": "/env/bin"],
+            loginPATH: ["/login/bin"],
+            fileManager: fm,
+            home: "/home/test")
+        #expect(resolved == "/login/bin/claude")
+    }
+
+    @Test
+    func resolvesClaudeFromAliasWhenOtherLookupsFail() {
+        let aliasPath = "/home/test/.claude/local/bin/claude"
+        let fm = MockFileManager(executables: [aliasPath])
+        var aliasCalled = false
+        let aliasResolver: (String, String?, TimeInterval, FileManager, String)
+            -> String? = { tool, shell, timeout, _, home in
+                aliasCalled = true
+                #expect(tool == "claude")
+                #expect(shell == "/bin/zsh")
+                #expect(timeout == 2.0)
+                #expect(home == "/home/test")
+                return aliasPath
+            }
+        let commandV: (String, String?, TimeInterval, FileManager) -> String? = { _, _, _, _ in
+            nil
+        }
+
+        let resolved = BinaryLocator.resolveClaudeBinary(
+            env: ["SHELL": "/bin/zsh"],
+            loginPATH: nil,
+            commandV: commandV,
+            aliasResolver: aliasResolver,
+            fileManager: fm,
+            home: "/home/test")
+
+        #expect(aliasCalled)
+        #expect(resolved == aliasPath)
+    }
+
+    @Test
+    func resolvesCodexFromAliasWhenOtherLookupsFail() {
+        let aliasPath = "/home/test/.codex/bin/codex"
+        let fm = MockFileManager(executables: [aliasPath])
+        var aliasCalled = false
+        let aliasResolver: (String, String?, TimeInterval, FileManager, String)
+            -> String? = { tool, shell, timeout, _, home in
+                aliasCalled = true
+                #expect(tool == "codex")
+                #expect(shell == "/bin/zsh")
+                #expect(timeout == 2.0)
+                #expect(home == "/home/test")
+                return aliasPath
+            }
+        let commandV: (String, String?, TimeInterval, FileManager) -> String? = { _, _, _, _ in
+            nil
+        }
+
+        let resolved = BinaryLocator.resolveCodexBinary(
+            env: ["SHELL": "/bin/zsh"],
+            loginPATH: nil,
+            commandV: commandV,
+            aliasResolver: aliasResolver,
+            fileManager: fm,
+            home: "/home/test")
+
+        #expect(aliasCalled)
+        #expect(resolved == aliasPath)
+    }
+
+    @Test
+    func skipsAliasWhenCommandVResolves() {
+        let path = "/shell/bin/claude"
+        let fm = MockFileManager(executables: [path])
+        var aliasCalled = false
+        let aliasResolver: (String, String?, TimeInterval, FileManager, String) -> String? = { _, _, _, _, _ in
+            aliasCalled = true
+            return "/alias/claude"
+        }
+        let commandV: (String, String?, TimeInterval, FileManager) -> String? = { _, _, _, _ in
+            path
+        }
+
+        let resolved = BinaryLocator.resolveClaudeBinary(
+            env: ["SHELL": "/bin/zsh"],
+            loginPATH: nil,
+            commandV: commandV,
+            aliasResolver: aliasResolver,
+            fileManager: fm,
+            home: "/home/test")
+
+        #expect(!aliasCalled)
+        #expect(resolved == path)
+    }
+}
+
+private final class MockFileManager: FileManager {
+    private let executables: Set<String>
+
+    init(executables: Set<String>) {
+        self.executables = executables
+    }
+
+    override func isExecutableFile(atPath path: String) -> Bool {
+        self.executables.contains(path)
+    }
+}

package/Tests/RunicTests/ProviderFetchPipelineTests.swift

@@ -0,0 +1,160 @@
+import Foundation
+import Testing
+@testable import RunicCore
+
+@Suite
+struct ProviderFetchPipelineTests {
+    private struct SlowStrategy: ProviderFetchStrategy {
+        let id: String
+        let kind: ProviderFetchKind = .api
+        let shouldFallbackValue: Bool
+
+        func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+            true
+        }
+
+        func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+            while true {
+                try await Task.sleep(for: .milliseconds(10))
+            }
+        }
+
+        func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+            self.shouldFallbackValue
+        }
+    }
+
+    private struct FailingStrategy: ProviderFetchStrategy {
+        let id: String = "provider.fetchPipeline.fail"
+        let kind: ProviderFetchKind = .api
+        let error: Error
+        let fallback: Bool
+
+        func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+            true
+        }
+
+        func fetch(_: ProviderFetchContext) async throws -> ProviderFetchResult {
+            throw self.error
+        }
+
+        func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+            self.fallback
+        }
+    }
+
+    private struct FastSuccessStrategy: ProviderFetchStrategy {
+        let id: String = "provider.fetchPipeline.success"
+        let kind: ProviderFetchKind = .api
+        let result: ProviderFetchResult
+
+        func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+            true
+        }
+
+        func fetch(_: ProviderFetchContext) async throws -> ProviderFetchResult {
+            self.result
+        }
+
+        func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+            false
+        }
+    }
+
+    private final class DummyClaudeFetcher: ClaudeUsageFetching, @unchecked Sendable {
+        func loadLatestUsage(model: String) async throws -> ClaudeUsageSnapshot {
+            throw URLError(.unsupportedURL)
+        }
+
+        func debugRawProbe(model: String) async -> String {
+            ""
+        }
+
+        func detectVersion() -> String? {
+            nil
+        }
+    }
+
+    private func makeContext() -> ProviderFetchContext {
+        ProviderFetchContext(
+            runtime: .app,
+            sourceMode: .auto,
+            includeCredits: false,
+            webTimeout: 60,
+            webDebugDumpHTML: false,
+            verbose: false,
+            env: [:],
+            settings: nil,
+            fetcher: UsageFetcher(environment: [:]),
+            claudeFetcher: DummyClaudeFetcher())
+    }
+
+    @Test
+    func hangsAreConvertedToStrategyTimeout() async {
+        let pipeline = ProviderFetchPipeline(
+            resolveStrategies: { _ in [SlowStrategy(id: "provider.fetchPipeline.hang", shouldFallbackValue: false)] },
+            strategyTimeout: 0.05)
+        let outcome = await pipeline.fetch(context: self.makeContext(), provider: .kimi)
+
+        #expect(!outcome.attempts.isEmpty)
+        #expect(outcome.attempts.count == 1)
+        #expect(outcome.attempts[0].strategyID == "provider.fetchPipeline.hang")
+        #expect(outcome.attempts[0].wasAvailable == true)
+
+        guard case .failure(let error) = outcome.result else {
+            Issue.record("Expected fetch failure")
+            return
+        }
+        guard case let .strategyTimeout(provider, strategyID, timeoutSeconds) = error as? ProviderFetchError else {
+            Issue.record("Expected strategy timeout error")
+            return
+        }
+        #expect(provider == .kimi)
+        #expect(strategyID == "provider.fetchPipeline.hang")
+        #expect(timeoutSeconds == 0.05)
+    }
+
+    @Test
+    func strategyFallbackStillHonorsOrder() async {
+        let expected = Self.makeStubResult()
+        let pipeline = ProviderFetchPipeline(
+            resolveStrategies: { _ in [
+                FailingStrategy(error: URLError(.timedOut), fallback: true),
+                FastSuccessStrategy(result: expected),
+            ] },
+            strategyTimeout: 1)
+
+        let outcome = await pipeline.fetch(context: self.makeContext(), provider: .kimi)
+        let result = try? outcome.result.get()
+
+        #expect(result?.strategyID == expected.strategyID)
+        #expect(result?.strategyKind == expected.strategyKind)
+        #expect(result?.sourceLabel == expected.sourceLabel)
+        #expect(result?.usage.primary.resetDescription == expected.usage.primary.resetDescription)
+        #expect(outcome.attempts.count == 2)
+        #expect(outcome.attempts[0].wasAvailable)
+        #expect(outcome.attempts[0].errorDescription != nil)
+        #expect(outcome.attempts[1].wasAvailable)
+        #expect(outcome.attempts[1].errorDescription == nil)
+    }
+
+    private static func makeStubResult() -> ProviderFetchResult {
+        let usage = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 1,
+                windowMinutes: nil,
+                resetsAt: nil,
+                resetDescription: "test"),
+            secondary: nil,
+            tertiary: nil,
+            updatedAt: Date(),
+            identity: nil)
+        return ProviderFetchResult(
+            usage: usage,
+            credits: nil,
+            dashboard: nil,
+            sourceLabel: "test",
+            strategyID: "provider.fetchPipeline.success",
+            strategyKind: .api)
+    }
+}

package/Tests/RunicTests/ProviderIconResourcesTests.swift

@@ -0,0 +1,38 @@
+import AppKit
+import Foundation
+import Testing
+
+@MainActor
+@Suite
+struct ProviderIconResourcesTests {
+    @Test
+    func providerIconSVGsExist() throws {
+        let root = try Self.repoRoot()
+        let resources = root.appending(path: "Sources/Runic/Resources", directoryHint: .isDirectory)
+
+        let slugs = ["codex", "claude", "zai", "cursor", "gemini", "antigravity", "factory", "copilot"]
+        for slug in slugs {
+            let url = resources.appending(path: "ProviderIcon-\(slug).svg")
+            #expect(
+                FileManager.default.fileExists(atPath: url.path(percentEncoded: false)),
+                "Missing SVG for \(slug)")
+
+            let image = NSImage(contentsOf: url)
+            #expect(image != nil, "Could not load SVG as NSImage for \(slug)")
+        }
+    }
+
+    private static func repoRoot() throws -> URL {
+        var dir = URL(filePath: #filePath).deletingLastPathComponent()
+        for _ in 0..<12 {
+            let candidate = dir.appending(path: "Package.swift")
+            if FileManager.default.fileExists(atPath: candidate.path(percentEncoded: false)) {
+                return dir
+            }
+            dir.deleteLastPathComponent()
+        }
+        throw NSError(domain: "ProviderIconResourcesTests", code: 2, userInfo: [
+            NSLocalizedDescriptionKey: "Could not locate repo root (Package.swift) from \(#filePath)",
+        ])
+    }
+}

package/Tests/RunicTests/ProviderMetadataStatusLinkTests.swift

@@ -0,0 +1,16 @@
+import Testing
+@testable import RunicCore
+
+@Suite
+struct ProviderMetadataStatusLinkTests {
+    @Test
+    func workspaceStatusLinkMatchesProductID() {
+        for (provider, meta) in ProviderDefaults.metadata {
+            guard let productID = meta.statusWorkspaceProductID else { continue }
+            let expected = "https://www.google.com/appsstatus/dashboard/products/\(productID)/history"
+            #expect(
+                meta.statusLinkURL == expected,
+                "Expected \(provider.rawValue) statusLinkURL to be \(expected)")
+        }
+    }
+}

package/Tests/RunicTests/ProviderRegistryTests.swift

@@ -0,0 +1,29 @@
+import RunicCore
+import XCTest
+
+final class ProviderRegistryTests: XCTestCase {
+    func test_descriptorRegistryIsCompleteAndDeterministic() {
+        let descriptors = ProviderDescriptorRegistry.all
+        let ids = descriptors.map(\.id)
+
+        XCTAssertFalse(descriptors.isEmpty, "ProviderDescriptorRegistry must not be empty.")
+        XCTAssertEqual(Set(ids).count, ids.count, "ProviderDescriptorRegistry contains duplicate IDs.")
+
+        let missing = Set(UsageProvider.allCases).subtracting(ids)
+        XCTAssertTrue(missing.isEmpty, "Missing descriptors for providers: \(missing).")
+
+        let secondPass = ProviderDescriptorRegistry.all.map(\.id)
+        XCTAssertEqual(ids, secondPass, "ProviderDescriptorRegistry order changed between reads.")
+    }
+
+    func test_providerUsageCoverageFlagsForQuotaModelProviders() {
+        let metadata = ProviderDefaults.metadata
+
+        XCTAssertTrue(
+            metadata[.gemini]?.usageCoverage.supportsModelBreakdown == true,
+            "Gemini should advertise model breakdown coverage from quota windows.")
+        XCTAssertTrue(
+            metadata[.antigravity]?.usageCoverage.supportsModelBreakdown == true,
+            "Antigravity should advertise model breakdown coverage from quota windows.")
+    }
+}

package/Tests/RunicTests/ProviderSettingsDescriptorTests.swift

@@ -0,0 +1,202 @@
+import RunicCore
+import Foundation
+import SwiftUI
+import Testing
+@testable import Runic
+
+@MainActor
+@Suite
+struct ProviderSettingsDescriptorTests {
+    @Test
+    func toggleIDsAreUniqueAcrossProviders() {
+        let defaults = UserDefaults(suiteName: "ProviderSettingsDescriptorTests-unique")!
+        defaults.removePersistentDomain(forName: "ProviderSettingsDescriptorTests-unique")
+        let settings = SettingsStore(userDefaults: defaults, zaiTokenStore: NoopZaiTokenStore(), minimaxTokenStore: NoopMiniMaxTokenStore(), minimaxCookieHeaderStore: NoopMiniMaxCookieHeaderStore(), minimaxGroupIDStore: NoopMiniMaxGroupIDStore(), openRouterTokenStore: NoopOpenRouterTokenStore(), groqTokenStore: NoopGroqTokenStore())
+        let store = UsageStore(fetcher: UsageFetcher(environment: [:]), settings: settings)
+
+        var statusByID: [String: String] = [:]
+        var lastRunAtByID: [String: Date] = [:]
+        var seenToggleIDs: Set<String> = []
+        var seenActionIDs: Set<String> = []
+
+        for provider in UsageProvider.allCases {
+            let context = ProviderSettingsContext(
+                provider: provider,
+                settings: settings,
+                store: store,
+                boolBinding: { keyPath in
+                    Binding(
+                        get: { settings[keyPath: keyPath] },
+                        set: { settings[keyPath: keyPath] = $0 })
+                },
+                stringBinding: { keyPath in
+                    Binding(
+                        get: { settings[keyPath: keyPath] },
+                        set: { settings[keyPath: keyPath] = $0 })
+                },
+                statusText: { id in statusByID[id] },
+                setStatusText: { id, text in
+                    if let text {
+                        statusByID[id] = text
+                    } else {
+                        statusByID.removeValue(forKey: id)
+                    }
+                },
+                lastAppActiveRunAt: { id in lastRunAtByID[id] },
+                setLastAppActiveRunAt: { id, date in
+                    if let date {
+                        lastRunAtByID[id] = date
+                    } else {
+                        lastRunAtByID.removeValue(forKey: id)
+                    }
+                },
+                requestConfirmation: { _ in })
+
+            let impl = ProviderCatalog.implementation(for: provider)!
+            let toggles = impl.settingsToggles(context: context)
+            for toggle in toggles {
+                #expect(!seenToggleIDs.contains(toggle.id))
+                seenToggleIDs.insert(toggle.id)
+
+                for action in toggle.actions {
+                    #expect(!seenActionIDs.contains(action.id))
+                    seenActionIDs.insert(action.id)
+                }
+            }
+        }
+    }
+
+    @Test
+    func codexDoesNotExposeOpenAIWebToggle() {
+        let defaults = UserDefaults(suiteName: "ProviderSettingsDescriptorTests-codex")!
+        defaults.removePersistentDomain(forName: "ProviderSettingsDescriptorTests-codex")
+        let settings = SettingsStore(userDefaults: defaults, zaiTokenStore: NoopZaiTokenStore(), minimaxTokenStore: NoopMiniMaxTokenStore(), minimaxCookieHeaderStore: NoopMiniMaxCookieHeaderStore(), minimaxGroupIDStore: NoopMiniMaxGroupIDStore(), openRouterTokenStore: NoopOpenRouterTokenStore(), groqTokenStore: NoopGroqTokenStore())
+        let store = UsageStore(fetcher: UsageFetcher(environment: [:]), settings: settings)
+
+        let context = ProviderSettingsContext(
+            provider: .codex,
+            settings: settings,
+            store: store,
+            boolBinding: { keyPath in
+                Binding(
+                    get: { settings[keyPath: keyPath] },
+                    set: { settings[keyPath: keyPath] = $0 })
+            },
+            stringBinding: { keyPath in
+                Binding(
+                    get: { settings[keyPath: keyPath] },
+                    set: { settings[keyPath: keyPath] = $0 })
+            },
+            statusText: { _ in nil },
+            setStatusText: { _, _ in },
+            lastAppActiveRunAt: { _ in nil },
+            setLastAppActiveRunAt: { _, _ in },
+            requestConfirmation: { _ in })
+
+        let toggles = CodexProviderImplementation().settingsToggles(context: context)
+        #expect(toggles.isEmpty)
+    }
+
+    @Test
+    func claudeDoesNotExposeSettingsToggles() {
+        let defaults = UserDefaults(suiteName: "ProviderSettingsDescriptorTests-claude")!
+        defaults.removePersistentDomain(forName: "ProviderSettingsDescriptorTests-claude")
+        let settings = SettingsStore(userDefaults: defaults, zaiTokenStore: NoopZaiTokenStore(), minimaxTokenStore: NoopMiniMaxTokenStore(), minimaxCookieHeaderStore: NoopMiniMaxCookieHeaderStore(), minimaxGroupIDStore: NoopMiniMaxGroupIDStore(), openRouterTokenStore: NoopOpenRouterTokenStore(), groqTokenStore: NoopGroqTokenStore())
+        let store = UsageStore(fetcher: UsageFetcher(environment: [:]), settings: settings)
+
+        let context = ProviderSettingsContext(
+            provider: .claude,
+            settings: settings,
+            store: store,
+            boolBinding: { keyPath in
+                Binding(
+                    get: { settings[keyPath: keyPath] },
+                    set: { settings[keyPath: keyPath] = $0 })
+            },
+            stringBinding: { keyPath in
+                Binding(
+                    get: { settings[keyPath: keyPath] },
+                    set: { settings[keyPath: keyPath] = $0 })
+            },
+            statusText: { _ in nil },
+            setStatusText: { _, _ in },
+            lastAppActiveRunAt: { _ in nil },
+            setLastAppActiveRunAt: { _, _ in },
+            requestConfirmation: { _ in })
+        let toggles = ClaudeProviderImplementation().settingsToggles(context: context)
+        #expect(toggles.isEmpty)
+    }
+
+    @Test
+    func claudeWebExtrasAutoDisablesWhenLeavingCLI() {
+        let defaults = UserDefaults(suiteName: "ProviderSettingsDescriptorTests-claude-invariant")!
+        defaults.removePersistentDomain(forName: "ProviderSettingsDescriptorTests-claude-invariant")
+        let settings = SettingsStore(userDefaults: defaults, zaiTokenStore: NoopZaiTokenStore(), minimaxTokenStore: NoopMiniMaxTokenStore(), minimaxCookieHeaderStore: NoopMiniMaxCookieHeaderStore(), minimaxGroupIDStore: NoopMiniMaxGroupIDStore(), openRouterTokenStore: NoopOpenRouterTokenStore(), groqTokenStore: NoopGroqTokenStore())
+        settings.debugMenuEnabled = true
+        settings.claudeUsageDataSource = .cli
+        settings.claudeWebExtrasEnabled = true
+
+        settings.claudeUsageDataSource = .oauth
+        #expect(settings.claudeWebExtrasEnabled == false)
+    }
+
+    @Test
+    func extraProvidersExposeExpectedSettingsFields() {
+        let defaults = UserDefaults(suiteName: "ProviderSettingsDescriptorTests-extra-fields")!
+        defaults.removePersistentDomain(forName: "ProviderSettingsDescriptorTests-extra-fields")
+        let settings = SettingsStore(userDefaults: defaults, zaiTokenStore: NoopZaiTokenStore(), minimaxTokenStore: NoopMiniMaxTokenStore(), minimaxCookieHeaderStore: NoopMiniMaxCookieHeaderStore(), minimaxGroupIDStore: NoopMiniMaxGroupIDStore(), openRouterTokenStore: NoopOpenRouterTokenStore(), groqTokenStore: NoopGroqTokenStore())
+        let store = UsageStore(fetcher: UsageFetcher(environment: [:]), settings: settings)
+
+        let expectedFields: [UsageProvider: Set<String>] = [
+            .kimi: ["kimi-api-token"],
+            .auggie: ["auggie-api-token"],
+            .openrouter: ["openrouter-api-token"],
+            .bedrock: ["bedrock-region", "bedrock-aws-profile", "bedrock-model-id"],
+        ]
+
+        for (provider, expected) in expectedFields {
+            guard let impl = ProviderCatalog.implementation(for: provider) else {
+                #expect(Bool(false), "Missing provider implementation for \(provider.rawValue).")
+                continue
+            }
+            let context = self.makeSettingsContext(provider: provider, settings: settings, store: store)
+            let visibleFields = impl.settingsFields(context: context).filter { $0.isVisible?() ?? true }
+            let fieldIDs = Set(visibleFields.map(\.id))
+            #expect(fieldIDs.isSuperset(of: expected))
+            #expect(!visibleFields.isEmpty)
+        }
+    }
+
+    @Test
+    func allProvidersHaveAppSideImplementation() {
+        for provider in UsageProvider.allCases {
+            #expect(ProviderCatalog.implementation(for: provider) != nil)
+        }
+    }
+
+    private func makeSettingsContext(
+        provider: UsageProvider,
+        settings: SettingsStore,
+        store: UsageStore) -> ProviderSettingsContext
+    {
+        ProviderSettingsContext(
+            provider: provider,
+            settings: settings,
+            store: store,
+            boolBinding: { keyPath in
+                Binding(
+                    get: { settings[keyPath: keyPath] },
+                    set: { settings[keyPath: keyPath] = $0 })
+            },
+            stringBinding: { keyPath in
+                Binding(
+                    get: { settings[keyPath: keyPath] },
+                    set: { settings[keyPath: keyPath] = $0 })
+            },
+            statusText: { _ in nil },
+            setStatusText: { _, _ in },
+            lastAppActiveRunAt: { _ in nil },
+            setLastAppActiveRunAt: { _, _ in },
+            requestConfirmation: { _ in })
+    }
+}