@sriinnu/runic 2.0.0 → 2.11.2

package/Tests/RunicTests/StatusProbeTests.swift

@@ -1,376 +0,0 @@
-import Foundation
-import RunicCore
-import Testing
-@testable import Runic
-
-struct StatusProbeTests {
-    @Test
-    func `parse codex status`() throws {
-        let sample = """
-        Model: gpt
-        Credits: 980 credits
-        5h limit: [#####] 75% left
-        Weekly limit: [##] 25% left
-        """
-        let snap = try CodexStatusProbe.parse(text: sample)
-        #expect(snap.credits == 980)
-        #expect(snap.fiveHourPercentLeft == 75)
-        #expect(snap.weeklyPercentLeft == 25)
-    }
-
-    @Test
-    func `parse codex status with ansi and resets`() throws {
-        let sample = """
-        \u{001B}[38;5;245mCredits:\u{001B}[0m 557 credits
-        5h limit: [█████     ] 50% left (resets 09:01)
-        Weekly limit: [███████   ] 85% left (resets 04:01 on 27 Nov)
-        """
-        let snap = try CodexStatusProbe.parse(text: sample)
-        #expect(snap.credits == 557)
-        #expect(snap.fiveHourPercentLeft == 50)
-        #expect(snap.weeklyPercentLeft == 85)
-    }
-
-    @Test
-    func `parse claude status`() throws {
-        let sample = """
-        Settings: Status   Config   Usage (tab to cycle)
-
-        Current session
-        1% used  (Resets 5am (Europe/Vienna))
-        Current week (all models)
-        1% used  (Resets Dec 2 at 12am (Europe/Vienna))
-        Current week (Sonnet only)
-        1% used (Resets Dec 2 at 12am (Europe/Vienna))
-
-        Nov 24, 2025 update:
-        We've increased your limits and removed the Opus cap,
-        so you can use Opus 4.5 up to your overall limit.
-        Sonnet now has its own limit—it's set to match your previous overall limit,
-        so you can use just as much as before.
-        Account: user@example.com
-        Org: Example Org
-        """
-        let snap = try ClaudeStatusProbe.parse(text: sample)
-        #expect(snap.sessionPercentLeft == 99)
-        #expect(snap.weeklyPercentLeft == 99)
-        #expect(snap.opusPercentLeft == 99)
-        #expect(snap.accountEmail == "user@example.com")
-        #expect(snap.accountOrganization == "Example Org")
-        #expect(snap.primaryResetDescription == "Resets 5am (Europe/Vienna)")
-        #expect(snap.secondaryResetDescription == "Resets Dec 2 at 12am (Europe/Vienna)")
-        #expect(snap.opusResetDescription == "Resets Dec 2 at 12am (Europe/Vienna)")
-    }
-
-    @Test
-    func `parse claude status with ANSI`() throws {
-        let sample = """
-        \u{001B}[35mCurrent session\u{001B}[0m
-        40% used  (Resets 11am)
-        Current week (all models)
-        10% used  (Resets Nov 27)
-        Current week (Sonnet only)
-        0% used (Resets Nov 27)
-        Account: user@example.com
-        Org: ACME
-        \u{001B}[0m
-        """
-        let snap = try ClaudeStatusProbe.parse(text: sample)
-        #expect(snap.sessionPercentLeft == 60)
-        #expect(snap.weeklyPercentLeft == 90)
-        #expect(snap.opusPercentLeft == 100)
-        #expect(snap.primaryResetDescription == "Resets 11am")
-        #expect(snap.secondaryResetDescription == "Resets Nov 27")
-        #expect(snap.opusResetDescription == "Resets Nov 27")
-    }
-
-    @Test
-    func `parse claude status legacy opus label`() throws {
-        let sample = """
-        Current session
-        12% used  (Resets 11am)
-        Current week (all models)
-        55% used  (Resets Nov 21)
-        Current week (Opus)
-        5% used (Resets Nov 21)
-        Account: user@example.com
-        Org: Example Org
-        """
-        let snap = try ClaudeStatusProbe.parse(text: sample)
-        #expect(snap.sessionPercentLeft == 88)
-        #expect(snap.weeklyPercentLeft == 45)
-        #expect(snap.opusPercentLeft == 95)
-        #expect(snap.primaryResetDescription == "Resets 11am")
-        #expect(snap.secondaryResetDescription == "Resets Nov 21")
-        #expect(snap.opusResetDescription == "Resets Nov 21")
-    }
-
-    @Test
-    func `parse claude status enterprise session only`() throws {
-        let sample = """
-        Current session
-        █                                                  2% used
-        Resets 3pm (Europe/Vienna)
-        """
-        let snap = try ClaudeStatusProbe.parse(text: sample)
-        #expect(snap.sessionPercentLeft == 98)
-        #expect(snap.weeklyPercentLeft == nil)
-        #expect(snap.primaryResetDescription == "Resets 3pm (Europe/Vienna)")
-        #expect(snap.secondaryResetDescription == nil)
-    }
-
-    @Test
-    func `parse claude status reset mappings with CR line endings`() throws {
-        let sample =
-            "Current  session\r" +
-            "██████████████████████████████████████████████████  17% used\r" +
-            "Resets 12:59pm (Europe/Paris)\r" +
-            "Current week (all models)\r" +
-            "██████████████████████████████████████████████████   4% used\r" +
-            "Resets Dec 24 at 3:59pm (Europe/Paris)\r" +
-            "Current week (Sonnet only)\r" +
-            "██████████████████████████████████████████████████   3% used\r" +
-            "Resets Dec 23 at 3:59am (Europe/Paris)\r"
-
-        let snap = try ClaudeStatusProbe.parse(text: sample)
-        #expect(snap.sessionPercentLeft == 83)
-        #expect(snap.weeklyPercentLeft == 96)
-        #expect(snap.opusPercentLeft == 97)
-        #expect(snap.primaryResetDescription == "Resets 12:59pm (Europe/Paris)")
-        #expect(snap.secondaryResetDescription == "Resets Dec 24 at 3:59pm (Europe/Paris)")
-        #expect(snap.opusResetDescription == "Resets Dec 23 at 3:59am (Europe/Paris)")
-    }
-
-    @Test
-    func `parse claude status reset mappings does not promote weekly reset to session`() throws {
-        let sample = """
-        Current session
-        ██████████████████████████████████████████████████  17% used
-        Current week (all models)
-        ██████████████████████████████████████████████████   4% used
-        Resets Dec 24 at 3:59pm (Europe/Paris)
-        """
-        let snap = try ClaudeStatusProbe.parse(text: sample)
-        #expect(snap.sessionPercentLeft == 83)
-        #expect(snap.weeklyPercentLeft == 96)
-        #expect(snap.primaryResetDescription == nil)
-        #expect(snap.secondaryResetDescription == "Resets Dec 24 at 3:59pm (Europe/Paris)")
-    }
-
-    @Test
-    func `parse claude status with plan and ansi noise`() throws {
-        let sample = """
-        Settings: Status   Config   Usage
-
-        Login method: \u{001B}[22mClaude Max Account\u{001B}[0m
-        Account: user@example.com
-        Org: ACME
-        """
-        // Only care about login/identity; include minimal usage lines to satisfy parser.
-        let text = """
-        Current session
-        10% used
-        Current week (all models)
-        20% used
-        Current week (Opus)
-        30% used
-        \(sample)
-        """
-        let snap = try ClaudeStatusProbe.parse(text: text)
-        #expect(snap.loginMethod == "Max")
-        #expect(snap.accountEmail == "user@example.com")
-        #expect(snap.accountOrganization == "ACME")
-    }
-
-    @Test
-    func `parse claude status with bracket plan noise no esc`() throws {
-        let sample = """
-        Login method: [22m Claude Max Account
-        Account: user@example.com
-        """
-        let text = """
-        Current session
-        10% used
-        Current week (all models)
-        20% used
-        Current week (Opus)
-        30% used
-        \(sample)
-        """
-        let snap = try ClaudeStatusProbe.parse(text: text)
-        #expect(snap.loginMethod == "Max")
-    }
-
-    @Test
-    func `surfaces claude token expired`() {
-        let sample = """
-        Settings:  Status   Config   Usage
-
-        Error: Failed to load usage data: {"type":"error","error":{"type":"authentication_error",
-        "message":"OAuth token has expired. Please obtain a new token or refresh your existing token.",
-        "details":{"error_visibility":"user_facing","error_code":"token_expired"}},\
-        "request_id":"req_123"}
-        """
-
-        do {
-            _ = try ClaudeStatusProbe.parse(text: sample)
-            #expect(Bool(false), "Parsing should fail for auth error")
-        } catch let ClaudeStatusProbeError.parseFailed(message) {
-            let lower = message.lowercased()
-            #expect(lower.contains("token"))
-            #expect(lower.contains("login"))
-        } catch {
-            #expect(Bool(false), "Unexpected error: \(error)")
-        }
-    }
-
-    @Test
-    func `surfaces claude folder trust prompt`() {
-        let sample = """
-        Do you trust the files in this folder?
-
-        /Users/example/project
-        """
-
-        do {
-            _ = try ClaudeStatusProbe.parse(text: sample)
-            #expect(Bool(false), "Parsing should fail for folder trust prompt")
-        } catch let ClaudeStatusProbeError.parseFailed(message) {
-            #expect(message.lowercased().contains("trust"))
-            #expect(message.contains("/Users/example/project"))
-            #expect(message.contains("cd \"/Users/example/project\" && claude"))
-        } catch {
-            #expect(Bool(false), "Unexpected error: \(error)")
-        }
-    }
-
-    @Test
-    func `surfaces claude folder trust prompt with CRLF and spaces`() {
-        let sample = "Do you trust the files in this folder?\r\n\r\n/Users/example/My Project\r\n"
-
-        do {
-            _ = try ClaudeStatusProbe.parse(text: sample)
-            #expect(Bool(false), "Parsing should fail for folder trust prompt")
-        } catch let ClaudeStatusProbeError.parseFailed(message) {
-            #expect(message.contains("/Users/example/My Project"))
-            #expect(message.contains("cd \"/Users/example/My Project\" && claude"))
-        } catch {
-            #expect(Bool(false), "Unexpected error: \(error)")
-        }
-    }
-
-    @Test
-    func `surfaces claude folder trust prompt without folder path`() {
-        let sample = """
-        Do you trust the files in this folder?
-        """
-
-        do {
-            _ = try ClaudeStatusProbe.parse(text: sample)
-            #expect(Bool(false), "Parsing should fail for folder trust prompt")
-        } catch let ClaudeStatusProbeError.parseFailed(message) {
-            let lower = message.lowercased()
-            #expect(lower.contains("trust"))
-            #expect(lower.contains("auto-accept"))
-        } catch {
-            #expect(Bool(false), "Unexpected error: \(error)")
-        }
-    }
-
-    @Test
-    func `parses claude reset time only`() throws {
-        let now = Date(timeIntervalSince1970: 1_733_690_000)
-        let parsed = ClaudeStatusProbe.parseResetDate(from: "Resets 12:59pm (Europe/Helsinki)", now: now)
-        let tz = try #require(TimeZone(identifier: "Europe/Helsinki"))
-        var calendar = Calendar(identifier: .gregorian)
-        calendar.timeZone = tz
-        var expected = try #require(calendar.date(bySettingHour: 12, minute: 59, second: 0, of: now))
-        if expected < now {
-            expected = try #require(calendar.date(byAdding: .day, value: 1, to: expected))
-        }
-        #expect(parsed == expected)
-    }
-
-    @Test
-    func `parses claude reset date and time`() throws {
-        let now = Date(timeIntervalSince1970: 1_733_690_000)
-        let parsed = ClaudeStatusProbe.parseResetDate(from: "Resets Dec 9, 8:59am (Europe/Helsinki)", now: now)
-        var calendar = Calendar(identifier: .gregorian)
-        calendar.timeZone = try #require(TimeZone(identifier: "Europe/Helsinki"))
-        let expected = calendar.date(from: DateComponents(
-            year: calendar.component(.year, from: now),
-            month: 12,
-            day: 9,
-            hour: 8,
-            minute: 59,
-            second: 0))
-        #expect(parsed == expected)
-    }
-
-    @Test
-    func `parses claude reset with dot separated time`() throws {
-        let now = Date(timeIntervalSince1970: 1_733_690_000)
-        let parsed = ClaudeStatusProbe.parseResetDate(from: "Resets Dec 9 at 5.27am (UTC)", now: now)
-        var calendar = Calendar(identifier: .gregorian)
-        calendar.timeZone = try #require(TimeZone(identifier: "UTC"))
-        let expected = calendar.date(from: DateComponents(year: 2024, month: 12, day: 9, hour: 5, minute: 27))
-        #expect(parsed == expected)
-    }
-
-    @Test
-    func `parses claude reset with compact times`() throws {
-        let now = Date(timeIntervalSince1970: 1_733_690_000)
-        let parsedTimeOnly = ClaudeStatusProbe.parseResetDate(from: "Resets 1pm (UTC)", now: now)
-        var calendar = Calendar(identifier: .gregorian)
-        calendar.timeZone = try #require(TimeZone(identifier: "UTC"))
-        var expected = try #require(calendar.date(bySettingHour: 13, minute: 0, second: 0, of: now))
-        if expected < now {
-            expected = try #require(calendar.date(byAdding: .day, value: 1, to: expected))
-        }
-        #expect(parsedTimeOnly == expected)
-
-        let parsedDateTime = ClaudeStatusProbe.parseResetDate(from: "Resets Dec 9, 9am", now: now)
-        calendar.timeZone = TimeZone.current
-        let dateExpected = calendar.date(from: DateComponents(
-            year: calendar.component(.year, from: now),
-            month: 12,
-            day: 9,
-            hour: 9,
-            minute: 0,
-            second: 0))
-        #expect(parsedDateTime == dateExpected)
-    }
-
-    @Test
-    func `live codex status`() async throws {
-        guard ProcessInfo.processInfo.environment["LIVE_CODEX_STATUS"] == "1" else { return }
-
-        let probe = CodexStatusProbe()
-        do {
-            let snap = try await probe.fetch()
-            let summary = """
-            Live Codex status:
-            \(snap.rawText)
-            values: 5h \(snap.fiveHourPercentLeft ?? -1)% left,
-            weekly \(snap.weeklyPercentLeft ?? -1)% left,
-            credits \(snap.credits ?? -1)
-            """
-            print(summary)
-        } catch {
-            // Dump raw PTY text to help debug.
-            let runner = TTYCommandRunner()
-            let res = try runner.run(
-                binary: "codex",
-                send: "/status\n",
-                options: .init(rows: 60, cols: 200, timeout: 12))
-            print("RAW CODEX PTY OUTPUT BEGIN\n\(res.text)\nRAW CODEX PTY OUTPUT END")
-            let clean = TextParsing.stripANSICodes(res.text)
-            print("CLEAN CODEX OUTPUT BEGIN\n\(clean)\nCLEAN CODEX OUTPUT END")
-            let five = TextParsing.firstInt(pattern: #"5h limit[^\n]*?([0-9]{1,3})%\s+left"#, text: clean) ?? -1
-            let week = TextParsing.firstInt(pattern: #"Weekly limit[^\n]*?([0-9]{1,3})%\s+left"#, text: clean) ?? -1
-            let credits = TextParsing.firstNumber(pattern: #"Credits:\s*([0-9][0-9.,]*)"#, text: clean) ?? -1
-            print("Parsed probes => 5h \(five)% weekly \(week)% credits \(credits)")
-            throw error
-        }
-    }
-}

package/Tests/RunicTests/SubprocessRunnerTests.swift

@@ -1,18 +0,0 @@
-import Foundation
-import Testing
-@testable import RunicCore
-
-struct SubprocessRunnerTests {
-    @Test
-    func `reads large stdout without deadlock`() async throws {
-        let result = try await SubprocessRunner.run(
-            binary: "/usr/bin/python3",
-            arguments: ["-c", "print('x' * 1_000_000)"],
-            environment: ProcessInfo.processInfo.environment,
-            timeout: 5,
-            label: "python large stdout")
-
-        #expect(result.stdout.count >= 1_000_000)
-        #expect(result.stderr.isEmpty)
-    }
-}

package/Tests/RunicTests/SubscriptionDetectionTests.swift

@@ -1,64 +0,0 @@
-import Foundation
-import Testing
-@testable import Runic
-
-struct SubscriptionDetectionTests {
-    // MARK: - Subscription plans should be detected
-
-    @Test
-    func `detects max plan`() {
-        #expect(UsageStore.isSubscriptionPlan("Claude Max") == true)
-        #expect(UsageStore.isSubscriptionPlan("Max") == true)
-        #expect(UsageStore.isSubscriptionPlan("claude max") == true)
-        #expect(UsageStore.isSubscriptionPlan("MAX") == true)
-    }
-
-    @Test
-    func `detects pro plan`() {
-        #expect(UsageStore.isSubscriptionPlan("Claude Pro") == true)
-        #expect(UsageStore.isSubscriptionPlan("Pro") == true)
-        #expect(UsageStore.isSubscriptionPlan("pro") == true)
-    }
-
-    @Test
-    func `detects ultra plan`() {
-        #expect(UsageStore.isSubscriptionPlan("Claude Ultra") == true)
-        #expect(UsageStore.isSubscriptionPlan("Ultra") == true)
-        #expect(UsageStore.isSubscriptionPlan("ultra") == true)
-    }
-
-    @Test
-    func `detects team plan`() {
-        #expect(UsageStore.isSubscriptionPlan("Claude Team") == true)
-        #expect(UsageStore.isSubscriptionPlan("Team") == true)
-        #expect(UsageStore.isSubscriptionPlan("team") == true)
-    }
-
-    // MARK: - Non-subscription plans should return false
-
-    @Test
-    func `nil login method returns false`() {
-        #expect(UsageStore.isSubscriptionPlan(nil) == false)
-    }
-
-    @Test
-    func `empty login method returns false`() {
-        #expect(UsageStore.isSubscriptionPlan("") == false)
-        #expect(UsageStore.isSubscriptionPlan("   ") == false)
-    }
-
-    @Test
-    func `unknown plan returns false`() {
-        #expect(UsageStore.isSubscriptionPlan("API") == false)
-        #expect(UsageStore.isSubscriptionPlan("Free") == false)
-        #expect(UsageStore.isSubscriptionPlan("Unknown") == false)
-        #expect(UsageStore.isSubscriptionPlan("Claude") == false)
-    }
-
-    @Test
-    func `api key users return false`() {
-        // API users typically don't have a login method or have non-subscription identifiers
-        #expect(UsageStore.isSubscriptionPlan("api_key") == false)
-        #expect(UsageStore.isSubscriptionPlan("console") == false)
-    }
-}

package/Tests/RunicTests/TTYCommandRunnerTests.swift

@@ -1,147 +0,0 @@
-import Foundation
-import Testing
-@testable import RunicCore
-
-struct TTYCommandRunnerEnvTests {
-    @Test
-    func `preserves environment and sets term`() {
-        let baseEnv: [String: String] = [
-            "PATH": "/custom/bin",
-            "HOME": "/Users/tester",
-            "LANG": "en_US.UTF-8",
-        ]
-
-        let merged = TTYCommandRunner.enrichedEnvironment(
-            baseEnv: baseEnv,
-            loginPATH: nil,
-            home: "/Users/tester")
-
-        #expect(merged["HOME"] == "/Users/tester")
-        #expect(merged["LANG"] == "en_US.UTF-8")
-        #expect(merged["TERM"] == "xterm-256color")
-
-        #expect(merged["PATH"] == "/custom/bin")
-    }
-
-    @Test
-    func `backfills home when missing`() {
-        let merged = TTYCommandRunner.enrichedEnvironment(
-            baseEnv: ["PATH": "/custom/bin"],
-            loginPATH: nil,
-            home: "/Users/fallback")
-        #expect(merged["HOME"] == "/Users/fallback")
-        #expect(merged["TERM"] == "xterm-256color")
-    }
-
-    @Test
-    func `preserves existing term and custom vars`() {
-        let merged = TTYCommandRunner.enrichedEnvironment(
-            baseEnv: [
-                "PATH": "/custom/bin",
-                "TERM": "vt100",
-                "BUN_INSTALL": "/Users/tester/.bun",
-                "SHELL": "/bin/zsh",
-            ],
-            loginPATH: nil,
-            home: "/Users/tester")
-
-        #expect(merged["TERM"] == "vt100")
-        #expect(merged["BUN_INSTALL"] == "/Users/tester/.bun")
-        #expect(merged["SHELL"] == "/bin/zsh")
-        #expect((merged["PATH"] ?? "").contains("/custom/bin"))
-    }
-
-    @Test
-    func `sets working directory when provided`() throws {
-        let fm = FileManager.default
-        let dir = fm.temporaryDirectory.appendingPathComponent("runic-tty-\(UUID().uuidString)", isDirectory: true)
-        try fm.createDirectory(at: dir, withIntermediateDirectories: true)
-
-        let runner = TTYCommandRunner()
-        let result = try runner.run(binary: "/bin/pwd", send: "", options: .init(timeout: 3, workingDirectory: dir))
-        let clean = result.text.replacingOccurrences(of: "\r", with: "")
-        #expect(clean.contains(dir.path))
-    }
-
-    @Test
-    func `auto responds to trust prompt`() throws {
-        let fm = FileManager.default
-        let dir = fm.temporaryDirectory.appendingPathComponent("runic-tty-\(UUID().uuidString)", isDirectory: true)
-        try fm.createDirectory(at: dir, withIntermediateDirectories: true)
-        defer { try? fm.removeItem(at: dir) }
-
-        let scriptURL = dir.appendingPathComponent("trust.sh")
-        let script = """
-        #!/bin/sh
-        echo \"Do you trust the files in this folder?\"
-        echo \"\"
-        echo \"/Users/example/project\"
-        IFS= read -r ans
-        if [ \"$ans\" = \"y\" ] || [ \"$ans\" = \"Y\" ]; then
-          echo \"accepted\"
-        else
-          echo \"rejected:$ans\"
-        fi
-        """
-        try script.write(to: scriptURL, atomically: true, encoding: .utf8)
-        try fm.setAttributes([.posixPermissions: 0o755], ofItemAtPath: scriptURL.path)
-
-        let runner = TTYCommandRunner()
-        let result = try runner.run(
-            binary: scriptURL.path,
-            send: "",
-            options: .init(
-                timeout: 3,
-                // Use LF for portability: some PTY/termios setups do not translate CR → NL for shell reads.
-                sendOnSubstrings: ["Do you trust the files in this folder?": "y\n"],
-                stopOnSubstrings: ["accepted", "rejected"],
-                settleAfterStop: 0.1))
-
-        #expect(result.text.contains("accepted"))
-    }
-
-    @Test
-    func `stops when output is idle`() throws {
-        let fm = FileManager.default
-        let dir = fm.temporaryDirectory.appendingPathComponent("runic-tty-\(UUID().uuidString)", isDirectory: true)
-        try fm.createDirectory(at: dir, withIntermediateDirectories: true)
-        defer { try? fm.removeItem(at: dir) }
-
-        let scriptURL = dir.appendingPathComponent("idle.sh")
-        let script = """
-        #!/bin/sh
-        echo "hello"
-        sleep 10
-        """
-        try script.write(to: scriptURL, atomically: true, encoding: .utf8)
-        try fm.setAttributes([.posixPermissions: 0o755], ofItemAtPath: scriptURL.path)
-
-        let runner = TTYCommandRunner()
-        let startedAt = Date()
-        let result = try runner.run(
-            binary: scriptURL.path,
-            send: "",
-            options: .init(timeout: 6, idleTimeout: 0.2))
-        let elapsed = Date().timeIntervalSince(startedAt)
-
-        #expect(result.text.contains("hello"))
-        #expect(elapsed < 3.0)
-    }
-
-    @Test
-    func `rolling buffer detects needle across boundary`() {
-        var scanner = TTYCommandRunner.RollingBuffer(maxNeedle: 6)
-        let needle = Data("hello".utf8)
-        let first = scanner.append(Data("he".utf8))
-        #expect(first.range(of: needle) == nil)
-        let second = scanner.append(Data("llo!".utf8))
-        #expect(second.range(of: needle) != nil)
-    }
-
-    @Test
-    func `lowercased ASCII only touches ascii`() {
-        let data = Data("UpDaTe".utf8)
-        let lowered = TTYCommandRunner.lowercasedASCII(data)
-        #expect(String(data: lowered, encoding: .utf8) == "update")
-    }
-}

package/Tests/RunicTests/TTYIntegrationTests.swift

@@ -1,41 +0,0 @@
-import RunicCore
-import XCTest
-@testable import Runic
-
-final class TTYIntegrationTests: XCTestCase {
-    func testCodexRPCUsageLive() async throws {
-        let fetcher = UsageFetcher()
-        do {
-            let snapshot = try await fetcher.loadLatestUsage()
-            let hasData = snapshot.primary.usedPercent >= 0 && (snapshot.secondary?.usedPercent ?? 0) >= 0
-            XCTAssertTrue(hasData, "Codex RPC probe returned no usage data.")
-        } catch UsageError.noRateLimitsFound {
-            throw XCTSkip("Codex RPC returned no rate limits yet (likely warming up).")
-        } catch {
-            throw XCTSkip("Codex RPC probe failed: \(error)")
-        }
-    }
-
-    func testClaudeTTYUsageProbeLive() async throws {
-        guard TTYCommandRunner.which("claude") != nil else {
-            throw XCTSkip("Claude CLI not installed; skipping live PTY probe.")
-        }
-
-        let fetcher = ClaudeUsageFetcher(dataSource: .cli)
-        do {
-            let snapshot = try await fetcher.loadLatestUsage()
-            XCTAssertNotNil(snapshot.primary.remainingPercent, "Claude session percent missing")
-            // Weekly is absent for some enterprise accounts.
-        } catch let ClaudeUsageError.parseFailed(message) {
-            throw XCTSkip("Claude PTY parse failed (likely not logged in or usage unavailable): \(message)")
-        } catch let ClaudeStatusProbeError.parseFailed(message) {
-            throw XCTSkip("Claude status parse failed (likely not logged in or usage unavailable): \(message)")
-        } catch ClaudeUsageError.claudeNotInstalled {
-            throw XCTSkip("Claude CLI not installed; skipping live PTY probe.")
-        } catch ClaudeStatusProbeError.timedOut {
-            throw XCTSkip("Claude PTY probe timed out; skipping.")
-        } catch let TTYCommandRunner.Error.launchFailed(message) where message.contains("login") {
-            throw XCTSkip("Claude CLI not logged in: \(message)")
-        }
-    }
-}