sneakoscope 8.1.2 → 8.2.0

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

@@ -1,321 +1,387 @@
 import Foundation
 
-/// Parses `sks.codex-lb-status.v2` / activation payloads without treating
-/// `provider.selected` as "codex-lb is selected". In cli-provider and native-
-/// bridge modes, `provider.selected == true` means the built-in OpenAI /
-/// ChatGPT OAuth provider is selected.
-struct ProviderRoutingTruth {
-    enum MeasuredState: Equatable {
-        case inactive
-        case active
-        case degraded
-        case unverified
+enum ProviderFacadeError: Error, Equatable, CustomStringConvertible {
+    case schemaInvalid(String)
+
+    var description: String {
+        switch self { case .schemaInvalid(let reason): return reason }
     }
+}
 
-    struct MeasuredRoute {
-        let selected: Bool
-        let measured: Bool
-        let fresh: Bool
-        let ok: Bool
-        let status: String
-        let configuredHost: String?
-        let actualHost: String?
-        let authTransport: String?
-        let authOutcome: String?
-        let httpStatus: Int?
-        let measuredAt: String?
-        let latencyMs: Int?
-        let blockers: [String]
+enum CapabilityProbeState: String, Codable, CaseIterable {
+    case notAttempted = "not_attempted", running, verified, degraded, blocked, failed, unsupported, stale
+}
 
-        var active: Bool {
-            selected && measured && fresh && ok && status == "verified"
-        }
+enum CapabilityProbeStage: String, Codable {
+    case preflight, process, tcpConnect = "tcp_connect", httpHealth = "http_health"
+    case websocketUpgrade = "websocket_upgrade", websocketProtocol = "websocket_protocol"
+    case frameRoundTrip = "frame_round_trip", cleanClose = "clean_close"
+    case providerAuth = "provider_auth", catalogSync = "catalog_sync", modelRoute = "model_route"
+    case featureRequest = "feature_request", featureResponse = "feature_response"
+    case artifactValidation = "artifact_validation", complete
+}
 
-        var state: MeasuredState {
-            guard selected else { return .inactive }
-            if active { return .active }
-            if !measured || !fresh || status == "selected_unmeasured" || status == "stale" {
-                return .unverified
-            }
-            return .degraded
+enum CapabilityScope: String, Codable, CaseIterable {
+    case bridge
+    case nativeIdentity = "native-identity"
+    case codexLb = "provider:codex-lb"
+    case openRouter = "provider:openrouter"
+    case combinedCatalog = "catalog:combined"
+
+    var displayName: String {
+        switch self {
+        case .bridge: return "Bridge"
+        case .nativeIdentity: return "OAuth Identity"
+        case .codexLb: return "Codex-LB"
+        case .openRouter: return "OpenRouter"
+        case .combinedCatalog: return "Combined Catalog"
         }
     }
+}
 
-    struct Snapshot {
-        let mode: String?
-        let desktopFullRouting: Bool
-        let legacyCodexLbSelected: Bool
-        let chatgptOauthPresent: Bool
-        let cliProviderStored: Bool
-        let cliCredentialsConfigured: Bool
-        let legacyDestructive: Bool
-        let oauthPreservedFlag: Bool?
-        let authMutated: Bool?
-    }
+enum JSONValue: Codable, Equatable {
+    case string(String), number(Double), boolean(Bool), object([String: JSONValue]), array([JSONValue]), null
 
-    static func snapshot(from json: [String: Any]) -> Snapshot {
-        let mode = desktopMode(json)
-        let oauth = json["oauth"] as? [String: Any]
-        let provider = json["provider"] as? [String: Any]
-        let capabilities = json["capabilities"] as? [String: Any]
-        let bridge = json["bridge"] as? [String: Any]
-        let legacyPayload = (json["codex_lb"] as? [String: Any]) ?? json
-        let chatgptOauthPresent = json["chatgpt_oauth_present"] as? Bool
-            ?? (oauth?["present"] as? Bool == true
-                || ["chatgpt_oauth", "mixed"].contains(oauth?["mode"] as? String ?? ""))
-        let legacyCodexLbSelected = json["legacy_codex_lb_selected"] as? Bool
-            ?? isLegacyCodexLbSelected(json: json, mode: mode, provider: provider)
-        let cliProviderStored = ["cli-provider", "desktop-native-bridge", "desktop-dual-auth-compat"].contains(mode ?? "")
-            || legacyPayload["provider_configured"] as? Bool == true
-            || ((provider?["contract"] as? String)?.hasPrefix("codex-lb") == true)
-        let keyFingerprint = bridge?["key_fingerprint"] as? String
-        let cliCredentialsConfigured = legacyPayload["env_key_configured"] as? Bool == true
-            || legacyPayload["key_configured"] as? Bool == true
-            || json["configured"] as? Bool == true
-            || (keyFingerprint?.isEmpty == false)
-        let oauthPreservedFlag = (json["oauth_preserved"] as? Bool)
-            ?? (capabilities?["oauth_preserved"] as? Bool)
-            ?? (oauth?["preserved"] as? Bool)
-        return Snapshot(
-            mode: mode,
-            desktopFullRouting: mode == "desktop-native-bridge",
-            legacyCodexLbSelected: legacyCodexLbSelected,
-            chatgptOauthPresent: chatgptOauthPresent,
-            cliProviderStored: cliProviderStored,
-            cliCredentialsConfigured: cliCredentialsConfigured,
-            legacyDestructive: isLegacyDestructive(json),
-            oauthPreservedFlag: oauthPreservedFlag,
-            authMutated: json["auth_mutated"] as? Bool ?? json["desktop_auth_mutated"] as? Bool
-        )
+    init(from decoder: Decoder) throws {
+        let value = try decoder.singleValueContainer()
+        if value.decodeNil() { self = .null }
+        else if let boolean = try? value.decode(Bool.self) { self = .boolean(boolean) }
+        else if let number = try? value.decode(Double.self) { self = .number(number) }
+        else if let string = try? value.decode(String.self) { self = .string(string) }
+        else if let object = try? value.decode([String: JSONValue].self) { self = .object(object) }
+        else { self = .array(try value.decode([JSONValue].self)) }
     }
 
-    static func measuredRoute(from json: [String: Any]) -> MeasuredRoute? {
-        guard let truth = json["routing_truth"] as? [String: Any],
-              truth["schema"] as? String == "sks.codex-lb-routing-truth.v1" else {
-            return nil
+    func encode(to encoder: Encoder) throws {
+        var value = encoder.singleValueContainer()
+        switch self {
+        case .string(let raw): try value.encode(raw)
+        case .number(let raw): try value.encode(raw)
+        case .boolean(let raw): try value.encode(raw)
+        case .object(let raw): try value.encode(raw)
+        case .array(let raw): try value.encode(raw)
+        case .null: try value.encodeNil()
         }
-        return MeasuredRoute(
-            selected: truth["selected"] as? Bool == true,
-            measured: truth["measured"] as? Bool == true,
-            fresh: truth["fresh"] as? Bool == true,
-            ok: truth["ok"] as? Bool == true,
-            status: truth["status"] as? String ?? "unavailable",
-            configuredHost: truth["configured_host"] as? String,
-            actualHost: truth["actual_host"] as? String,
-            authTransport: truth["auth_transport"] as? String,
-            authOutcome: truth["auth_outcome"] as? String,
-            httpStatus: (truth["http_status"] as? NSNumber)?.intValue,
-            measuredAt: truth["measured_at"] as? String ?? truth["checked_at"] as? String,
-            latencyMs: (truth["latency_ms"] as? NSNumber)?.intValue,
-            blockers: truth["blockers"] as? [String] ?? []
-        )
     }
+}
 
-    static func desktopMode(_ json: [String: Any]) -> String? {
-        if let mode = json["desktop_mode"] as? String, !mode.isEmpty { return mode }
-        if let mode = json["mode"] as? String, !mode.isEmpty { return mode }
-        if let routing = json["desktop_routing"] as? [String: Any],
-           let mode = routing["mode"] as? String, !mode.isEmpty {
-            return mode
-        }
-        return nil
+struct CapabilityProbeResultV3: Codable, Equatable {
+    let schema: String
+    let capability: String
+    let scope: CapabilityScope
+    let requestedLevel: String
+    let stage: CapabilityProbeStage
+    let state: CapabilityProbeState
+    let checkedAt: String
+    let reportId: String
+    let correlationId: String
+    let sessionId: String
+    let attemptId: Int
+    let terminal: Bool
+    let rootCause: String?
+    let blockers: [String]
+    let warnings: [String]
+    let retryable: Bool
+    let recoveryAction: String?
+    let source: String
+    let evidence: [String: JSONValue]
+
+    enum CodingKeys: String, CodingKey {
+        case schema, capability, scope, stage, state, terminal, blockers, warnings, retryable, source, evidence
+        case requestedLevel = "requested_level", checkedAt = "checked_at", reportId = "report_id"
+        case correlationId = "correlation_id", sessionId = "session_id", attemptId = "attempt_id"
+        case rootCause = "root_cause", recoveryAction = "recovery_action"
     }
+}
 
-    private static func isLegacyCodexLbSelected(
-        json: [String: Any],
-        mode: String?,
-        provider: [String: Any]?
-    ) -> Bool {
-        if let provider = provider {
-            let id = provider["id"] as? String
-            let selected = provider["selected"] as? Bool
-            if id == "codex-lb", selected == true { return true }
-            // status.v2 marks built-in OpenAI as selected=false when model_provider is still codex-lb
-            // (legacy destructive selection). Do not treat ordinary disabled/OAuth mode as legacy.
-            if id == "openai", selected == false,
-               ["cli-provider", "desktop-native-bridge"].contains(mode ?? "") {
-                return true
-            }
-            return false
-        }
-        // Legacy status payloads used a top-level selected flag for codex-lb activation.
-        return json["selected"] as? Bool == true
+struct ScopeCapabilitySummaryV3: Codable, Equatable {
+    let schema: String
+    let scope: CapabilityScope
+    let state: CapabilityProbeState
+    let checkedAt: String
+    let capabilities: [String: CapabilityProbeResultV3]
+    let blockers: [String]
+    let warnings: [String]
+
+    enum CodingKeys: String, CodingKey { case schema, scope, state, capabilities, blockers, warnings; case checkedAt = "checked_at" }
+}
+
+struct CatalogSyncStateV2: Codable, Equatable {
+    let schema: String
+    let providerId: String
+    let state: String
+    let source: String?
+    let generation: String?
+    let digest: String?
+    let modelCount: Int?
+    let checkedAt: String?
+    let expiresAt: String?
+    let blockers: [String]
+    let warnings: [String]
+    let recoveryAction: String?
+
+    enum CodingKeys: String, CodingKey {
+        case schema, state, source, generation, digest, blockers, warnings
+        case providerId = "provider_id", modelCount = "model_count", checkedAt = "checked_at"
+        case expiresAt = "expires_at", recoveryAction = "recovery_action"
     }
+}
 
-    private static func isLegacyDestructive(_ json: [String: Any]) -> Bool {
-        if json["legacy_destructive_state"] as? Bool == true
-            || json["legacy_migration_required"] as? Bool == true {
-            return true
-        }
-        if let blockers = json["blockers"] as? [String],
-           blockers.contains(where: { $0.contains("legacy") && $0.contains("migration") }) {
-            return true
-        }
-        if let status = json["status"] as? String {
-            return status.contains("legacy") && (status.contains("required") || status.contains("destructive"))
-        }
-        return false
+struct CombinedCatalogSyncStatusV1: Codable, Equatable {
+    let schema: String
+    let state: String
+    let generation: String?
+    let digest: String?
+    let modelCount: Int?
+    let routeCount: Int?
+    let conflictCount: Int
+    let checkedAt: String?
+    let providers: [String: CatalogSyncStateV2]
+    let blockers: [String]
+    let warnings: [String]
+    let recoveryAction: String?
+
+    enum CodingKeys: String, CodingKey {
+        case schema, state, generation, digest, providers, blockers, warnings
+        case modelCount = "model_count", routeCount = "route_count", conflictCount = "conflict_count"
+        case checkedAt = "checked_at", recoveryAction = "recovery_action"
     }
 }
 
-struct CapabilityVerificationTruth {
-    static func deepEvidenceTrusted(in value: Any) -> Bool {
-        if let object = value as? [String: Any] {
-            if let validation = object["deep_evidence_validation"] as? [String: Any],
-               validation["schema"] as? String == "sks.codex-lb-deep-evidence-validation.v1",
-               validation["state"] as? String == "verified",
-               validation["trusted"] as? Bool == true,
-               (validation["blockers"] as? [Any])?.isEmpty == true { return true }
-            return object.values.contains { deepEvidenceTrusted(in: $0) }
+struct DesktopCapabilityReportV3: Codable, Equatable {
+    struct Execution: Codable, Equatable { let ok: Bool; let status: String; let blockers: [String] }
+    struct Summary: Codable, Equatable {
+        let bridgeReady: Bool
+        let activeRoutesReady: Bool
+        let levelSatisfied: Bool
+        let transportLevelSatisfied: Bool
+        let deepLevelSatisfied: Bool
+        let fullFeatureVerified: Bool
+        let inactiveProviderFailures: [String]
+        let blockers: [String]
+        let warnings: [String]
+        enum CodingKeys: String, CodingKey {
+            case blockers, warnings
+            case bridgeReady = "bridge_ready", activeRoutesReady = "active_routes_ready", levelSatisfied = "level_satisfied"
+            case transportLevelSatisfied = "transport_level_satisfied", deepLevelSatisfied = "deep_level_satisfied"
+            case fullFeatureVerified = "full_feature_verified", inactiveProviderFailures = "inactive_provider_failures"
         }
-        if let array = value as? [Any] { return array.contains { deepEvidenceTrusted(in: $0) } }
-        return false
     }
 
-    static func blockers(in value: Any) -> [String] {
-        var result: [String] = []
-        collectBlockers(value, into: &result)
-        return Array(NSOrderedSet(array: result).array.compactMap { $0 as? String })
+    let schema: String
+    let reportId: String
+    let correlationId: String
+    let sessionId: String
+    let requestedLevel: String
+    let checkedAt: String
+    let catalogGeneration: String?
+    let execution: Execution
+    let bridge: ScopeCapabilitySummaryV3
+    let nativeIdentity: ScopeCapabilitySummaryV3
+    let providers: [String: ScopeCapabilitySummaryV3]
+    let combinedCatalog: ScopeCapabilitySummaryV3
+    let summary: Summary
+    let catalogSync: CombinedCatalogSyncStatusV1
+
+    enum CodingKeys: String, CodingKey {
+        case schema, execution, bridge, providers, summary
+        case reportId = "report_id", correlationId = "correlation_id", sessionId = "session_id"
+        case requestedLevel = "requested_level", checkedAt = "checked_at", catalogGeneration = "catalog_generation"
+        case nativeIdentity = "native_identity", combinedCatalog = "combined_catalog", catalogSync = "catalog_sync"
     }
 
-    private static func collectBlockers(_ value: Any, into result: inout [String]) {
-        if let object = value as? [String: Any] {
-            if let blockers = object["blockers"] as? [String] { result.append(contentsOf: blockers) }
-            for child in object.values { collectBlockers(child, into: &result) }
-        } else if let array = value as? [Any] {
-            for child in array { collectBlockers(child, into: &result) }
-        }
+    var maximumAttemptId: Int { allProbes.map(\.attemptId).max() ?? 0 }
+    var allProbes: [CapabilityProbeResultV3] { scopeSummaries.flatMap { $0.capabilities.values } }
+    var scopeSummaries: [ScopeCapabilitySummaryV3] {
+        [bridge, nativeIdentity, providers["codex-lb"], providers["openrouter"], combinedCatalog].compactMap { $0 }
     }
-}
 
-extension ProvidersViewController {
-    func describeRoutingTruth(_ route: ProviderRoutingTruth.MeasuredRoute?) -> String {
-        guard let route = route else { return "measured route unavailable · blocker=codex_lb_routing_truth_unavailable" }
-        let host = route.actualHost ?? route.configuredHost ?? "host unavailable"
-        let auth = route.authOutcome ?? "auth unmeasured"
-        let measuredAt = route.measuredAt ?? "time unavailable"
-        let latency = route.latencyMs.map { "\($0) ms" } ?? "latency unavailable"
-        let http = route.httpStatus.map { " · HTTP \($0)" } ?? ""
-        let blockers = route.blockers.isEmpty ? "" : " · blockers=\(route.blockers.prefix(3).joined(separator: ", "))"
-        return "status=\(route.status) · host=\(host) · auth=\(auth) · measured=\(measuredAt) · latency=\(latency)\(http)\(blockers)"
+    static func decode(from json: [String: Any]) throws -> DesktopCapabilityReportV3 {
+        guard json["schema"] as? String == "sks.desktop-capabilities.v3",
+              json["catalog_sync"] is [String: Any] else {
+            throw ProviderFacadeError.schemaInvalid("capability_schema_invalid: catalog_sync missing")
+        }
+        do {
+            let report = try JSONDecoder().decode(Self.self, from: JSONSerialization.data(withJSONObject: json))
+            try report.validate()
+            return report
+        } catch let error as ProviderFacadeError { throw error }
+        catch { throw ProviderFacadeError.schemaInvalid("capability_schema_invalid: \(error)") }
     }
 
-    func renderMeasuredRoutingBadge(_ route: ProviderRoutingTruth.MeasuredRoute?, routeExpected: Bool) {
-        guard let route = route else {
-            if routeExpected {
-                ControlKit.setBadge(activeProviderBadge, text: "Codex LB · unverified · blocker=codex_lb_routing_truth_unavailable", tone: .warning)
+    private func validate() throws {
+        guard schema == "sks.desktop-capabilities.v3", !reportId.isEmpty, !correlationId.isEmpty, !sessionId.isEmpty,
+              ["shallow", "transport", "deep"].contains(requestedLevel),
+              providers["codex-lb"] != nil, providers["openrouter"] != nil,
+              bridge.scope == .bridge, nativeIdentity.scope == .nativeIdentity,
+              providers["codex-lb"]?.scope == .codexLb, providers["openrouter"]?.scope == .openRouter,
+              combinedCatalog.scope == .combinedCatalog else {
+            throw ProviderFacadeError.schemaInvalid("capability_schema_invalid")
+        }
+        guard catalogSync.schema == "sks.combined-catalog-sync.v1",
+              catalogSync.providers["codex-lb"]?.schema == "sks.catalog-sync-state.v2",
+              catalogSync.providers["openrouter"]?.schema == "sks.catalog-sync-state.v2" else {
+            throw ProviderFacadeError.schemaInvalid("capability_schema_invalid: catalog_sync invalid")
+        }
+        for scope in scopeSummaries {
+            guard scope.schema == "sks.scope-capability-summary.v1" else { throw ProviderFacadeError.schemaInvalid("capability_schema_invalid: scope summary invalid") }
+            for (key, probe) in scope.capabilities {
+                guard probe.schema == "sks.capability-probe.v3", probe.scope == scope.scope,
+                      probe.capability == key, probe.reportId == reportId,
+                      probe.correlationId == correlationId, probe.sessionId == sessionId, probe.attemptId >= 0 else {
+                    throw ProviderFacadeError.schemaInvalid("capability_schema_invalid: probe identity invalid")
+                }
             }
-            return
         }
-        guard route.selected else { return }
-        switch route.state {
-        case .active:
-            ControlKit.setBadge(activeProviderBadge, text: "Codex LB · active · \(describeRoutingTruth(route))", tone: .ok)
-        case .degraded:
-            ControlKit.setBadge(activeProviderBadge, text: "Codex LB · degraded · \(describeRoutingTruth(route))", tone: .warning)
-        case .unverified:
-            ControlKit.setBadge(activeProviderBadge, text: "Codex LB · unverified · \(describeRoutingTruth(route))", tone: .warning)
-        case .inactive:
-            break
+        let correlations = Set(allProbes.map(\.correlationId))
+        guard correlations.count == 1 else {
+            throw ProviderFacadeError.schemaInvalid("capability_schema_invalid: correlation mismatch")
+        }
+        guard catalogGeneration == catalogSync.generation else {
+            throw ProviderFacadeError.schemaInvalid("capability_schema_invalid: catalog generation mismatch")
         }
     }
 }
 
-struct CodexLbConnectTestTruth {
-    static let schema = "sks.codex-lb-connect-test.v1"
-    static let maximumAcceptedOutputTokens = 128
-    static let maximumRenderedReplyCharacters = 240
-
-    struct Success {
-        let model: String
-        let latencyMs: Int
-        let responseId: String
-        let reply: String
-        let inputTokens: Int
-        let outputTokens: Int
-        let totalTokens: Int
-        let httpStatus: Int
+struct DesktopBridgeStatusV3Truth {
+    private static let keys: Set<String> = [
+        "schema", "checked_at", "correlation_id", "management", "service",
+        "http_probe", "websocket_probe", "native_identity", "providers", "routing",
+        "catalog_sync", "capabilities", "readiness", "recovery_actions"
+    ]
+    let raw: [String: Any]
+    let checkedAt: String
+    let correlationId: String
+    let capabilities: DesktopCapabilityReportV3?
 
-        var renderedSummary: String {
-            "Model \(model) · latency \(latencyMs) ms · tokens \(inputTokens) in / \(outputTokens) out / \(totalTokens) total · reply: \(reply)"
+    static func decode(from json: [String: Any]) throws -> DesktopBridgeStatusV3Truth {
+        guard Set(json.keys) == keys,
+              json["schema"] as? String == "sks.desktop-bridge-status.v3",
+              let checkedAt = nonempty(json["checked_at"]), let correlationId = nonempty(json["correlation_id"]),
+              let management = json["management"] as? [String: Any],
+              let service = json["service"] as? [String: Any],
+              let identity = json["native_identity"] as? [String: Any],
+              let providers = json["providers"] as? [String: Any],
+              let routing = json["routing"] as? [String: Any],
+              let catalog = json["catalog_sync"] as? [String: Any],
+              let readiness = json["readiness"] as? [String: Any],
+              json["recovery_actions"] is [String] else {
+            throw ProviderFacadeError.schemaInvalid("desktop_bridge_status_schema_invalid")
         }
-    }
-
-    static func success(from json: [String: Any]) -> Success? {
-        guard validationFailure(from: json) == "none",
-              let model = nonemptyString(json["model"]),
-              let latencyMs = integer(json["latency_ms"]),
-              let responseId = nonemptyString(json["response_id"]),
-              let rawReply = nonemptyString(json["result"]),
-              let usage = json["usage"] as? [String: Any],
-              let inputTokens = integer(usage["input_tokens"]),
-              let outputTokens = integer(usage["output_tokens"]),
-              let totalTokens = integer(usage["total_tokens"]),
-              let httpStatus = integer(json["http_status"]) else { return nil }
-        return Success(
-            model: model,
-            latencyMs: latencyMs,
-            responseId: responseId,
-            reply: boundedReply(rawReply),
-            inputTokens: inputTokens,
-            outputTokens: outputTokens,
-            totalTokens: totalTokens,
-            httpStatus: httpStatus
-        )
-    }
-
-    static func validationFailure(from json: [String: Any]) -> String {
-        guard json["schema"] as? String == schema else { return "unexpected or missing schema" }
-        guard json["ok"] as? Bool == true else { return publicFailure(from: json) }
-        guard json["status"] as? String == "connected" else { return "status is not connected" }
-        guard nonemptyString(json["model"]) != nil else { return "model evidence is missing" }
-        guard let latencyMs = integer(json["latency_ms"]), latencyMs >= 0 else { return "latency evidence is invalid" }
-        guard nonemptyString(json["response_id"]) != nil else { return "response id is missing" }
-        guard nonemptyString(json["result"]) != nil else { return "returned reply is empty" }
-        guard json["result_truncated"] as? Bool != nil else { return "result bound evidence is missing" }
-        guard let httpStatus = integer(json["http_status"]), (200..<300).contains(httpStatus) else {
-            return "HTTP success evidence is invalid"
+        let managed = management["managed"] as? Bool == true
+        let managementValid = managed
+            ? management["runtime"] as? String == "desktop-bridge" && management["reason"] is NSNull
+            : management["runtime"] is NSNull && ["not_installed", "stopped"].contains(management["state"] as? String ?? "")
+        guard managementValid,
+              service["installed"] is Bool, service["loaded"] is Bool, service["running"] is Bool,
+              nonempty(service["checked_at"]) != nil, identity["configured"] is Bool,
+              routing["fallback"] as? String == "none", readiness["ready"] is Bool,
+              ["ready", "awaiting_provider", "degraded", "blocked", "unmanaged"].contains(readiness["state"] as? String ?? ""),
+              profileValid(providers["codex-lb"], id: "codex-lb"),
+              profileValid(providers["openrouter"], id: "openrouter"),
+              transportProbeValid(json["http_probe"], websocket: false),
+              transportProbeValid(json["websocket_probe"], websocket: true) else {
+            throw ProviderFacadeError.schemaInvalid("desktop_bridge_status_schema_invalid")
         }
-        guard let blockers = json["blockers"] as? [String], blockers.isEmpty else {
-            return "success blockers are not empty"
+        if let policy = routing["policy"] as? [String: Any] {
+            guard policy["schema"] as? String == "sks.bridge-routing-policy.v1", policy["fallback"] as? String == "none" else {
+                throw ProviderFacadeError.schemaInvalid("desktop_bridge_status_schema_invalid: routing policy")
+            }
+        }
+        guard let data = try? JSONSerialization.data(withJSONObject: catalog),
+              let decodedCatalog = try? JSONDecoder().decode(CombinedCatalogSyncStatusV1.self, from: data),
+              decodedCatalog.schema == "sks.combined-catalog-sync.v1" else {
+            throw ProviderFacadeError.schemaInvalid("desktop_bridge_status_schema_invalid: catalog_sync")
         }
-        guard let usage = json["usage"] as? [String: Any],
-              let inputTokens = integer(usage["input_tokens"]), inputTokens >= 0,
-              let outputTokens = integer(usage["output_tokens"]), outputTokens >= 0,
-              let totalTokens = integer(usage["total_tokens"]), totalTokens >= 0,
-              totalTokens == inputTokens + outputTokens else { return "token usage evidence is invalid" }
-        guard outputTokens <= maximumAcceptedOutputTokens else { return "low-token request evidence is invalid" }
-        return "none"
+        let report: DesktopCapabilityReportV3?
+        if json["capabilities"] is NSNull || json["capabilities"] == nil { report = nil }
+        else if let capabilities = json["capabilities"] as? [String: Any] {
+            report = try DesktopCapabilityReportV3.decode(from: capabilities)
+        } else { throw ProviderFacadeError.schemaInvalid("desktop_bridge_status_schema_invalid: capabilities") }
+        return DesktopBridgeStatusV3Truth(raw: json, checkedAt: checkedAt, correlationId: correlationId, capabilities: report)
     }
 
-    static func boundedReply(_ value: String) -> String {
-        let compact = value.split(whereSeparator: { $0.isWhitespace }).joined(separator: " ")
-        guard compact.count > maximumRenderedReplyCharacters else { return compact }
-        return String(compact.prefix(maximumRenderedReplyCharacters)) + "…"
+    private static func transportProbeValid(_ value: Any?, websocket: Bool) -> Bool {
+        if value is NSNull { return true }
+        guard let probe = value as? [String: Any] else { return false }
+        let expected: Set<String> = websocket
+            ? ["schema", "state", "terminal_stage", "root_cause", "status_code", "negotiated_protocol",
+               "upgrade_verified", "protocol_verified", "frame_round_trip_verified", "clean_close_verified",
+               "latency_ms", "blockers", "warnings"]
+            : ["schema", "state", "terminal_stage", "root_cause", "status_code", "latency_ms", "blockers", "warnings"]
+        guard Set(probe.keys) == expected,
+              probe["schema"] as? String == (websocket ? "sks.desktop-bridge-websocket-probe.v2" : "sks.desktop-bridge-http-probe.v1"),
+              let state = probe["state"] as? String,
+              let stage = probe["terminal_stage"] as? String,
+              probe["root_cause"] is NSNull || probe["root_cause"] is String,
+              probe["status_code"] is NSNull || probe["status_code"] is NSNumber,
+              probe["latency_ms"] is NSNull || probe["latency_ms"] is NSNumber,
+              probe["blockers"] is [String], probe["warnings"] is [String] else { return false }
+        if websocket {
+            guard ["not_attempted", "verified", "degraded", "blocked", "failed", "unsupported"].contains(state),
+                  ["tcp_connect", "websocket_upgrade", "websocket_protocol", "frame_round_trip", "clean_close", "complete"].contains(stage),
+                  probe["negotiated_protocol"] is NSNull || probe["negotiated_protocol"] is String,
+                  probe["upgrade_verified"] is Bool, probe["protocol_verified"] is Bool,
+                  probe["frame_round_trip_verified"] is Bool, probe["clean_close_verified"] is Bool else { return false }
+            if state == "verified" {
+                return stage == "complete" && probe["root_cause"] is NSNull
+                    && probe["upgrade_verified"] as? Bool == true
+                    && probe["protocol_verified"] as? Bool == true
+                    && probe["frame_round_trip_verified"] as? Bool == true
+                    && probe["clean_close_verified"] as? Bool == true
+            }
+            return state != "not_attempted"
+                || probe["root_cause"] is NSNull && (probe["blockers"] as? [String])?.isEmpty == true
+        }
+        guard ["verified", "blocked", "failed", "unsupported"].contains(state),
+              ["tcp_connect", "http_health", "complete"].contains(stage) else { return false }
+        return state != "verified" || stage == "complete" && probe["root_cause"] is NSNull
     }
 
-    private static func publicFailure(from json: [String: Any]) -> String {
-        if let blockers = json["blockers"] as? [String], !blockers.isEmpty {
-            return "blocked: \(blockers.prefix(3).joined(separator: ", "))"
-        }
-        if let error = nonemptyString(json["error"]) { return boundedReply(error) }
-        if let status = nonemptyString(json["status"]) { return "status=\(boundedReply(status))" }
-        return "ok was not true"
+    private static func profileValid(_ value: Any?, id: String) -> Bool {
+        guard let profile = value as? [String: Any], profile["schema"] as? String == "sks.bridge-provider-profile-status.v1",
+              profile["provider_id"] as? String == id, profile["enabled"] is Bool,
+              profile["credential"] is [String: Any], profile["endpoint"] is [String: Any],
+              let catalog = profile["catalog"] as? [String: Any],
+              let capabilities = profile["capabilities"] as? [String: Any] else { return false }
+        return catalog["schema"] as? String == "sks.catalog-sync-state.v2"
+            && capabilities["schema"] as? String == "sks.scope-capability-summary.v1"
+            && capabilities["scope"] as? String == "provider:\(id)"
     }
 
-    private static func nonemptyString(_ value: Any?) -> String? {
-        guard let raw = value as? String else { return nil }
-        let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines)
+    private static func nonempty(_ value: Any?) -> String? {
+        guard let string = value as? String else { return nil }
+        let trimmed = string.trimmingCharacters(in: .whitespacesAndNewlines)
         return trimmed.isEmpty ? nil : trimmed
     }
+}
+
+struct CapabilityDisplayRow: Equatable {
+    let scope: CapabilityScope
+    let capability: String
+    let state: CapabilityProbeState
+    let route: String
+    let oauthRequirement: String
+    let checkedAt: String
+    let stage: CapabilityProbeStage
+    let rootCause: String?
+    let recoveryAction: String?
+
+    static func rows(from report: DesktopCapabilityReportV3) -> [CapabilityDisplayRow] {
+        report.scopeSummaries.flatMap { summary in
+            summary.capabilities.keys.sorted().compactMap { key in
+                guard let probe = summary.capabilities[key] else { return nil }
+                let route = evidenceString(probe.evidence["route"]) ?? evidenceString(probe.evidence["provider_route"]) ?? "none"
+                let oauth = evidenceString(probe.evidence["oauth_requirement"]) ?? (summary.scope == .nativeIdentity ? "required" : "not required")
+                return CapabilityDisplayRow(scope: summary.scope, capability: key, state: probe.state, route: route,
+                    oauthRequirement: oauth, checkedAt: probe.checkedAt, stage: probe.stage,
+                    rootCause: probe.rootCause, recoveryAction: probe.recoveryAction)
+            }
+        }
+    }
 
-    private static func integer(_ value: Any?) -> Int? {
-        guard !(value is Bool), let number = value as? NSNumber else { return nil }
-        let double = number.doubleValue
-        guard double.isFinite,
-              double.rounded(.towardZero) == double,
-              double >= Double(Int.min),
-              double <= Double(Int.max) else { return nil }
-        return number.intValue
+    private static func evidenceString(_ value: JSONValue?) -> String? {
+        if case .string(let raw)? = value { return raw }
+        return nil
     }
 }