fix: shellstate-unknown-race (issue manaflow-ai#6618) [salvaged from ultracode worktree] (#31)

Author: arzafran

Sources/TabManager.swift

@@ -2750,13 +2750,19 @@ class TabManager: ObservableObject {
         )
     }
 
+    /// Updates the shell-activity state for a surface.
+    ///
+    /// - Returns: `true` if the update was applied (workspace and panel both exist and
+    ///   state changed), `false` otherwise. Callers that deduplicate reports MUST only
+    ///   record the state in their dedup dict when this returns `true`.
+    @discardableResult
     func updateSurfaceShellActivity(
         tabId: UUID,
         surfaceId: UUID,
         state: Workspace.PanelShellActivityState
-    ) {
-        guard let tab = tabs.first(where: { $0.id == tabId }) else { return }
-        tab.updatePanelShellActivityState(panelId: surfaceId, state: state)
+    ) -> Bool {
+        guard let tab = tabs.first(where: { $0.id == tabId }) else { return false }
+        return tab.updatePanelShellActivityState(panelId: surfaceId, state: state)
     }
 
     private func normalizeDirectory(_ directory: String) -> String {

Sources/TerminalController.swift

@@ -458,21 +458,37 @@ class TerminalController {
             }
         }
 
+        /// Returns `true` when the incoming state differs from the last *applied* state,
+        /// meaning the report is worth dispatching to the main thread.
+        ///
+        /// This method only reads the dedup dict; it does NOT record the new state.
+        /// Call `recordShellActivity` after the update is confirmed applied on the main
+        /// thread so that a failed apply (panel absent) never suppresses the next
+        /// identical report.
         func shouldPublishShellActivity(
             workspaceId: UUID,
             panelId: UUID,
             state: Workspace.PanelShellActivityState
         ) -> Bool {
             let key = SocketSurfaceKey(workspaceId: workspaceId, panelId: panelId)
             return queue.sync {
-                if lastReportedShellStates[key] == state {
-                    return false
-                }
-                if lastReportedShellStates.count >= maxTrackedShellStates {
-                    lastReportedShellStates.removeAll(keepingCapacity: true)
+                lastReportedShellStates[key] != state
+            }
+        }
+
+        /// Records that the given state was successfully applied to the given panel.
+        /// Must be called only when `updateSurfaceShellActivity` returned `true`.
+        func recordShellActivity(
+            workspaceId: UUID,
+            panelId: UUID,
+            state: Workspace.PanelShellActivityState
+        ) {
+            let key = SocketSurfaceKey(workspaceId: workspaceId, panelId: panelId)
+            queue.async {
+                if self.lastReportedShellStates.count >= self.maxTrackedShellStates {
+                    self.lastReportedShellStates.removeAll(keepingCapacity: true)
                 }
-                lastReportedShellStates[key] = state
-                return true
+                self.lastReportedShellStates[key] = state
             }
         }
     }
@@ -15366,16 +15382,35 @@ class TerminalController {
         }
 
         if let scope = Self.explicitSocketScope(options: parsed.options) {
+            // Fast-path check: skip dispatch if we already know this state is current.
+            // Note: we only READ here, not record. Recording happens after the update is
+            // confirmed applied on the main thread, preventing a race where the panel
+            // isn't registered yet and the dedup would suppress subsequent reports.
             guard Self.socketFastPathState.shouldPublishShellActivity(
                 workspaceId: scope.workspaceId,
                 panelId: scope.panelId,
                 state: state
             ) else {
                 return "OK"
             }
+            let fastPathState = Self.socketFastPathState
             DispatchQueue.main.async {
                 guard let tabManager = AppDelegate.shared?.tabManagerFor(tabId: scope.workspaceId) else { return }
-                tabManager.updateSurfaceShellActivity(tabId: scope.workspaceId, surfaceId: scope.panelId, state: state)
+                let applied = tabManager.updateSurfaceShellActivity(
+                    tabId: scope.workspaceId,
+                    surfaceId: scope.panelId,
+                    state: state
+                )
+                // Only record the state in the dedup dict when the update actually
+                // applied (panel was registered). If the panel was absent, we do NOT
+                // record, so the next identical report will not be suppressed.
+                if applied {
+                    fastPathState.recordShellActivity(
+                        workspaceId: scope.workspaceId,
+                        panelId: scope.panelId,
+                        state: state
+                    )
+                }
             }
             return "OK"
         }

Sources/Workspace.swift

@@ -7644,17 +7644,26 @@ final class Workspace: Identifiable, ObservableObject {
         }
     }
 
-    func updatePanelShellActivityState(panelId: UUID, state: PanelShellActivityState) {
-        guard panels[panelId] != nil else { return }
+    /// Updates the shell-activity state for a panel.
+    ///
+    /// - Returns: `true` if the update was applied (panel exists and state changed),
+    ///   `false` if it was a no-op (panel absent or state unchanged).
+    ///   Callers that deduplicate reports MUST only record the state in their dedup
+    ///   dict when this returns `true`; recording on `false` would suppress the next
+    ///   identical report even though it was never actually applied.
+    @discardableResult
+    func updatePanelShellActivityState(panelId: UUID, state: PanelShellActivityState) -> Bool {
+        guard panels[panelId] != nil else { return false }
         let previousState = panelShellActivityStates[panelId] ?? .unknown
-        guard previousState != state else { return }
+        guard previousState != state else { return false }
         panelShellActivityStates[panelId] = state
 #if DEBUG
         dlog(
             "surface.shellState workspace=\(id.uuidString.prefix(5)) " +
             "panel=\(panelId.uuidString.prefix(5)) from=\(previousState.rawValue) to=\(state.rawValue)"
         )
 #endif
+        return true
     }
 
     func panelNeedsConfirmClose(panelId: UUID, fallbackNeedsConfirmClose: Bool) -> Bool {