cmux NEXT: a tab an agent needs you in shows the blue dot, the ring and why (carries #24311)

Packages/macOS/CmuxNext/Sources/CmuxNextActions/ActionInvocation.swift

@@ -48,6 +48,8 @@ public nonisolated enum ActionOrigin: String, Sendable, Hashable, CaseIterable {
 /// CLI `--target`, or nil for "the focused one") and the collected arguments.
 public nonisolated struct ActionInvocation: Sendable, Hashable {
     public var target: ActionTargetRef?
+    /// Namespace of a native menu's target. It identifies its owner, never grants authority.
+    public var targetMachineID: String?
     public var arguments: [String: ActionValue]
     /// In-app runs are the user's; the control socket sets its caller's.
     public var origin: ActionOrigin

Packages/macOS/CmuxNext/Sources/CmuxNextActions/ActionRegistry+Menus.swift

@@ -25,6 +25,18 @@ extension ActionRegistry {
 }
 
 extension ActionRegistry {
+    /// Binds one menu action to the machine that supplied its native target. Other items keep
+    /// their ordinary invocation; no synthetic argument leaks into their handlers.
+    public func scopeMenuAction(_ menu: NSMenu, action: ActionID, toMachine machineID: String) {
+        for item in menu.items {
+            if let payload = item.representedObject as? ActionMenuPayload, payload.id == action {
+                payload.targetMachineID = machineID
+                if let title = self.action(for: action)?.targetTitle?(payload.invocation(in: self)) { item.title = title }
+            }
+            if let submenu = item.submenu { scopeMenuAction(submenu, action: action, toMachine: machineID) }
+        }
+    }
+
     /// The action, target and arguments a generated menu item runs (nil
     /// for items the registry did not make). Callers that retitle a row
     /// (Search Google for "…") and tests read it.
@@ -39,6 +51,7 @@ extension ActionRegistry {
 final class ActionMenuPayload: NSObject {
     let id: ActionID
     let target: ActionTargetRef?
+    var targetMachineID: String?
     let arguments: [String: ActionValue]
     /// Focus facts the right-clicked object stands in for (`ActionRegistry.impliedContext(for:)`):
     /// the item is enabled and runs with them added to the window's context, the same facts
@@ -55,6 +68,7 @@ final class ActionMenuPayload: NSObject {
     /// The run of this item in `registry`'s context, plus the implied facts.
     func invocation(in registry: ActionRegistry, withArguments: Bool = true) -> ActionInvocation {
         var invocation = ActionInvocation(target: target, arguments: withArguments ? arguments : [:])
+        invocation.targetMachineID = targetMachineID
         if !implied.isEmpty { invocation.keyContext = registry.context.union(implied) }
         return invocation
     }
@@ -84,7 +98,9 @@ final class ActionMenuTarget: NSObject, NSMenuItemValidation {
         if menuItem.isHidden { return false }
         // A standalone key window claims the run: its close items stay
         // enabled (they close it), actions on main window content are off.
-        let invocation = ActionInvocation(target: payload.target, arguments: payload.arguments)
+        var invocation = ActionInvocation(target: payload.target, arguments: payload.arguments)
+        // A row scoped to its target's machine (``scopeMenuAction``) validates against that machine, as it runs.
+        invocation.targetMachineID = payload.targetMachineID
         // A main menu toggle reads as the change it makes for the focused target (Pin
         // Workspace or Unpin Workspace, PINNED-ITEMS-END-TO-END); no target title, the
         // catalog's. Context menu items (an ActionMenuPayload) are decorated when built.

Packages/macOS/CmuxNext/Sources/CmuxNextApp/ActionRouting.swift

@@ -18,6 +18,13 @@ enum ActionRouting {
             let routed = daemon(for: invocation, daemons: services.machines.daemons) { windowID in
                 windows.first { $0.state.id == windowID }.flatMap { services.machines.daemon(machine: $0.state.machineID) }
             }
+            // A native context menu carries an explicit machine owner. If that
+            // machine disappeared while the menu was open, refuse the action;
+            // falling back to the active daemon could mutate a same-ID tab here.
+            if invocation.targetMachineID != nil, routed == nil {
+                services.registry.refuseNotFound("The target machine is no longer connected.")
+                return
+            }
             let previous = services.routedDaemon
             services.routedDaemon = routed ?? previous
             body()
@@ -30,6 +37,7 @@ enum ActionRouting {
     /// object's". `windowMachine` maps a window id to its machine's daemon.
     static func daemon(for invocation: ActionInvocation, daemons: [DaemonService],
                        windowMachine: (String) -> DaemonService?) -> DaemonService? {
+        if let machine = invocation.targetMachineID { return daemons.first { $0.machineID == machine } }
         let arguments = ["workspace", "tab", "pane", "group"].compactMap { invocation[$0]?.targetValue }
         guard let target = invocation.target ?? arguments.first else { return nil }
         switch target.kind {

Packages/macOS/CmuxNext/Sources/CmuxNextApp/ActionScope.swift

@@ -45,6 +45,10 @@ struct ActionScope {
 
     var workspace: WorkspaceModel? {
         if let target = invocation.target ?? invocation["workspace"]?.targetValue, target.kind == .workspace {
+            if let machine = invocation.targetMachineID {
+                return services.machines.daemon(machine: machine)?.store.workspaces.first { $0.id == target.id }
+                    ?? notFound(RefusalStrings.noWorkspace(target.id))
+            }
             return services.workspace(id: target.id) ?? notFound(RefusalStrings.noWorkspace(target.id))
         }
         return window?.state.workspaceID.flatMap(services.workspace(id:))

Packages/macOS/CmuxNext/Sources/CmuxNextApp/Handlers/AppActionContext+Targets.swift

@@ -175,6 +175,13 @@ extension AppActionContext {
     /// The targeted daemon tab, found in any workspace (shown or not).
     func daemonTab(_ invocation: ActionInvocation) -> (tab: TabModel, pane: PaneModel)? {
         if let target = explicitTarget(invocation, kinds: [.tab]) {
+            if let machine = invocation.targetMachineID {
+                guard let store = services.machines.daemon(machine: machine)?.store,
+                      let tab = store.tab(idOrResource: target.id), let pane = store.pane(holding: tab) else {
+                    return notFound(RefusalStrings.noTab(target.id))
+                }
+                return (tab, pane)
+            }
             return services.locateTab(target.id) ?? notFound(RefusalStrings.noTab(target.id))
         }
         guard let (pane, id) = tab(invocation) else { return nil }

Packages/macOS/CmuxNext/Sources/CmuxNextApp/Notifications/DebugNotifications.swift

@@ -73,7 +73,9 @@ enum DebugNotifications {
             "log": .array(center.log.map(JSONValue.string)),
             "feed_log": .array((center.feedDriver?.log ?? []).map(JSONValue.string)),
             "dock_badge": center.dockBadge.label.map(JSONValue.string) ?? .null,
-            "dismissed_highlights": .object(center.dismissedHighlights.mapValues { .number(Double($0)) }),
+            "dismissed_highlights": .object(Dictionary(uniqueKeysWithValues: center.dismissedHighlights.map { key, value in
+                ("\(key.machine):\(key.session ?? ""):\(key.id)", .number(Double(value)))
+            })),
             "highlight_look": .string(AttentionHighlightLook.tunable.value.rawValue),
             "preferences": [
                 "dismissal": .string(prefs.dismissal.rawValue), "desktop": .string(prefs.desktop.rawValue),

Packages/macOS/CmuxNext/Sources/CmuxNextApp/Notifications/NotificationCenterService+Lookup.swift

@@ -142,8 +142,8 @@ extension NotificationCenterService {
                         shownTab: @MainActor (PaneModel) -> String? = { _ in nil }) -> [LayoutPaneID: AttentionMark] {
         let attention = DesignSettings.shared.attention
         guard attention.style != .none, !preferences.mutedWorkspaces.contains(workspace.id) else { return [:] }
-        let sameSession = dismissedHighlightSession == services?.daemon.identity?.session
-        let dismissed = sameSession ? dismissedHighlights[workspace.id] ?? 0 : 0
+        let key = highlightKey(for: workspace)
+        let dismissed = dismissedHighlights[key] ?? 0
         var marks: [LayoutPaneID: AttentionMark] = [:]
         for screen in workspace.screens {
             for pane in screen.panes {
@@ -153,7 +153,7 @@ extension NotificationCenterService {
                 let agentChat = shown.agentSession != nil
                 guard attention.rings(agentChat: agentChat) else { continue }
                 // An agent chat whose turn ended rings until the person goes into it.
-                if let finished = agentFinished[shown.id] {
+                if key.machine == MachineRegistry.localID, let finished = agentFinished[shown.id] {
                     marks[LayoutPaneID(pane.id)] = AttentionMark(color: preferences.sources[.agent]?.color, generation: finished,
                                                                  agentChat: agentChat, quiet: quietAgentFinishes.contains(shown.id))
                     continue
@@ -178,12 +178,20 @@ extension NotificationCenterService {
             let generation = tab.notification?.notification.rawValue ?? 1
             if generation > dismissed { return generation }
         }
-        guard tab.markedUnread, tab.markedUnreadGeneration > (dismissedMarks[tab.id] ?? 0) else { return nil }
-        return Self.markRingBase | tab.markedUnreadGeneration
+        if tab.markedUnread, tab.markedUnreadGeneration > (dismissedMarks[highlightKey(for: tab)] ?? 0) {
+            return Self.markRingBase | tab.markedUnreadGeneration
+        }
+        // An agent's "needs you here" mark (tab-attention-v1) rings until Dismiss Highlight hides
+        // that request; a different owner-issued request rings again.
+        guard tab.attention != nil,
+              tab.attentionRingHiddenThrough.map({ $0 != tab.attentionGeneration }) ?? true else { return nil }
+        return Self.markRingBase | Self.attentionRingBase | (tab.attentionGeneration & ~(Self.markRingBase | Self.attentionRingBase))
     }
 
     /// The bit a marked tab's ring generation carries, apart from notification ids.
     static let markRingBase: UInt64 = 1 << 63
+    /// The bit an agent's attention ring carries, apart from manual marks.
+    static let attentionRingBase: UInt64 = 1 << 62
 
     /// Of the panes in `removed` (their mark just went away), those read because
     /// the person went into them: their ring blinks out. Forgets the entry
@@ -211,24 +219,38 @@ extension NotificationCenterService {
         !attentionMarks(for: workspace).isEmpty
     }
 
+    private func highlightKey(for workspace: WorkspaceModel) -> HighlightKey {
+        let daemon = services?.machines.daemons.first { $0.store.workspace(id: workspace.id) === workspace }
+        return HighlightKey(machine: daemon?.machineID ?? MachineRegistry.localID,
+                            session: daemon?.identity?.session, id: workspace.id)
+    }
+
+    private func highlightKey(for tab: TabModel) -> HighlightKey {
+        let daemon = services?.machines.daemon(forTab: tab)
+        return HighlightKey(machine: daemon?.machineID ?? MachineRegistry.localID,
+                            session: daemon?.identity?.session, id: tab.id)
+    }
+
     /// Dismiss Highlight (cx-epgo): hides `workspace`'s attention rings
     /// until a newer notification arrives or a tab is marked unread again.
     /// The tabs stay unread (the tab dot, the row badge and the Dock badge
     /// keep them).
     func dismissHighlight(_ workspace: WorkspaceModel) {
         let tabs = workspace.screens.flatMap(\.panes).flatMap(\.tabs)
         let newest = tabs.filter(\.hasUnread).map { $0.notification?.notification.rawValue ?? 1 }.max() ?? 0
-        let session = services?.daemon.identity?.session
-        if session != dismissedHighlightSession {
-            dismissedHighlights = [:]
-            dismissedHighlightSession = session
+        let key = highlightKey(for: workspace)
+        // A restarted daemon has new notification IDs; discard only that machine's old session.
+        dismissedHighlights = dismissedHighlights.filter { $0.key.machine != key.machine || $0.key.session == key.session }
+        dismissedMarks = dismissedMarks.filter { $0.key.machine != key.machine || $0.key.session == key.session }
+        if key.machine == MachineRegistry.localID {
+            for tab in tabs where agentFinished[tab.id] != nil { agentFinished[tab.id] = nil; quietAgentFinishes.remove(tab.id) }
         }
-        for tab in tabs where agentFinished[tab.id] != nil { agentFinished[tab.id] = nil; quietAgentFinishes.remove(tab.id) }
-        for tab in tabs where tab.markedUnread && dismissedMarks[tab.id] != tab.markedUnreadGeneration {
-            dismissedMarks[tab.id] = tab.markedUnreadGeneration
+        for tab in tabs where tab.markedUnread {
+            dismissedMarks[highlightKey(for: tab)] = tab.markedUnreadGeneration
         }
-        guard newest > (dismissedHighlights[workspace.id] ?? 0) else { return }
-        dismissedHighlights[workspace.id] = newest
+        for tab in tabs where tab.attention != nil { tab.attentionRingHiddenThrough = tab.attentionGeneration }
+        guard newest > (dismissedHighlights[key] ?? 0) else { return }
+        dismissedHighlights[key] = newest
         note("highlight dismissed workspace=\(workspace.id) through=\(newest)")
     }
 }

Packages/macOS/CmuxNext/Sources/CmuxNextApp/Notifications/NotificationCenterService+StripPress.swift

@@ -16,6 +16,8 @@ extension NotificationCenterService {
         /// The pane's selected tab once the press was dispatched (the one it selected), taken then:
         /// by the mouse-up a close under the press has already selected a neighbor.
         let tab: String
+        /// The exact tab and store pressed; its window can show another workspace before release.
+        let target: TabInteractionTarget?
         /// Where it went down (screen coordinates; a torn-off tab's mouse-up comes in another window).
         let screenLocation: NSPoint
         /// The pointer went past the tab drag distance at some point: a drag, even if it came back.
@@ -25,8 +27,8 @@ extension NotificationCenterService {
     /// A strip press began on `tab` at `screenLocation`. A press whose mouse-up a tracking loop took
     /// before this ran (the titlebar row's window drag, `WindowTitlebar`) is already over: it
     /// resolves now, from where the pointer is. The app's own input has no hardware button to ask.
-    func beginStripPress(tab: String, at screenLocation: NSPoint, synthetic: Bool) {
-        stripPress = StripPress(tab: tab, screenLocation: screenLocation)
+    func beginStripPress(tab: String, target: TabInteractionTarget?, at screenLocation: NSPoint, synthetic: Bool) {
+        stripPress = StripPress(tab: tab, target: target, screenLocation: screenLocation)
         viewHolds.insert(tab)
         if !synthetic, !leftButtonIsDown() { noteMouseUp(in: nil, at: pointerLocation()) }
     }
@@ -51,7 +53,7 @@ extension NotificationCenterService {
         if press.dragged || Self.beyondDragDistance(up, press.screenLocation) { return }
         // A click: the hold ends here, also for a tab the click closed (no tab left to read).
         viewHolds.remove(press.tab)
-        interacted(.click, tabID: press.tab)
+        if let target = press.target { interacted(.click, target: target) }
     }
 
     /// The person's next input after a move (a key-down; a press calls it too): every hold ends,