sneakoscope 10.3.7 → 10.3.8

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

@@ -23,6 +23,13 @@ final class ProvidersViewController: NSViewController, ControlCenterPage, NSText
     var authPriorityEnabled: Bool?
     var authPriorityBusy = false
     var authPriorityGeneration = 0
+    // OpenRouter Only shares the Default connection card; its logic lives in ProvidersOpenRouterOnly.swift.
+    let openRouterOnlyToggle = NSSwitch()
+    let openRouterOnlyStatus = NativeView.detail("Checking OpenRouter Only…")
+    let openRouterOnlyDetail = NativeView.detail("")
+    var openRouterOnlyEnabled: Bool?
+    var openRouterOnlyBusy = false
+    var openRouterOnlyGeneration = 0
     let providerStatus = NativeView.detail("Desktop Bridge status has not loaded.")
     let bridgeServiceStatus = NativeView.detail("Service: checking…")
     let bridgeHttpStatus = NativeView.detail("HTTP probe: not attempted")
@@ -116,64 +123,67 @@ final class ProvidersViewController: NSViewController, ControlCenterPage, NSText
         return NativeView.card(title: "Default connection", subtitle: "", views: [
             NativeView.row([authPriorityToggle, label]), authPriorityStatus,
             NativeView.detail("Use the saved Codex-LB connection first for eligible models. Explicit provider choices and session pins still apply.")
-        ])
+        ] + makeOpenRouterOnlyRows())
     }
 
-    func refreshAuthPriority(afterUnconfirmedMutation: Bool = false) {
-        guard !authPriorityBusy else { return }
+    func refreshAuthPriority(notice: String? = nil) {
+        guard !routingModeBusy else { return }
         authPriorityGeneration += 1
         let generation = authPriorityGeneration
         processClient.run(["bridge", "auth-priority", "status", "--json"], timeout: NativeView.statusTimeout) { [weak self] result in
-            guard let self = self, !self.authPriorityBusy, generation == self.authPriorityGeneration else { return }
+            guard let self = self, !self.routingModeBusy, generation == self.authPriorityGeneration else { return }
             guard !result.timedOut, !result.truncated,
                   let payload = self.json(result.output),
                   let priority = AuthPriorityState.decode(payload) else {
                 self.authPriorityEnabled = nil
-                self.authPriorityToggle.isEnabled = false
+                self.updateRoutingModeSwitches()
                 self.authPriorityToggle.isHidden = true
                 self.authPriorityStatus.stringValue = "Saved preference could not be confirmed. Reopen Connections to check again."
                 self.authPriorityStatus.textColor = .systemOrange
                 return
             }
             self.renderAuthPriority(priority)
-            if afterUnconfirmedMutation {
-                self.authPriorityStatus.stringValue += "\nSaved preference rechecked. The earlier operation did not finish normally."
+            if let notice = notice {
+                self.authPriorityStatus.stringValue += "\n" + notice
                 self.authPriorityStatus.textColor = .systemOrange
             }
         }
     }
 
-    private func renderAuthPriority(_ state: AuthPriorityState) {
+    func renderAuthPriority(_ state: AuthPriorityState) {
         authPriorityEnabled = state.enabled
         authPriorityToggle.isHidden = false
         authPriorityToggle.state = state.enabled ? .on : .off
-        authPriorityToggle.isEnabled = !busy && !authPriorityBusy
+        updateRoutingModeSwitches()
         authPriorityStatus.stringValue = state.message
         authPriorityStatus.textColor = state.state == "active" ? .systemGreen : state.state == "unavailable" ? .systemOrange : .secondaryLabelColor
     }
 
     @objc func toggleAuthPriority() {
-        guard !authPriorityBusy, let previous = authPriorityEnabled else { return }
+        guard !routingModeBusy, let previous = authPriorityEnabled else { return }
         let desired = authPriorityToggle.state == .on
         guard let operation = operations.begin(kind: "bridge-auth-priority", mutationGroup: "codex-config", summary: "Change Codex-LB preference") else {
             authPriorityToggle.state = previous ? .on : .off
             authPriorityStatus.stringValue = "Another configuration change is running. Try again when it finishes."
             return
         }
-        authPriorityGeneration += 1
         authPriorityBusy = true
-        authPriorityToggle.isEnabled = false
+        beginRoutingModeMutation()
         authPriorityStatus.stringValue = "Saving preference…"
         _ = operations.update(operation, state: .running, stage: "saving", progress: nil, summary: "Saving Codex-LB preference")
         processClient.run(["bridge", "auth-priority", desired ? "on" : "off", "--json"], timeout: NativeView.mutationTimeout) { [weak self] result in
             guard let self = self else { return }
             self.authPriorityBusy = false
             let payload = self.json(result.output)
+            let complete = !result.truncated && !result.timedOut
             let outcome = AuthPriorityMutationOutcome.resolve(
                 payload: payload, desired: desired,
-                commandSucceeded: result.code == 0 && payload?["ok"] as? Bool == true,
-                responseComplete: !result.truncated && !result.timedOut
+                commandSucceeded: result.code == 0 && payload?["ok"] as? Bool == true
+                    && OpenRouterOnlyReceipt.decode(payload).blockers.isEmpty,
+                responseComplete: complete
             )
+            self.renderOpenRouterOnly(from: payload, responseComplete: complete)
+            let issue = OpenRouterOnlyReceipt.decode(payload).primaryIssue.map(ProviderSecretRedactor.redact)
             let operationState: OperationState
             switch outcome {
             case .saved: operationState = .succeeded
@@ -184,17 +194,19 @@ final class ProvidersViewController: NSViewController, ControlCenterPage, NSText
             if let state = outcome.observedState {
                 self.renderAuthPriority(state)
                 if operationState != .succeeded {
-                    self.authPriorityStatus.stringValue = outcome.operationSummary + "\n" + state.message
+                    self.authPriorityStatus.stringValue = [outcome.operationSummary, issue].compactMap { $0 }.joined(separator: " · ") + "\n" + state.message
                     self.authPriorityStatus.textColor = .systemOrange
                 }
             } else {
                 self.authPriorityEnabled = nil
-                self.authPriorityToggle.isEnabled = false
+                self.updateRoutingModeSwitches()
                 self.authPriorityToggle.isHidden = true
                 self.authPriorityStatus.stringValue = "Operation result is uncertain. Checking the saved preference…"
                 self.authPriorityStatus.textColor = .systemOrange
-                self.refreshAuthPriority(afterUnconfirmedMutation: true)
             }
+            // Turning Codex-LB on turns OpenRouter Only off: re-read both modes.
+            let notice = outcome.observedState == nil ? "Saved preference rechecked. The earlier operation did not finish normally." : operationState == .succeeded ? nil : outcome.operationSummary
+            self.rereadRoutingModes(authPriorityNotice: notice, openRouterOnlyNotice: nil)
         }
     }
 
@@ -221,7 +233,7 @@ final class ProvidersViewController: NSViewController, ControlCenterPage, NSText
 
     func setBusy(_ value: Bool) {
         busy = value
-        authPriorityToggle.isEnabled = !value && !authPriorityBusy && authPriorityEnabled != nil
+        updateRoutingModeSwitches()
         for button in actionButtons where !providerButtons.values.flatMap({ $0 }).contains(where: { $0 === button }) { button.isEnabled = !value }
         value ? globalSpinner.startAnimation(nil) : globalSpinner.stopAnimation(nil)
     }
@@ -235,6 +247,12 @@ final class ProvidersViewController: NSViewController, ControlCenterPage, NSText
     func refresh() {
         refreshCredentialHealth()
         refreshAuthPriority()
+        refreshOpenRouterOnly()
+        refreshBridgeStatus()
+    }
+
+    /// Runtime, profiles, combined catalog and routes from one v3 status read.
+    func refreshBridgeStatus() {
         processClient.run(["bridge", "status", "--json"], timeout: NativeView.statusTimeout) { [weak self] result in
             guard let self = self, let json = self.json(result.output),
                   let status = try? DesktopBridgeStatusV3Truth.decode(from: json),

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

@@ -56,7 +56,7 @@ final class SettingsViewController: NSViewController, ControlCenterPage {
         )
         let contextCard = NativeView.card(
             title: "Codex 1M Context",
-            subtitle: "Allow up to 1M tokens for GPT-5.6 Sol. New sessions use this setting; running Codex restarts. Requests over 272K input tokens use the long-context rate for the entire request.",
+            subtitle: "Let every Codex model use its largest context window, up to 1M tokens. New sessions use this setting; running Codex restarts. Requests over 272K input tokens use the long-context rate for the entire request.",
             views: [NativeView.row([contextToggleButton]), contextStatus]
         )
         let notificationsCard = NativeView.card(
@@ -173,12 +173,18 @@ final class SettingsViewController: NSViewController, ControlCenterPage {
             self.contextToggleButton.title = enabled ? "Disable 1M Context" : "Enable 1M Context"
             guard !preserveStatusText else { return }
             let model = json["model"] as? String
+            let window = json["model_window"] as? [String: Any]
+            let effective = window?["effective_window"] as? Int
             var text = enabled
-                ? "Enabled · window 1,000,000 · auto-compact 900,000 · applies to new sessions only."
+                ? "Enabled · applies to new sessions only."
                 : "Disabled · Codex uses its tuned default context window."
             var tone: NSColor = enabled ? .systemGreen : .secondaryLabelColor
-            if enabled, let model = model, model != "gpt-5.6-sol" {
-                text += " Active model is \(model); the 1M window is documented for gpt-5.6-sol."
+            if let model = model, let effective = effective {
+                let size = NumberFormatter.localizedString(from: NSNumber(value: effective), number: .decimal)
+                text += enabled ? " \(model) window \(size) tokens." : " \(model) can use up to \(size) tokens."
+            }
+            if enabled, let model = model, window?["extends"] as? Bool == false {
+                text += " \(model) has a fixed window, so this setting does not enlarge it."
                 tone = .systemOrange
             }
             self.contextStatus.stringValue = text

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

@@ -5,6 +5,7 @@ import Foundation
 enum SidebarItem: String, CaseIterable {
     case overview = "Overview"
     case providers = "Providers"
+    case subagentModels = "Subagent Models"
     case remoteCoding = "Remote Coding"
     case updates = "Updates"
     case mcpServers = "MCP Servers"
@@ -19,6 +20,7 @@ enum SidebarItem: String, CaseIterable {
         switch self {
         case .overview: return "gauge"
         case .providers: return "network"
+        case .subagentModels: return "person.2"
         case .updates: return "arrow.down.circle"
         case .mcpServers: return "server.rack"
         case .localDecision: return "cpu"

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

@@ -0,0 +1,201 @@
+import Foundation
+
+/// One `available` row of `sks bridge subagent-models list --json`: an
+/// OpenRouter model the bridge catalog knows.
+struct SubagentModelOption: Equatable {
+    let publicId: String
+    let displayName: String
+    /// false for a saved or drafted model the catalog no longer lists.
+    var listed = true
+
+    var menuTitle: String {
+        guard listed else { return "\(publicId)  ·  not in the current catalog" }
+        return displayName == publicId ? publicId : "\(displayName)  ·  \(publicId)"
+    }
+}
+
+/// `subagent-models.list` / `subagent-models.set` answers: the mode with its
+/// saved list, and (when reported) the models the row popups can offer.
+struct SubagentModelsSnapshot: Equatable {
+    static let operations: Set<String> = ["subagent-models.list", "subagent-models.set"]
+
+    let mode: OpenRouterOnlyState
+    /// nil when the answer did not include `available` (keep the previous list).
+    let available: [SubagentModelOption]?
+
+    static func decode(_ payload: [String: Any]) -> SubagentModelsSnapshot? {
+        guard payload["schema"] as? String == OpenRouterOnlyCommand.resultSchema,
+              let operation = payload["operation"] as? String, operations.contains(operation),
+              let mode = OpenRouterOnlyState.decode(payload) else { return nil }
+        let result = payload["result"] as? [String: Any]
+        var seen = Set<String>()
+        let available = (result?["available"] as? [Any]).map { rows in
+            rows.compactMap { value -> SubagentModelOption? in
+                guard let row = value as? [String: Any],
+                      let id = OpenRouterOnlyJSON.text(row["public_id"]),
+                      SubagentModelRules.isModelId(id),
+                      seen.insert(id.lowercased()).inserted else { return nil }
+                return SubagentModelOption(publicId: id, displayName: OpenRouterOnlyJSON.text(row["display_name"]) ?? id)
+            }
+        }
+        return SubagentModelsSnapshot(mode: mode, available: available)
+    }
+}
+
+/// Pure edits of the unapplied list. The page keeps one draft array and
+/// always sends the complete list, never a patch.
+enum SubagentModelDraft {
+    static let effortTitles = ["Default", "low", "medium", "high", "xhigh"]
+
+    /// Popup rows: every available model, then saved or drafted models the CLI
+    /// no longer lists, so a popup never misstates a choice.
+    static func popupOptions(available: [SubagentModelOption], entries: [SubagentModelEntry]) -> [SubagentModelOption] {
+        var seen = Set(available.map { $0.publicId.lowercased() })
+        let missing = entries.filter { seen.insert($0.model.lowercased()).inserted }
+            .map { SubagentModelOption(publicId: $0.model, displayName: $0.model, listed: false) }
+        return available + missing
+    }
+
+    /// A new row takes the first available model not already on the list.
+    static func adding(_ entries: [SubagentModelEntry], available: [SubagentModelOption]) -> [SubagentModelEntry]? {
+        guard entries.count < SubagentModelRules.maxModels else { return nil }
+        let used = Set(entries.map { $0.model.lowercased() })
+        guard let next = available.first(where: { !used.contains($0.publicId.lowercased()) }) else { return nil }
+        return entries + [SubagentModelEntry(model: next.publicId, criteria: "", reasoningEffort: nil, isDefault: entries.isEmpty, routable: nil)]
+    }
+
+    static func removing(_ entries: [SubagentModelEntry], at index: Int) -> [SubagentModelEntry] {
+        guard entries.indices.contains(index) else { return entries }
+        var next = entries
+        next.remove(at: index)
+        return withOneDefault(next)
+    }
+
+    static func settingDefault(_ entries: [SubagentModelEntry], at index: Int) -> [SubagentModelEntry] {
+        guard entries.indices.contains(index) else { return entries }
+        return entries.enumerated().map { offset, entry in
+            var copy = entry
+            copy.isDefault = offset == index
+            return copy
+        }
+    }
+
+    /// Same rule as the CLI: the first default wins, else the first row.
+    static func withOneDefault(_ entries: [SubagentModelEntry]) -> [SubagentModelEntry] {
+        let first = entries.firstIndex(where: \.isDefault) ?? 0
+        return entries.enumerated().map { offset, entry in
+            var copy = entry
+            copy.isDefault = offset == first
+            return copy
+        }
+    }
+
+    static func effort(title: String?) -> String? {
+        guard let title, SubagentModelRules.efforts.contains(title) else { return nil }
+        return title
+    }
+
+    /// The CLI caps criteria at 240 UTF-16 units (JavaScript `slice`). Capping
+    /// whole characters to the same budget keeps its slice a no-op, so the
+    /// saved text reads back exactly. While typing, spaces are kept.
+    static func limitCriteria(_ text: String) -> String {
+        let limit = SubagentModelRules.maxCriteriaCharacters
+        guard text.utf16.count > limit else { return text }
+        var kept = ""
+        for character in text {
+            guard kept.utf16.count + String(character).utf16.count <= limit else { break }
+            kept.append(character)
+        }
+        return kept
+    }
+
+    /// JavaScript `\s` plus the C0 controls and DEL the CLI folds into spaces.
+    private static let criteriaSeparators: CharacterSet = {
+        var set = CharacterSet(charactersIn: "\u{0}"..."\u{20}")
+        set.insert(charactersIn: "\u{7F}\u{A0}\u{1680}\u{2028}\u{2029}\u{202F}\u{205F}\u{3000}\u{FEFF}")
+        set.insert(charactersIn: "\u{2000}"..."\u{200A}")
+        return set
+    }()
+
+    /// Same cleanup as the CLI's cleanCriteria: controls and whitespace runs
+    /// become one space, then trim and cap.
+    static func cleanCriteria(_ text: String) -> String {
+        let collapsed = text.components(separatedBy: criteriaSeparators)
+            .filter { !$0.isEmpty }
+            .joined(separator: " ")
+        return limitCriteria(collapsed)
+    }
+
+    static func normalizedForSubmit(_ entries: [SubagentModelEntry]) -> [SubagentModelEntry] {
+        withOneDefault(entries.map { entry in
+            var copy = entry.submitted
+            copy.model = entry.model.trimmingCharacters(in: .whitespacesAndNewlines)
+            copy.criteria = cleanCriteria(entry.criteria)
+            return copy
+        })
+    }
+
+    /// Local mirror of normalizeSubagentModelList; codes carry the row index.
+    static func issues(_ entries: [SubagentModelEntry]) -> [String] {
+        var seen = Set<String>()
+        var issues: [String] = []
+        for (index, entry) in entries.enumerated() {
+            let model = entry.model.trimmingCharacters(in: .whitespacesAndNewlines)
+            if !SubagentModelRules.isModelId(model) {
+                issues.append("subagent_model_id_invalid:\(index)")
+            } else if !seen.insert(model.lowercased()).inserted {
+                issues.append("subagent_model_duplicate:\(index)")
+            } else if let effort = entry.reasoningEffort, !SubagentModelRules.efforts.contains(effort) {
+                issues.append("subagent_model_effort_invalid:\(index)")
+            } else if entry.criteriaUnreadable {
+                issues.append("subagent_model_criteria_redacted:\(index)")
+            } else if index >= SubagentModelRules.maxModels {
+                issues.append("subagent_model_list_too_long:\(index)")
+            }
+        }
+        return issues
+    }
+
+    /// A redacted answer row takes the text this page already holds when that
+    /// text redacts to exactly the answer; any other redacted row stays
+    /// unreadable, and `issues` keeps it from being applied.
+    static func restoringCriteria(_ incoming: [SubagentModelEntry], known: [SubagentModelEntry], redact: (String) -> String) -> [SubagentModelEntry] {
+        incoming.map { entry in
+            guard entry.criteriaUnreadable, let match = known.first(where: {
+                $0.model.lowercased() == entry.model.lowercased() && !$0.criteriaUnreadable
+                    && (redact(cleanCriteria($0.criteria)) == entry.criteria || fitsRedacted(cleanCriteria($0.criteria), answer: entry.criteria))
+            }) else { return entry }
+            var copy = entry
+            copy.criteria = cleanCriteria(match.criteria)
+            return copy
+        }
+    }
+
+    /// The CLI and Control Center redact with different patterns; either way
+    /// each "[redacted]" stands for some text the known criteria must supply.
+    static func fitsRedacted(_ text: String, answer: String) -> Bool {
+        let marker = NSRegularExpression.escapedPattern(for: "[redacted]")
+        let pattern = "^" + NSRegularExpression.escapedPattern(for: answer).replacingOccurrences(of: marker, with: ".+?") + "$"
+        guard answer.contains("[redacted]"), let regex = try? NSRegularExpression(pattern: pattern, options: [.dotMatchesLineSeparators]) else { return false }
+        return regex.firstMatch(in: text, range: NSRange(text.startIndex..., in: text)) != nil
+    }
+
+    static func isDirty(draft: [SubagentModelEntry], saved: [SubagentModelEntry]) -> Bool {
+        normalizedForSubmit(draft) != normalizedForSubmit(saved)
+    }
+
+    /// stdin for `bridge subagent-models set --stdin --json`.
+    static func stdinPayload(_ entries: [SubagentModelEntry]) -> String? {
+        let rows: [[String: Any]] = normalizedForSubmit(entries).map { entry in
+            [
+                "model": entry.model,
+                "criteria": entry.criteria,
+                "reasoning_effort": entry.reasoningEffort.map { $0 as Any } ?? NSNull(),
+                "default": entry.isDefault
+            ]
+        }
+        guard let data = try? JSONSerialization.data(withJSONObject: ["subagent_models": rows], options: [.sortedKeys, .withoutEscapingSlashes]),
+              let text = String(data: data, encoding: .utf8) else { return nil }
+        return text + "\n"
+    }
+}