fix(desktop): derive stable Session identity from tmux name

parseSessionOutput minted a fresh random UUID for every Session on
every 5s refresh, breaking SwiftUI ForEach identity and the
session-picker checkmark and forcing needless view rebuilds. Derive a
deterministic UUIDv5 from the tmux session name so a session keeps one
identity across refreshes.

Refs: RMI-PLEXUSONEAPP-003

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: grokify

apps/desktop/Sources/PlexusOneDesktop/Models/Session.swift

@@ -1,6 +1,35 @@
 import Foundation
+import CryptoKit
 import AssistantKit
 
+extension UUID {
+    /// Fixed namespace for PlexusOne tmux-session identities (RFC 4122).
+    private static let tmuxSessionNamespace = UUID(uuidString: "b3f0e6a2-1c4d-5e6f-8a9b-0c1d2e3f4a5b")!
+
+    /// Derive a stable, deterministic UUID (version 5, RFC 4122) from a tmux
+    /// session name. The same name always yields the same UUID, so a session
+    /// keeps one identity across periodic refreshes instead of getting a fresh
+    /// random UUID each cycle (which would churn SwiftUI identity).
+    static func forTmuxSession(named name: String) -> UUID {
+        var hasher = Insecure.SHA1()
+        withUnsafeBytes(of: tmuxSessionNamespace.uuid) { hasher.update(bufferPointer: $0) }
+        hasher.update(data: Data(name.utf8))
+        var digest = Array(hasher.finalize()) // 20 bytes; use the first 16
+
+        // Set the version (5) and variant (RFC 4122) bits.
+        digest[6] = (digest[6] & 0x0F) | 0x50
+        digest[8] = (digest[8] & 0x3F) | 0x80
+
+        let bytes = (
+            digest[0], digest[1], digest[2], digest[3],
+            digest[4], digest[5], digest[6], digest[7],
+            digest[8], digest[9], digest[10], digest[11],
+            digest[12], digest[13], digest[14], digest[15]
+        )
+        return UUID(uuid: bytes)
+    }
+}
+
 /// Represents a tmux session that can be attached to a pane
 struct Session: Identifiable, Codable, Hashable {
     let id: UUID

apps/desktop/Sources/PlexusOneDesktop/Services/SessionManager.swift

@@ -195,6 +195,7 @@ final class SessionManager {
             let status = determineStatus(lastActivity: lastActivity)
 
             let session = Session(
+                id: .forTmuxSession(named: name),
                 name: name,
                 tmuxSession: name,
                 status: status,

apps/desktop/Tests/PlexusOneDesktopTests/SessionManagerTests.swift

@@ -160,6 +160,32 @@ final class SessionManagerTests: XCTestCase {
         XCTAssertEqual(sessions[0].status, .running)
     }
 
+    func testParseSessionOutputIdStableAcrossRefreshes() {
+        let manager = SessionManager()
+        let now = Date()
+        let ts = Int(now.timeIntervalSince1970 - 10)
+
+        // Same session parsed on two separate refresh cycles (different activity
+        // timestamps, as tmux would report) must keep the same identity.
+        let first = manager.parseSessionOutput("my-session|\(ts)|1", referenceDate: now)
+        let second = manager.parseSessionOutput("my-session|\(ts + 5)|1", referenceDate: now)
+
+        XCTAssertEqual(first.count, 1)
+        XCTAssertEqual(second.count, 1)
+        XCTAssertEqual(first[0].id, second[0].id, "Session id must be stable across refreshes")
+    }
+
+    func testParseSessionOutputIdDiffersByName() {
+        let manager = SessionManager()
+        let now = Date()
+        let ts = Int(now.timeIntervalSince1970 - 10)
+
+        let sessions = manager.parseSessionOutput("alpha|\(ts)|1\nbeta|\(ts)|1", referenceDate: now)
+
+        XCTAssertEqual(sessions.count, 2)
+        XCTAssertNotEqual(sessions[0].id, sessions[1].id, "Different sessions must have distinct ids")
+    }
+
     func testParseSessionOutputMultipleSessions() {
         let manager = SessionManager()
         let now = Date()