Fix Cloud sidebar shortcut and customize right sidebar tabs

Packages/macOS/CmuxSettings/Sources/CmuxSettings/Values/ShortcutAction+Defaults.swift

@@ -24,6 +24,22 @@ extension ShortcutAction {
         }
     }
 
+    /// Returns this action's factory default using a host-owned resolver.
+    ///
+    /// Chords are package-owned and therefore do not consult the resolver.
+    /// A resolver may return ``ShortcutDefaultResolver.Result/stroke(_:)`` with
+    /// `nil` to explicitly make an action unbound for the host. When it returns
+    /// ``ShortcutDefaultResolver.Result/useBuiltIn``, this method falls back to
+    /// the package table.
+    public func defaultShortcut(using resolver: ShortcutDefaultResolver) -> StoredShortcut? {
+        switch self {
+        case .diffViewerScrollToTop, .diffViewerNextFile, .diffViewerPreviousFile:
+            return defaultShortcut
+        default:
+            return defaultStroke(using: resolver).map { StoredShortcut(first: $0) }
+        }
+    }
+
     /// The factory-default ``ShortcutStroke`` for this action.
     ///
     /// Mirrors the table in
@@ -32,7 +48,24 @@ extension ShortcutAction {
     /// next to unbound rows, and so the Reset action in the Settings
     /// UI can restore a row by writing the default stroke through
     /// the JSON store.
+    ///
+    /// The package-owned default table. Hosts with dynamic defaults should use
+    /// ``defaultStroke(using:)`` and pass their resolver explicitly.
     public var defaultStroke: ShortcutStroke? {
+        return builtInDefaultStroke
+    }
+
+    /// Returns this action's stroke after applying a host-owned resolver.
+    public func defaultStroke(using resolver: ShortcutDefaultResolver) -> ShortcutStroke? {
+        switch resolver.result(for: self) {
+        case .useBuiltIn:
+            return builtInDefaultStroke
+        case .stroke(let stroke):
+            return stroke
+        }
+    }
+
+    private var builtInDefaultStroke: ShortcutStroke? {
         switch self {
         case .openSettings: return ShortcutStroke(key: ",", command: true)
         case .reloadConfiguration: return ShortcutStroke(key: ",", command: true, shift: true)

Packages/macOS/CmuxSettings/Sources/CmuxSettings/Values/ShortcutAction+LegacyDefaultResolution.swift

@@ -1,8 +1,14 @@
 extension ShortcutAction {
     /// Resolves a persisted shortcut while preserving an explicitly configured
     /// binding that predates a built-in default migration.
+    ///
+    /// - Parameters:
+    ///   - candidate: The configured shortcut, or `nil` when no override exists.
+    ///   - hostDefault: An optional host-owned default. Pass
+    ///     ``StoredShortcut/unbound`` to explicitly disable the built-in value.
     public func effectivePersistedShortcutResolvingLegacyConflicts(
         _ candidate: StoredShortcut?,
+        defaultShortcut hostDefault: StoredShortcut? = nil,
         explicitlyConfiguredShortcut: (ShortcutAction) -> StoredShortcut?,
         bindingsConflict: (
             _ proposed: StoredShortcut,
@@ -13,6 +19,7 @@ extension ShortcutAction {
     ) -> StoredShortcut? {
         effectivePersistedShortcutResolvingLegacyConflicts(
             candidate,
+            defaultShortcut: hostDefault,
             normalizing: { shortcut in
                 shortcutBindingPolicyResult(for: shortcut) == .accepted
                     ? shortcut.canonicalized()
@@ -25,8 +32,14 @@ extension ShortcutAction {
     }
 
     /// Consumer-normalized variant used by the app runtime and Settings UI.
+    ///
+    /// - Parameters:
+    ///   - candidate: The configured shortcut, or `nil` when no override exists.
+    ///   - hostDefault: An optional host-owned default. Pass
+    ///     ``StoredShortcut/unbound`` to explicitly disable the built-in value.
     public func effectivePersistedShortcutResolvingLegacyConflicts(
         _ candidate: StoredShortcut?,
+        defaultShortcut hostDefault: StoredShortcut? = nil,
         normalizing: (StoredShortcut) -> StoredShortcut?,
         conflictsWithReservedShortcut: (StoredShortcut) -> Bool,
         explicitlyConfiguredShortcut: (ShortcutAction) -> StoredShortcut?,
@@ -38,13 +51,14 @@ extension ShortcutAction {
     ) -> StoredShortcut? {
         guard let resolved = effectivePersistedShortcut(
             candidate,
+            defaultShortcut: hostDefault,
             normalizing: normalizing,
             conflictsWithReservedShortcut: conflictsWithReservedShortcut
         ) else {
             return nil
         }
         guard candidate != resolved,
-              let normalizedDefault = defaultShortcut.flatMap(normalizing),
+              let normalizedDefault = (hostDefault ?? defaultShortcut).flatMap(normalizing),
               resolved == normalizedDefault,
               let legacyAction = legacyActionDisplacingBuiltInDefault,
               let legacyShortcut = explicitlyConfiguredShortcut(legacyAction),

Packages/macOS/CmuxSettings/Sources/CmuxSettings/Values/ShortcutBindingPolicyResult.swift

@@ -72,15 +72,19 @@ extension ShortcutAction {
     ///
     /// - Parameters:
     ///   - candidate: The configured shortcut, or `nil` when no override exists.
+    ///   - hostDefault: An optional host-owned default. Pass
+    ///     ``StoredShortcut/unbound`` to explicitly disable the built-in value.
     ///   - conflictsWithReservedShortcut: Whether a normalized shortcut is reserved
     ///     by a higher-priority system-wide binding.
     /// - Returns: The executable shortcut, or `nil` when the action is unbound.
     public func effectivePersistedShortcut(
         _ candidate: StoredShortcut?,
+        defaultShortcut hostDefault: StoredShortcut? = nil,
         conflictsWithReservedShortcut: (StoredShortcut) -> Bool = { _ in false }
     ) -> StoredShortcut? {
         effectivePersistedShortcut(
             candidate,
+            defaultShortcut: hostDefault,
             normalizing: { shortcut in
                 shortcutBindingPolicyResult(for: shortcut) == .accepted
                     ? shortcut.canonicalized()
@@ -94,13 +98,16 @@ extension ShortcutAction {
     ///
     /// - Parameters:
     ///   - candidate: The configured shortcut, or `nil` when no override exists.
+    ///   - hostDefault: An optional host-owned default. Pass
+    ///     ``StoredShortcut/unbound`` to explicitly disable the built-in value.
     ///   - normalizing: Returns the executable representation of a shortcut, or
     ///     `nil` when the consumer cannot execute it.
     ///   - conflictsWithReservedShortcut: Whether a normalized shortcut is reserved
     ///     by a higher-priority system-wide binding.
     /// - Returns: The executable shortcut, or `nil` when the action is unbound.
     public func effectivePersistedShortcut(
         _ candidate: StoredShortcut?,
+        defaultShortcut hostDefault: StoredShortcut? = nil,
         normalizing: (StoredShortcut) -> StoredShortcut?,
         conflictsWithReservedShortcut: (StoredShortcut) -> Bool
     ) -> StoredShortcut? {
@@ -117,9 +124,10 @@ extension ShortcutAction {
             }
         }
 
-        guard let defaultShortcut,
-              !defaultShortcut.isUnbound,
-              let normalizedDefault = normalizing(defaultShortcut),
+        let fallback = hostDefault ?? defaultShortcut
+        guard let fallback,
+              !fallback.isUnbound,
+              let normalizedDefault = normalizing(fallback),
               !conflictsWithReservedShortcut(normalizedDefault) else {
             return nil
         }

Packages/macOS/CmuxSettings/Sources/CmuxSettings/Values/ShortcutDefaultResolver.swift

@@ -0,0 +1,36 @@
+/// Resolves host-specific shortcut defaults without shared mutable state.
+///
+/// The settings package owns the built-in table, but a host may have a more
+/// specific default. For example, cmux assigns right-sidebar digit shortcuts
+/// from the visible tab order. The host constructs one resolver at its
+/// composition root and passes it to the settings owner that needs it. A
+/// resolver is a value, so previews and multiple hosts can use different
+/// defaults in the same process without affecting one another.
+public struct ShortcutDefaultResolver: Sendable {
+    /// The result of resolving one action's host default.
+    public enum Result: Sendable {
+        /// Use the package's built-in default.
+        case useBuiltIn
+        /// Use `stroke`; `nil` explicitly means the action is unbound.
+        case stroke(ShortcutStroke?)
+    }
+
+    /// A host callback that computes a default from current host state.
+    public typealias Provider = @Sendable (ShortcutAction) -> Result
+
+    private let provider: Provider
+
+    /// Creates a resolver backed by `provider`.
+    public init(provider: @escaping Provider) {
+        self.provider = provider
+    }
+
+    /// A resolver that always uses the package's built-in defaults.
+    public static let builtIn = Self(provider: { _ in .useBuiltIn })
+
+    /// Resolves `action`, falling back to ``Result/useBuiltIn`` when the host
+    /// provider has no override.
+    func result(for action: ShortcutAction) -> Result {
+        provider(action)
+    }
+}

Packages/macOS/CmuxSettings/Tests/CmuxSettingsTests/ShortcutActionNumberedDigitTests.swift

@@ -79,4 +79,44 @@ struct ShortcutActionNumberedDigitTests {
         #expect(!ShortcutAction.fileExplorerOpenSelection.allowsChordShortcut)
         #expect(!ShortcutAction.fileExplorerOpenSelectionFinderAlias.allowsChordShortcut)
     }
+
+    @Test func hostDefaultResolversDoNotShareState() {
+        let first = ShortcutDefaultResolver { action in
+            action == .switchRightSidebarToFiles
+                ? .stroke(ShortcutStroke(key: "7", control: true))
+                : .useBuiltIn
+        }
+        let second = ShortcutDefaultResolver { action in
+            action == .switchRightSidebarToFiles
+                ? .stroke(ShortcutStroke(key: "2", control: true))
+                : .useBuiltIn
+        }
+
+        #expect(
+            ShortcutAction.switchRightSidebarToFiles.defaultStroke(using: first)
+                == ShortcutStroke(key: "7", control: true)
+        )
+        #expect(
+            ShortcutAction.switchRightSidebarToFiles.defaultStroke(using: second)
+                == ShortcutStroke(key: "2", control: true)
+        )
+        #expect(
+            ShortcutAction.switchRightSidebarToFiles.defaultStroke(using: first)
+                == ShortcutStroke(key: "7", control: true)
+        )
+        #expect(
+            ShortcutAction.openSettings.defaultStroke(using: first)
+                == ShortcutAction.openSettings.defaultStroke
+        )
+    }
+
+    @Test func explicitHostUnboundDefaultDoesNotFallBackToBuiltIn() {
+        let hostDefault = StoredShortcut.unbound
+        let resolved = ShortcutAction.switchRightSidebarToFiles.effectivePersistedShortcut(
+            nil,
+            defaultShortcut: hostDefault
+        )
+
+        #expect(resolved == nil)
+    }
 }

Packages/macOS/CmuxSettingsUI/Sources/CmuxSettingsUI/Bindings/ShortcutListModel+Resolution.swift

@@ -12,6 +12,10 @@ extension ShortcutListModel {
         }
         return action.effectivePersistedShortcutResolvingLegacyConflicts(
             candidate,
+            // The policy's optional means "use the package default". Convert
+            // a resolver's explicit nil stroke to the persisted unbound marker
+            // so a hidden host action cannot silently regain its built-in key.
+            defaultShortcut: action.defaultShortcut(using: defaultShortcutResolver) ?? .unbound,
             normalizing: { shortcut in
                 guard action.shortcutBindingPolicyResult(for: shortcut) == .accepted else {
                     return nil

Packages/macOS/CmuxSettingsUI/Sources/CmuxSettingsUI/Bindings/ShortcutListModel.swift

@@ -36,6 +36,10 @@ final class ShortcutListModel {
     @ObservationIgnored let errorLog: SettingsErrorLog
     @ObservationIgnored let onShortcutsChanged: @MainActor () -> Void
     @ObservationIgnored let canRegisterSystemWideHotkey: @MainActor (StoredShortcut) -> Bool
+    /// Host-owned, value-typed factory defaults. Each model retains its own
+    /// resolver, so separate settings windows and previews cannot overwrite
+    /// one another's defaults.
+    @ObservationIgnored let defaultShortcutResolver: ShortcutDefaultResolver
     @ObservationIgnored private let bindingsDriver = SettingReadDriver<ShortcutBindingsSnapshot>()
     @ObservationIgnored private let legacyBindingsDriver = SettingReadDriver<[String: StoredShortcut]>()
     @ObservationIgnored private let whenDriver = SettingReadDriver<[String: String]>()
@@ -52,6 +56,7 @@ final class ShortcutListModel {
         canRegisterSystemWideHotkey: @escaping @MainActor (StoredShortcut) -> Bool = {
             ShortcutAction.showHideAllWindows.shortcutBindingPolicyResult(for: $0) == .accepted
         },
+        defaultShortcutResolver: ShortcutDefaultResolver = .builtIn,
         onShortcutsChanged: @escaping @MainActor () -> Void = {}
     ) {
         self.jsonStore = jsonStore
@@ -60,6 +65,7 @@ final class ShortcutListModel {
         self.catalog = catalog
         self.errorLog = errorLog
         self.canRegisterSystemWideHotkey = canRegisterSystemWideHotkey
+        self.defaultShortcutResolver = defaultShortcutResolver
         self.onShortcutsChanged = onShortcutsChanged
     }
 

Packages/macOS/CmuxSettingsUI/Sources/CmuxSettingsUI/Environment/SettingsHostActions.swift

@@ -127,6 +127,28 @@ public protocol SettingsHostActions: AnyObject {
     @discardableResult
     func setSidebarFontSize(_ points: Double) async -> Bool
 
+    /// The customizable right-sidebar tabs in the user's order, hidden tabs
+    /// included. Backed by host-owned mode metadata and tab preferences the
+    /// package cannot read; empty when the host has no right sidebar
+    /// (previews/tests).
+    func rightSidebarTabs() -> [RightSidebarTabSettingsItem]
+
+    /// Shows or hides one right-sidebar tab.
+    ///
+    /// - Returns: `false` when the host refused the change (hiding the last
+    ///   visible tab); the card re-reads state so the toggle snaps back.
+    @discardableResult
+    func setRightSidebarTabVisible(id: String, visible: Bool) -> Bool
+
+    /// Moves one right-sidebar tab by `offset` within the ordered tab list
+    /// (negative is toward the front). Hidden tabs keep their slot.
+    func moveRightSidebarTab(id: String, offset: Int)
+
+    /// Yields a fresh tab list whenever the tabs change from any entrypoint
+    /// (this card, the mode bar's context menu, shortcut rebinds that change
+    /// the displayed digit hints).
+    func rightSidebarTabsUpdates() -> AsyncStream<[RightSidebarTabSettingsItem]>
+
     /// The current workspace tab-bar font size with its range + default.
     /// Backed by the Ghostty config file (`surface-tab-bar-font-size`).
     func surfaceTabBarFontSize() -> SettingsFontSize
@@ -287,6 +309,31 @@ public struct CloudMachinesPlanSummary: Equatable, Sendable {
     }
 }
 
+/// One right-sidebar tab as the Sidebar section's customization card renders
+/// it. `id` is the host's stable mode identifier (the mode raw value).
+public struct RightSidebarTabSettingsItem: Identifiable, Equatable, Sendable {
+    public let id: String
+    public let title: String
+    public let symbolName: String
+    public let isVisible: Bool
+    /// Resolved switch-shortcut label (e.g. `⌃4`); empty when unbound.
+    public let shortcutLabel: String
+
+    public init(
+        id: String,
+        title: String,
+        symbolName: String,
+        isVisible: Bool,
+        shortcutLabel: String
+    ) {
+        self.id = id
+        self.title = title
+        self.symbolName = symbolName
+        self.isVisible = isVisible
+        self.shortcutLabel = shortcutLabel
+    }
+}
+
 public extension SettingsHostActions {
     /// Returns the registry-backed agent choices shown by notification sound settings.
     func notificationSoundAgentOptions() -> [NotificationSoundAgentOption] { [] }
@@ -297,6 +344,16 @@ public extension SettingsHostActions {
     /// Default no-op for previews and tests without a live control socket.
     func socketControlConfigurationDidChange() {}
 
+    /// Right-sidebar tab defaults for previews, tests, and package-only
+    /// hosts: no tabs, refuse mutations, no updates.
+    func rightSidebarTabs() -> [RightSidebarTabSettingsItem] { [] }
+    @discardableResult
+    func setRightSidebarTabVisible(id: String, visible: Bool) -> Bool { false }
+    func moveRightSidebarTab(id: String, offset: Int) {}
+    func rightSidebarTabsUpdates() -> AsyncStream<[RightSidebarTabSettingsItem]> {
+        AsyncStream { $0.finish() }
+    }
+
     /// Cloud Machines defaults for previews, tests, and package-only hosts:
     /// unavailable, no plan, no-op actions.
     var isCloudMachinesAvailable: Bool { false }

Packages/macOS/CmuxSettingsUI/Sources/CmuxSettingsUI/Environment/SettingsRuntime.swift

@@ -28,6 +28,8 @@ public struct SettingsRuntime: @unchecked Sendable {
     public let accountFlow: AccountFlow?
     /// Host callbacks for actions the package cannot perform itself.
     public let hostActions: SettingsHostActions
+    /// Host-scoped factory-default resolver for dynamic shortcut actions.
+    public let shortcutDefaultResolver: ShortcutDefaultResolver
 
     /// Creates the settings runtime bundle injected into the settings UI.
     ///
@@ -39,6 +41,8 @@ public struct SettingsRuntime: @unchecked Sendable {
     ///   - errorLog: Rolling settings error log displayed as alerts.
     ///   - accountFlow: Optional host-owned account flow actions.
     ///   - hostActions: Host callbacks for actions the package cannot perform itself.
+    ///   - shortcutDefaultResolver: Value-typed defaults supplied by the host;
+    ///     defaults to the package table for previews and package-only hosts.
     ///   - searchIndex: Prebuilt search index to share across settings roots. When `nil`,
     ///     the runtime builds one index from `catalog` and keeps it for its own lifetime.
     @MainActor
@@ -50,6 +54,7 @@ public struct SettingsRuntime: @unchecked Sendable {
         errorLog: SettingsErrorLog,
         accountFlow: AccountFlow? = nil,
         hostActions: SettingsHostActions = NoopSettingsHostActions(),
+        shortcutDefaultResolver: ShortcutDefaultResolver = .builtIn,
         searchIndex: SettingsSearchIndex? = nil
     ) {
         self.catalog = catalog
@@ -60,6 +65,7 @@ public struct SettingsRuntime: @unchecked Sendable {
         self.errorLog = errorLog
         self.accountFlow = accountFlow
         self.hostActions = hostActions
+        self.shortcutDefaultResolver = shortcutDefaultResolver
     }
 }