sneakoscope 8.0.2 → 8.0.4

package/dist/native/sks-menubar/Sources/OperationModels.swift

@@ -0,0 +1,389 @@
+import Foundation
+
+// SKS CLI timestamps come from JavaScript Date.toISOString() and carry
+// fractional seconds ("2026-07-24T00:00:00.000Z"), which the default
+// ISO8601DateFormatter options cannot parse. Try fractional first, then plain.
+enum SKSTimestamp {
+    private static let fractional: ISO8601DateFormatter = {
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        return formatter
+    }()
+    private static let plain = ISO8601DateFormatter()
+
+    static func date(from value: String) -> Date? {
+        fractional.date(from: value) ?? plain.date(from: value)
+    }
+}
+
+enum OperationState: String, Codable {
+    case queued, running, waitingForConfirmation, succeeded, failed, cancelled, terminalUncertain
+}
+
+enum OperationProgressSignal: String, Codable, CaseIterable {
+    case evidence, fileChange, testResult, modelResponse, toolResponse, none
+}
+
+enum OperationRecoveryCause: String, Codable, CaseIterable {
+    case transientNetwork
+    case authentication
+    case providerMode
+    case accountBinding
+    case externalConfiguration
+    case unknown
+}
+
+enum OperationRecoveryState: String, Codable {
+    case active
+    case warning
+    case autoResumePending
+    case pausedResumable
+}
+
+enum ProviderApplyStageName: String, Codable, CaseIterable {
+    case configSaved = "config_saved"
+    case proxyApplied = "proxy_applied"
+    case catalogRefreshed = "catalog_refreshed"
+    case newSessionReady = "new_session_ready"
+}
+
+enum ProviderApplyStageState: String, Codable {
+    case pending, running, succeeded, failed
+}
+
+struct ProviderApplyStageReceipt: Codable, Equatable {
+    let stage: ProviderApplyStageName
+    let status: ProviderApplyStageState
+    let reasonCode: String?
+    let updatedAt: String
+
+    enum CodingKeys: String, CodingKey {
+        case stage, status
+        case reasonCode = "reason_code"
+        case updatedAt = "updated_at"
+    }
+}
+
+struct ProviderSessionCopy: Codable, Equatable {
+    let mode: String
+    let model: String
+    let catalogVersion: String
+
+    enum CodingKeys: String, CodingKey {
+        case mode, model
+        case catalogVersion = "catalog_version"
+    }
+}
+
+struct ProviderApplyProjection: Codable, Equatable {
+    let schema: String
+    let stages: [ProviderApplyStageReceipt]
+    let existingSession: ProviderSessionCopy?
+    let newSessionDefault: ProviderSessionCopy
+
+    enum CodingKeys: String, CodingKey {
+        case schema, stages
+        case existingSession = "existing_session"
+        case newSessionDefault = "new_session_default"
+    }
+
+    static func initial(
+        existingSession: ProviderSessionCopy?,
+        newSessionDefault: ProviderSessionCopy,
+        now: Date = Date()
+    ) -> ProviderApplyProjection {
+        let timestamp = ISO8601DateFormatter().string(from: now)
+        return ProviderApplyProjection(
+            schema: "sks.provider-apply-projection.v1",
+            stages: ProviderApplyStageName.allCases.map {
+                ProviderApplyStageReceipt(stage: $0, status: .pending, reasonCode: nil, updatedAt: timestamp)
+            },
+            existingSession: existingSession,
+            newSessionDefault: newSessionDefault
+        )
+    }
+
+    func transitioning(
+        stage: ProviderApplyStageName,
+        to status: ProviderApplyStageState,
+        reasonCode: String? = nil,
+        now: Date = Date()
+    ) throws -> ProviderApplyProjection {
+        guard schema == "sks.provider-apply-projection.v1",
+              stages.map(\.stage) == ProviderApplyStageName.allCases,
+              let index = stages.firstIndex(where: { $0.stage == stage }) else {
+            throw ProviderApplyProjectionError.invalidProjection
+        }
+        if status == .failed, reasonCode == nil { throw ProviderApplyProjectionError.failureReasonRequired }
+        if status != .failed, reasonCode != nil { throw ProviderApplyProjectionError.unexpectedReason }
+        let current = stages[index].status
+        let validTransition = current == status
+            || current == .pending && status == .running
+            || current == .running && (status == .succeeded || status == .failed)
+            || current == .failed && status == .running
+        guard validTransition else { throw ProviderApplyProjectionError.invalidTransition }
+        if status != .pending, index > 0, stages[index - 1].status != .succeeded {
+            throw ProviderApplyProjectionError.previousStageIncomplete
+        }
+        var next = stages
+        next[index] = ProviderApplyStageReceipt(
+            stage: stage,
+            status: status,
+            reasonCode: reasonCode,
+            updatedAt: ISO8601DateFormatter().string(from: now)
+        )
+        return ProviderApplyProjection(
+            schema: schema,
+            stages: next,
+            existingSession: existingSession,
+            newSessionDefault: newSessionDefault
+        )
+    }
+
+    var allSucceeded: Bool { stages.allSatisfy { $0.status == .succeeded } }
+    var failedStage: ProviderApplyStageReceipt? { stages.first { $0.status == .failed } }
+}
+
+enum ProviderApplyProjectionError: Error {
+    case invalidProjection
+    case failureReasonRequired
+    case unexpectedReason
+    case invalidTransition
+    case previousStageIncomplete
+}
+
+struct OperationRecoveryStatus: Codable, Equatable {
+    let schema: String
+    let state: OperationRecoveryState
+    let cause: OperationRecoveryCause?
+    let automaticResume: Bool
+    let retryCount: Int
+    let maxAutomaticRetries: Int
+    let lastProgressSignal: OperationProgressSignal
+    let lastProgressAt: String
+    let stallReason: String?
+    let recoveryAttempt: String?
+    let nextAction: String
+    let pinnedMode: String?
+    let pinnedModel: String?
+    let accountBinding: String
+    let evidenceIntegrity: String
+
+    enum CodingKeys: String, CodingKey {
+        case schema, state, cause
+        case automaticResume = "automatic_resume"
+        case retryCount = "retry_count"
+        case maxAutomaticRetries = "max_automatic_retries"
+        case lastProgressSignal = "last_progress_signal"
+        case lastProgressAt = "last_progress_at"
+        case stallReason = "stall_reason"
+        case recoveryAttempt = "recovery_attempt"
+        case nextAction = "next_action"
+        case pinnedMode = "pinned_mode"
+        case pinnedModel = "pinned_model"
+        case accountBinding = "account_binding"
+        case evidenceIntegrity = "evidence_integrity"
+    }
+}
+
+struct OperationRecoveryAttemptOutcome {
+    let succeeded: Bool
+    let cause: OperationRecoveryCause?
+    let progressSignal: OperationProgressSignal
+
+    static func success(_ signal: OperationProgressSignal) -> OperationRecoveryAttemptOutcome {
+        OperationRecoveryAttemptOutcome(succeeded: true, cause: nil, progressSignal: signal)
+    }
+
+    static func failure(_ cause: OperationRecoveryCause) -> OperationRecoveryAttemptOutcome {
+        OperationRecoveryAttemptOutcome(succeeded: false, cause: cause, progressSignal: .none)
+    }
+}
+
+enum OperationRecoveryPolicy {
+    static let maxAutomaticNetworkRetries = 2
+
+    /// Time is diagnostic only. A fresh progress signal always keeps the work
+    /// active, even after a warning threshold. Only a classified cause may choose
+    /// automatic or manual recovery, and only transient network causes auto-resume.
+    static func evaluate(
+        cause: OperationRecoveryCause?,
+        sameCauseRetryCount: Int,
+        progressSignal: OperationProgressSignal,
+        progressObserved: Bool,
+        secondsWithoutProgress: TimeInterval,
+        warningAfter: TimeInterval,
+        pinnedMode: String? = nil,
+        pinnedModel: String? = nil,
+        now: Date = Date()
+    ) -> OperationRecoveryStatus {
+        let retryCount = max(0, sameCauseRetryCount)
+        let timestamp = ISO8601DateFormatter().string(from: now)
+        let shared = (
+            schema: "sks.operation-recovery.v1",
+            signal: progressSignal,
+            timestamp: timestamp,
+            mode: pinnedMode,
+            model: pinnedModel
+        )
+        if progressObserved {
+            return OperationRecoveryStatus(
+                schema: shared.schema, state: .active, cause: nil,
+                automaticResume: false, retryCount: retryCount,
+                maxAutomaticRetries: maxAutomaticNetworkRetries,
+                lastProgressSignal: shared.signal, lastProgressAt: shared.timestamp,
+                stallReason: nil, recoveryAttempt: nil,
+                nextAction: "Work is progressing; keep running.",
+                pinnedMode: shared.mode, pinnedModel: shared.model,
+                accountBinding: "pinned_unchanged", evidenceIntegrity: "preserved"
+            )
+        }
+        guard let cause = cause else {
+            let warning = secondsWithoutProgress >= max(1, warningAfter)
+            return OperationRecoveryStatus(
+                schema: shared.schema, state: warning ? .warning : .active, cause: nil,
+                automaticResume: false, retryCount: retryCount,
+                maxAutomaticRetries: maxAutomaticNetworkRetries,
+                lastProgressSignal: shared.signal, lastProgressAt: shared.timestamp,
+                stallReason: warning ? "No progress signal observed; time budget is warning-only." : nil,
+                recoveryAttempt: warning ? "Inspect runner health without terminating the operation." : nil,
+                nextAction: warning ? "Keep state resumable and inspect the stalled stage." : "Keep running.",
+                pinnedMode: shared.mode, pinnedModel: shared.model,
+                accountBinding: "pinned_unchanged", evidenceIntegrity: "preserved"
+            )
+        }
+        if cause == .transientNetwork, retryCount < maxAutomaticNetworkRetries {
+            let nextRetry = retryCount + 1
+            return OperationRecoveryStatus(
+                schema: shared.schema, state: .autoResumePending, cause: cause,
+                automaticResume: true, retryCount: nextRetry,
+                maxAutomaticRetries: maxAutomaticNetworkRetries,
+                lastProgressSignal: shared.signal, lastProgressAt: shared.timestamp,
+                stallReason: "Transient network interruption.",
+                recoveryAttempt: "Bounded automatic resume \(nextRetry)/\(maxAutomaticNetworkRetries).",
+                nextAction: "Retry the same request with the same pinned mode, model, and account binding.",
+                pinnedMode: shared.mode, pinnedModel: shared.model,
+                accountBinding: "pinned_unchanged", evidenceIntegrity: "preserved"
+            )
+        }
+        let reason = cause == .transientNetwork
+            ? "Transient network retry limit reached."
+            : "\(cause.rawValue) requires explicit user review."
+        return OperationRecoveryStatus(
+            schema: shared.schema, state: .pausedResumable, cause: cause,
+            automaticResume: false, retryCount: min(retryCount, maxAutomaticNetworkRetries),
+            maxAutomaticRetries: maxAutomaticNetworkRetries,
+            lastProgressSignal: shared.signal, lastProgressAt: shared.timestamp,
+            stallReason: reason, recoveryAttempt: nil,
+            nextAction: "Review the cause in SKS Center, then resume explicitly from the owning section.",
+            pinnedMode: shared.mode, pinnedModel: shared.model,
+            accountBinding: "pinned_unchanged", evidenceIntegrity: "preserved"
+        )
+    }
+}
+
+struct OperationSnapshot: Codable {
+    let schema: String
+    let id: String
+    let kind: String
+    let state: OperationState
+    let stage: String?
+    let progress: Double?
+    let startedAt: String
+    let updatedAt: String
+    let publicSummary: String
+    let logPath: String?
+    let retryable: Bool
+    let targetVersion: String?
+    let projectRoot: String?
+    let registry: String?
+    let recovery: OperationRecoveryStatus?
+    let providerApply: ProviderApplyProjection?
+
+    init(
+        schema: String,
+        id: String,
+        kind: String,
+        state: OperationState,
+        stage: String?,
+        progress: Double?,
+        startedAt: String,
+        updatedAt: String,
+        publicSummary: String,
+        logPath: String?,
+        retryable: Bool,
+        targetVersion: String?,
+        projectRoot: String?,
+        registry: String?,
+        recovery: OperationRecoveryStatus? = nil,
+        providerApply: ProviderApplyProjection? = nil
+    ) {
+        self.schema = schema
+        self.id = id
+        self.kind = kind
+        self.state = state
+        self.stage = stage
+        self.progress = progress
+        self.startedAt = startedAt
+        self.updatedAt = updatedAt
+        self.publicSummary = publicSummary
+        self.logPath = logPath
+        self.retryable = retryable
+        self.targetVersion = targetVersion
+        self.projectRoot = projectRoot
+        self.registry = registry
+        self.recovery = recovery
+        self.providerApply = providerApply
+    }
+}
+
+struct UpdateOperationStageSnapshot: Codable {
+    let id: String
+    let ok: Bool
+    let status: String
+    let updatedAt: String
+
+    enum CodingKeys: String, CodingKey {
+        case id, ok, status
+        case updatedAt = "updated_at"
+    }
+}
+
+struct UpdateOperationReceiptSnapshot: Codable {
+    let schema: String
+    let id: String
+    let kind: String
+    let state: String
+    let currentStage: String?
+    let startedAt: String
+    let updatedAt: String
+    let fromVersion: String
+    let targetVersion: String?
+    let previousVersion: String
+    let projectRoot: String?
+    let registry: String?
+    let rollbackCommand: String
+    let sideEffectsStarted: Bool
+    let stages: [UpdateOperationStageSnapshot]
+    let resultStatus: String?
+    let publicError: String?
+    let receiptPath: String
+
+    enum CodingKeys: String, CodingKey {
+        case schema, id, kind, state, stages
+        case currentStage = "current_stage"
+        case startedAt = "started_at"
+        case updatedAt = "updated_at"
+        case fromVersion = "from_version"
+        case targetVersion = "target_version"
+        case previousVersion = "previous_version"
+        case projectRoot = "project_root"
+        case registry
+        case rollbackCommand = "rollback_command"
+        case sideEffectsStarted = "side_effects_started"
+        case resultStatus = "result_status"
+        case publicError = "public_error"
+        case receiptPath = "receipt_path"
+    }
+}
+

package/dist/native/sks-menubar/Sources/OverviewViewController.swift

@@ -186,6 +186,7 @@ final class OverviewViewController: NSViewController, ControlCenterPage {
     private let operations: OperationCoordinator
     private let status = NativeView.detail("Loading local SKS status…")
     private let notificationInbox = NativeView.detail("Notifications: checking authorization…")
+    private let recoveryStatus = NativeView.detail("Progress recovery: no operation state loaded yet.")
     private let healthBadge = NativeView.badge("Checking local status", color: .systemBlue)
     private let statusSpinner = NativeView.spinner(label: "Checking SKS Center status")
     private var generation = 0
@@ -193,6 +194,7 @@ final class OverviewViewController: NSViewController, ControlCenterPage {
     private var doctorButton: NSButton!
     private var refreshButton: NSButton!
     private var updateCodexButton: NSButton!
+    private var reviewAndResumeButton: NSButton!
     /// Section navigation by sidebar title, wired by ControlCenterWindowController.
     var openSection: ((String) -> Void)?
 
@@ -207,6 +209,8 @@ final class OverviewViewController: NSViewController, ControlCenterPage {
         doctorButton = NativeView.button("Run Doctor", target: self, action: #selector(doctor))
         refreshButton = NativeView.button("Refresh", target: self, action: #selector(refreshStatus))
         updateCodexButton = NativeView.button("Update Codex CLI", target: self, action: #selector(updateCodexCLI))
+        reviewAndResumeButton = NativeView.button("Review & Resume…", target: self, action: #selector(reviewAndResume))
+        reviewAndResumeButton.isEnabled = false
         updateCodexButton.setAccessibilityHelp("Update the operator Codex CLI to the preferred latest channel.")
         let buttons = NativeView.row([refreshButton, doctorButton, updateCodexButton])
         let shortcuts = NativeView.row([
@@ -226,10 +230,16 @@ final class OverviewViewController: NSViewController, ControlCenterPage {
             subtitle: "Results remain available here even when macOS notifications are disabled.",
             views: [notificationInbox, shortcuts]
         )
+        let recoveryCard = NativeView.card(
+            title: "Progress, pause & recovery",
+            subtitle: "Time budgets are warnings, never automatic termination. Only transient network failures can auto-resume, at most twice. Authentication, mode, account binding, and external configuration always wait for explicit review.",
+            views: [recoveryStatus, NativeView.row([reviewAndResumeButton])]
+        )
         view = NativeView.page([
             NativeView.title("Overview"),
             NativeView.detail("Menu Bar build \(AppRuntime.packageVersion) · Local health for SKS, Codex CLI, MCP, and operations. Prefer the latest Codex CLI; SKS stays version-agnostic and capability-gates features."),
             healthCard,
+            recoveryCard,
             nextStepsCard
         ])
     }
@@ -238,6 +248,28 @@ final class OverviewViewController: NSViewController, ControlCenterPage {
     @objc private func openUpdates() { openSection?("Updates") }
     @objc private func openDiagnostics() { openSection?("Diagnostics") }
 
+    @objc private func reviewAndResume() {
+        guard let operation = operations.latestSnapshot(),
+              let recovery = operation.recovery,
+              recovery.state == .pausedResumable || recovery.state == .warning else {
+            recoveryStatus.stringValue = "No resumable pause is available. Refresh status to inspect the latest progress signal."
+            reviewAndResumeButton.isEnabled = false
+            return
+        }
+        let section: String
+        if operation.kind.localizedCaseInsensitiveContains("provider")
+            || operation.kind.localizedCaseInsensitiveContains("openrouter")
+            || operation.kind.localizedCaseInsensitiveContains("codex-lb") {
+            section = "Providers"
+        } else if operation.kind.localizedCaseInsensitiveContains("update") {
+            section = "Updates"
+        } else {
+            section = "Diagnostics"
+        }
+        recoveryStatus.stringValue = "Review opened for \(operation.kind). Confirm the unchanged mode/model/account binding, then retry from \(section). Nothing resumed automatically."
+        openSection?(section)
+    }
+
     func refreshOnAppear() {
         loadStatus(forceUpdateRefresh: false)
     }
@@ -381,6 +413,7 @@ final class OverviewViewController: NSViewController, ControlCenterPage {
     private func renderStatus(update: [String: Any]?, mcp: [String: Any]?, partial: Bool) {
         let rendered = summary(update: update, mcp: mcp)
         status.stringValue = rendered
+        renderRecoveryStatus(operations.latestSnapshot())
         if partial {
             NativeView.setBadge(healthBadge, text: "Partial status · still checking", color: .systemBlue)
         } else if rendered.localizedCaseInsensitiveContains("unavailable")
@@ -391,6 +424,30 @@ final class OverviewViewController: NSViewController, ControlCenterPage {
         }
     }
 
+    private func renderRecoveryStatus(_ operation: OperationSnapshot?) {
+        guard let operation = operation else {
+            recoveryStatus.stringValue = "Progress recovery: no operation recorded · automatic resume inactive."
+            reviewAndResumeButton.isEnabled = false
+            return
+        }
+        guard let recovery = operation.recovery else {
+            recoveryStatus.stringValue = "Progress recovery: no pause/retry decision recorded for \(operation.kind) · critical path \(operation.stage ?? "unknown") · cache evidence not reported."
+            reviewAndResumeButton.isEnabled = false
+            return
+        }
+        let cause = recovery.cause?.rawValue ?? "none"
+        let automatic = recovery.automaticResume ? "yes" : "no"
+        let mode = recovery.pinnedMode ?? "not reported"
+        let model = recovery.pinnedModel ?? "not reported"
+        let stall = recovery.stallReason.map { " · stop reason: \($0)" } ?? ""
+        let attempt = recovery.recoveryAttempt.map { " · recovery: \($0)" } ?? ""
+        recoveryStatus.stringValue = "State \(recovery.state.rawValue) · progress \(recovery.lastProgressSignal.rawValue) at \(recovery.lastProgressAt) · cause \(cause) · auto resume \(automatic) · retry \(recovery.retryCount)/\(recovery.maxAutomaticRetries) · critical path \(operation.stage ?? "unknown") · mode \(mode) · model \(model) · account \(recovery.accountBinding) · evidence \(recovery.evidenceIntegrity)\(stall)\(attempt) · next: \(recovery.nextAction)"
+        reviewAndResumeButton.isEnabled = recovery.state == .pausedResumable || recovery.state == .warning
+        reviewAndResumeButton.toolTip = reviewAndResumeButton.isEnabled
+            ? "Open the owning section for explicit review; this button never changes authentication, mode, account, or evidence."
+            : "No manual resume action is required for the current state."
+    }
+
     private func summary(update: [String: Any]?, mcp: [String: Any]?) -> String {
         let codexRunning = AppRuntime.codexBundleId.map { bundle in
             NSWorkspace.shared.runningApplications.contains { $0.bundleIdentifier == bundle }

package/dist/native/sks-menubar/Sources/ProcessClient.swift

@@ -421,7 +421,9 @@ final class ProcessClient {
     }
 
     private func sensitiveStdinValues(arguments: [String], stdin: String?) -> [String] {
-        guard arguments.contains("--api-key-stdin"), let stdin = stdin else { return [] }
+        let receivesSensitiveStdin = arguments.contains("--api-key-stdin")
+            || arguments.contains("--token-stdin")
+        guard receivesSensitiveStdin, let stdin = stdin else { return [] }
         let normalized = stdin.trimmingCharacters(in: .whitespacesAndNewlines)
         guard !normalized.isEmpty else { return [] }
         return normalized == stdin ? [normalized] : [normalized, stdin]

package/dist/native/sks-menubar/Sources/ProvidersConnectTest.swift

@@ -0,0 +1,115 @@
+import Cocoa
+
+extension ProvidersViewController {
+    func makeCliConnectProgressView() -> NSStackView {
+        cliConnectConfigurationStage.setAccessibilityLabel("Codex LB configuration stage: waiting")
+        cliConnectConfigurationStage.setAccessibilityIdentifier("sks-center-codex-lb-configuration-stage")
+        cliConnectRequestStage.setAccessibilityLabel("Codex LB one-request low-token test stage: waiting")
+        cliConnectRequestStage.setAccessibilityIdentifier("sks-center-codex-lb-request-stage")
+        cliConnectResponseStage.setAccessibilityLabel("Codex LB response stage: not received")
+        cliConnectResponseStage.setAccessibilityIdentifier("sks-center-codex-lb-response-stage")
+        cliConnectResult.setAccessibilityLabel("Codex LB connection proof result: not run")
+        cliConnectResult.setAccessibilityIdentifier("sks-center-codex-lb-connect-result")
+        let title = NativeView.sectionTitle("Connection Proof")
+        title.setAccessibilityIdentifier("sks-center-codex-lb-connect-heading")
+        let stack = NSStackView(views: [title, cliConnectProgress, cliConnectConfigurationStage, cliConnectRequestStage, cliConnectResponseStage, cliConnectResult])
+        stack.orientation = .vertical
+        stack.alignment = .width
+        stack.spacing = 6
+        stack.setAccessibilityRole(.group)
+        stack.setAccessibilityLabel("Codex LB connection proof")
+        stack.setAccessibilityIdentifier("sks-center-codex-lb-connect-proof")
+        return stack
+    }
+
+    func renderCliConnectStages(
+        progress: Double,
+        configuration: String,
+        request: String,
+        response: String,
+        result: String,
+        tone: NSColor
+    ) {
+        cliConnectProgress.doubleValue = min(3, max(0, progress))
+        cliConnectProgress.setAccessibilityValue("Stage \(Int(cliConnectProgress.doubleValue)) of 3")
+        cliConnectConfigurationStage.stringValue = "1. Configuration · \(configuration)"
+        cliConnectConfigurationStage.setAccessibilityLabel("Codex LB configuration stage: \(configuration)")
+        cliConnectRequestStage.stringValue = "2. One-request low-token test · \(request)"
+        cliConnectRequestStage.setAccessibilityLabel("Codex LB one-request low-token test stage: \(request)")
+        cliConnectResponseStage.stringValue = "3. Response · \(response)"
+        cliConnectResponseStage.setAccessibilityLabel("Codex LB response stage: \(response)")
+        cliConnectResult.stringValue = result
+        cliConnectResult.textColor = tone
+        cliConnectResult.setAccessibilityLabel("Codex LB connection proof result: \(result)")
+    }
+
+    @objc func testConnection() {
+        runConnectTest()
+    }
+
+    func runConnectTest() {
+        guard !connectTestInFlight else {
+            cliProviderStatus.stringValue = "A Codex LB connection proof is already running."
+            return
+        }
+        guard !busy else { cliProviderStatus.stringValue = "Another provider action is already running."; return }
+        guard let snapshot = operations.begin(kind: "codex-lb-connect-test", mutationGroup: nil, summary: "Run Codex LB connect test") else {
+            cliProviderStatus.stringValue = "Another guarded operation is already running. Wait or open Diagnostics."
+            return
+        }
+        connectTestInFlight = true
+        setBusy(true)
+        cliProviderStatus.stringValue = "Codex LB mode \(codexLbSelectedNow ? "selected" : "selection unconfirmed") · sending one bounded low-token request…"
+        renderCliConnectStages(
+            progress: 2,
+            configuration: codexLbSelectedNow ? "CLI provider selected" : "selection unconfirmed",
+            request: "sending one bounded request…",
+            response: "waiting",
+            result: "Waiting for structured proof. Connectivity has not been claimed.",
+            tone: .secondaryLabelColor
+        )
+        _ = operations.update(snapshot, state: .running, stage: "one-request-low-token-test", progress: 2.0 / 3.0, summary: "Run Codex LB connect test")
+        processClient.run(["codex-lb", "connect-test", "--json"], timeout: NativeView.mutationTimeout) { [weak self] result in
+            guard let self = self else { return }
+            self.connectTestInFlight = false
+            self.setBusy(false)
+            let parsed = self.json(result.output)
+            let proof = parsed.flatMap(CodexLbConnectTestTruth.success(from:))
+            let proved = result.code == 0 && proof != nil
+            _ = self.operations.update(snapshot, state: proved ? .succeeded : .failed, stage: "complete", progress: 1, summary: proved ? "Codex LB connection proved" : "Codex LB connection proof failed")
+            if let proof = proof, result.code == 0 {
+                self.codexLbSelectedNow = true
+                self.cliProviderStatus.stringValue = "Codex LB mode selected · connection proved by one live response."
+                ControlKit.setBadge(self.activeProviderBadge, text: "Codex LB · active · model \(proof.model) · \(proof.latencyMs) ms", tone: .ok)
+                self.renderCliConnectStages(
+                    progress: 3,
+                    configuration: "CLI provider selected",
+                    request: "completed · \(proof.outputTokens) output tokens",
+                    response: "received · id \(proof.responseId)",
+                    result: proof.renderedSummary,
+                    tone: .systemGreen
+                )
+                return
+            }
+            let selected = self.codexLbSelectedNow
+            let failure = parsed.map(CodexLbConnectTestTruth.validationFailure(from:))
+                ?? "structured connect-test JSON was not returned"
+            self.cliProviderStatus.stringValue = selected
+                ? "Codex LB mode is selected, but connection proof failed · \(failure)."
+                : "Codex LB connection proof failed and provider selection is unconfirmed · \(failure)."
+            if selected {
+                ControlKit.setBadge(self.activeProviderBadge, text: "Codex LB · selected · connection proof failed", tone: .warning)
+            }
+            self.renderCliConnectStages(
+                progress: 3,
+                configuration: selected ? "CLI provider remains selected" : "selection unconfirmed",
+                request: "completed without valid proof",
+                response: "failed",
+                result: selected
+                    ? "Mode is selected, but connection proof failed · \(failure). Use Run Connect Test to retry."
+                    : "Connection proof failed · \(failure). Confirm the provider, then retry.",
+                tone: .systemRed
+            )
+        }
+    }
+}

package/dist/native/sks-menubar/Sources/ProvidersFastMode.swift

@@ -0,0 +1,17 @@
+import Cocoa
+
+extension ProvidersViewController {
+    func refreshFastStatus() {
+        if !busy { fastStatus.stringValue = "Codex Fast: checking the official service-tier setting…" }
+        processClient.run(["fast-mode", "status", "--json"], timeout: NativeView.statusTimeout) { [weak self] result in
+            guard let self = self else { return }
+            guard result.code == 0, let json = self.json(result.output),
+                  let global = json["global"] as? [String: Any], let on = global["on"] as? Bool else {
+                self.fastStatus.stringValue = "Codex Fast: unavailable — no state was assumed."
+                return
+            }
+            let tier = global["service_tier"] as? String ?? (on ? "fast" : "default")
+            self.fastStatus.stringValue = "Codex Fast: \(on ? "On" : "Off") · official service_tier=\(tier) · model and reasoning remain separate."
+        }
+    }
+}

package/dist/native/sks-menubar/Sources/ProvidersMultiProvider.swift

@@ -63,6 +63,9 @@ extension ProvidersViewController {
         test.setAccessibilityHelp("Checks that the selected model exists in both the local catalog and the live loopback router. No configuration is changed.")
         activate.setAccessibilityHelp("Validates the loopback router, writes its provider and catalog settings to Codex config, and restarts Codex App. Runtime adoption still requires a live Codex check.")
         multiProvider.refreshButton = refresh
+        registerProviderAction(refresh, id: "sks-provider-refresh-router")
+        registerProviderAction(test, id: "sks-provider-test-router")
+        registerProviderAction(activate, id: "sks-provider-configure-router")
         actionButtons += [refresh, test, activate]
 
         let routerLabel = NSTextField(labelWithString: "Router URL")