refactor: migrate to Swift 6 language mode with strict concurrency (farouqaldori#47)

* refactor(build): migrate to Swift 6 language mode

Enable Swift 6 with strict concurrency checking:
- Update SWIFT_VERSION from 5.0 to 6 in Debug and Release configs
- Add SWIFT_STRICT_CONCURRENCY = complete
- Add @preconcurrency imports for Sparkle and Markdown libraries
- Add @mainactor to AppDelegate class for global state isolation

Build errors are expected and will be fixed in subsequent commits.

* fix(concurrency): replace NSLock with Mutex for thread-safe task tracking

Migrate from NSLock to Swift 6 Synchronization.Mutex for the activeTasks
dictionary in ClaudeSessionMonitor. Mutex provides better ergonomics with
withLock closures and aligns with modern Swift concurrency patterns.

* fix(concurrency): convert ProcessExecutor from actor to struct

ProcessExecutor has no mutable state to protect - all methods dispatch
work to background queues and return results via async continuations.
Converting to a Sendable struct eliminates unnecessary actor isolation
overhead and simplifies cross-context access in Swift 6.

* fix(concurrency): use MainActor.assumeIsolated for event handlers

NSEvent monitor handlers and NotificationCenter handlers run on the main
thread by documentation. Replace DispatchQueue.main.async with
MainActor.assumeIsolated for better performance and to avoid Sendable
warnings when passing NSEvent across isolation boundaries.

Also add nonisolated(unsafe) to ScreenObserver properties that are only
written during init (on MainActor) and read from deinit.

* fix(concurrency): fix MainActor isolation for timer callbacks and loggers

- Wrap Sparkle update check in Timer callback with Task { @mainactor }
  to ensure SPUUpdater methods are called on MainActor
- Mark global Logger instances as nonisolated(unsafe) for cross-context
  access from actors and nonisolated functions

* fix(concurrency): add nonisolated annotations for Sendable types

Add explicit nonisolated markers to methods, computed properties, and
static functions on Sendable value types. Swift 6 strict concurrency
requires these when accessed from non-isolated contexts:

- SessionPhase: init, isWaitingForApproval, matches(), allowedTransitions()
- SessionState: ToolTracker and SubagentState methods
- ToolResultData: MCPResult and GenericResult with nonisolated(unsafe) for
  [String: Any] properties and nonisolated == operators
- ChatItemFactory: all static factory methods
- ToolResultParser: all static parsing methods
- TerminalAppRegistry: static properties and methods
- EventMonitor: stopInternal() for deinit access

* fix(deprecation): update deprecated API calls

- Replace NSRunningApplication.activate(options:) with activate() as the
  options parameter is deprecated in macOS 14+
- Silence unused result warning for NSSound.play() with explicit discard

* fix(lint): remove redundant conditional casts in HookInstaller

Simplify array iteration by removing unnecessary conditional casts.
Since the arrays are already typed as [[String: Any]], re-casting
each element is redundant and triggers Swift 6 warnings.

* fix(concurrency): make file watcher classes @unchecked Sendable

AgentFileWatcher and JSONLInterruptWatcher use their own DispatchQueues
for serialization rather than MainActor. Mark them as @unchecked Sendable
with nonisolated methods and nonisolated(unsafe) properties to satisfy
Swift 6 strict concurrency checking.

- Add final class with @unchecked Sendable conformance
- Mark all methods as nonisolated
- Mark mutable properties as nonisolated(unsafe) (protected by queue)
- Add nonisolated(unsafe) to file-level logger (MainActor inference workaround)

* fix(concurrency): make HookSocketServer @unchecked Sendable with explicit Codable

HookSocketServer uses its own DispatchQueue and NSLock for thread safety.
Mark it as @unchecked Sendable with proper nonisolated annotations for
Swift 6 strict concurrency.

- Add final class with @unchecked Sendable conformance
- Mark all public and private methods as nonisolated
- Mark mutable properties as nonisolated(unsafe) (protected by queue/locks)
- Add explicit nonisolated Codable conformance for HookEvent and HookResponse
  to avoid MainActor-isolated synthesized conformance
- Add nonisolated(unsafe) to file-level logger (MainActor inference workaround)

* fix(concurrency): replace nonisolated(unsafe) with nonisolated for Sendable constants

Move module-level loggers inside their types as `nonisolated static let`
per SE-0434. Sendable constants don't need the `unsafe` qualifier since
they're inherently thread-safe. This eliminates 7 compiler warnings.

* fix(concurrency): make ScreenObserver @unchecked Sendable

Add @unchecked Sendable conformance to ScreenObserver for consistency
with other classes using nonisolated(unsafe) properties (AgentFileWatcher,
JSONLInterruptWatcher). Thread safety is managed via main thread notification
delivery and debounced DispatchWorkItem execution.

* refactor(concurrency): migrate HookSocketServer from NSLock to Mutex

Replace legacy NSLock + nonisolated(unsafe) pattern with modern
Synchronization.Mutex for thread-safe state management.

- Add PermissionsState and CacheState structs for Mutex-protected state
- Replace permissionsLock/cacheLock NSLock with Mutex instances
- Convert all critical sections to use withLock closures
- Add TimeoutResult and PermissionLookupResult enums for clean
  multi-guard early returns outside lock scope
- Convert markPermissionResponded to nonisolated static helper

* fix(concurrency): address race conditions and Swift 6 isolation

- Move acceptSource mutations into queue.sync in stop() to avoid data races
- Remove unnecessary MainActor hop in scheduleRetry() to prevent deadlock
- Use explicit MainActor isolation for delegate callbacks in file watchers

Author: engels74

ClaudeIsland.xcodeproj/project.pbxproj

@@ -306,7 +306,8 @@
 				SWIFT_DEFAULT_ACTOR_ISOLATION = MainActor;
 				SWIFT_EMIT_LOC_STRINGS = YES;
 				SWIFT_UPCOMING_FEATURE_MEMBER_IMPORT_VISIBILITY = YES;
-				SWIFT_VERSION = 5.0;
+				SWIFT_STRICT_CONCURRENCY = complete;
+				SWIFT_VERSION = 6;
 			};
 			name = Debug;
 		};
@@ -341,7 +342,8 @@
 				SWIFT_DEFAULT_ACTOR_ISOLATION = MainActor;
 				SWIFT_EMIT_LOC_STRINGS = YES;
 				SWIFT_UPCOMING_FEATURE_MEMBER_IMPORT_VISIBILITY = YES;
-				SWIFT_VERSION = 5.0;
+				SWIFT_STRICT_CONCURRENCY = complete;
+				SWIFT_VERSION = 6;
 			};
 			name = Release;
 		};

ClaudeIsland/App/AppDelegate.swift

@@ -1,12 +1,14 @@
 import AppKit
 import os
-import Sparkle
+@preconcurrency import Sparkle
 import SwiftUI
 
+/// Logger for app delegate
 private let logger = Logger(subsystem: "com.engels74.ClaudeIsland", category: "AppDelegate")
 
 // MARK: - AppDelegate
 
+@MainActor
 class AppDelegate: NSObject, NSApplicationDelegate {
     // MARK: Lifecycle
 
@@ -68,8 +70,10 @@ class AppDelegate: NSObject, NSApplicationDelegate {
         }
 
         self.updateCheckTimer = Timer.scheduledTimer(withTimeInterval: 3600, repeats: true) { [weak self] _ in
-            guard let updater = self?.updater, updater.canCheckForUpdates else { return }
-            updater.checkForUpdates()
+            Task { @MainActor [weak self] in
+                guard let updater = self?.updater, updater.canCheckForUpdates else { return }
+                updater.checkForUpdates()
+            }
         }
     }
 

ClaudeIsland/App/ScreenObserver.swift

@@ -7,7 +7,9 @@
 
 import AppKit
 
-class ScreenObserver {
+/// `@unchecked Sendable` because thread safety is managed via main thread
+/// notification delivery and debounced DispatchWorkItem execution
+final class ScreenObserver: @unchecked Sendable {
     // MARK: Lifecycle
 
     init(onScreenChange: @escaping () -> Void) {
@@ -21,9 +23,13 @@ class ScreenObserver {
 
     // MARK: Private
 
-    private var observer: Any?
-    private let onScreenChange: () -> Void
-    private var pendingWork: DispatchWorkItem?
+    /// nonisolated(unsafe) is safe here because:
+    /// 1. These are only written in startObserving() which runs on init (implicitly @MainActor)
+    /// 2. They are read in stopObserving() which is either called from @MainActor or from deinit
+    ///    when there are no other references
+    private nonisolated(unsafe) var observer: Any?
+    private nonisolated(unsafe) let onScreenChange: () -> Void
+    private nonisolated(unsafe) var pendingWork: DispatchWorkItem?
 
     /// Debounce interval to coalesce rapid screen change notifications
     /// (e.g., when waking from sleep, displays reconnect in stages)
@@ -35,7 +41,9 @@ class ScreenObserver {
             object: nil,
             queue: .main
         ) { [weak self] _ in
-            self?.scheduleScreenChange()
+            MainActor.assumeIsolated {
+                self?.scheduleScreenChange()
+            }
         }
     }
 
@@ -53,7 +61,7 @@ class ScreenObserver {
         )
     }
 
-    private func stopObserving() {
+    private nonisolated func stopObserving() {
         self.pendingWork?.cancel()
         if let observer {
             NotificationCenter.default.removeObserver(observer)

ClaudeIsland/Events/EventMonitor.swift

@@ -59,7 +59,7 @@ final class EventMonitor: @unchecked Sendable {
     private let handler: @Sendable (NSEvent) -> Void
 
     /// Internal stop that can be called from deinit
-    private func stopInternal() {
+    private nonisolated func stopInternal() {
         if let monitor = globalMonitor {
             NSEvent.removeMonitor(monitor)
             self.globalMonitor = nil

ClaudeIsland/Events/EventMonitors.swift

@@ -8,6 +8,16 @@
 import AppKit
 import Combine
 
+// MARK: - SendableEvent
+
+/// Wrapper to safely pass NSEvent across MainActor boundaries.
+/// Safe because NSEvent monitor handlers are documented to run on main thread.
+private struct SendableEvent: @unchecked Sendable {
+    nonisolated(unsafe) let event: NSEvent
+}
+
+// MARK: - EventMonitors
+
 /// Singleton that aggregates all event monitors.
 /// @MainActor ensures thread-safe access to mutable state and Combine publishers
 /// since NSEvent monitors dispatch handlers on the main thread.
@@ -33,25 +43,26 @@ final class EventMonitors {
     private var mouseDraggedMonitor: EventMonitor?
 
     private func setupMonitors() {
-        // Note: Apple documents that NSEvent monitor handlers run on the main thread.
-        // Using DispatchQueue.main.async provides defensive safety in case this ever changes,
-        // avoiding potential crashes from MainActor.assumeIsolated violations.
+        // NSEvent monitor handlers are documented to run on the main thread.
+        // Using MainActor.assumeIsolated is safe and avoids Swift 6 Sendable warnings
+        // when passing NSEvent across isolation boundaries.
         self.mouseMoveMonitor = EventMonitor(mask: .mouseMoved) { [weak self] _ in
-            DispatchQueue.main.async {
+            MainActor.assumeIsolated {
                 self?.mouseLocation.send(NSEvent.mouseLocation)
             }
         }
         self.mouseMoveMonitor?.start()
 
         self.mouseDownMonitor = EventMonitor(mask: .leftMouseDown) { [weak self] event in
-            DispatchQueue.main.async {
-                self?.mouseDown.send(event)
+            let wrapper = SendableEvent(event: event)
+            MainActor.assumeIsolated {
+                self?.mouseDown.send(wrapper.event)
             }
         }
         self.mouseDownMonitor?.start()
 
         self.mouseDraggedMonitor = EventMonitor(mask: .leftMouseDragged) { [weak self] _ in
-            DispatchQueue.main.async {
+            MainActor.assumeIsolated {
                 self?.mouseLocation.send(NSEvent.mouseLocation)
             }
         }

ClaudeIsland/Models/SessionPhase.swift

@@ -17,7 +17,7 @@ struct PermissionContext: Sendable {
     // MARK: Lifecycle
 
     /// Initialize with raw tool input dictionary (serializes to JSON)
-    init(toolUseID: String, toolName: String, toolInput: [String: AnyCodable]?, receivedAt: Date) {
+    nonisolated init(toolUseID: String, toolName: String, toolInput: [String: AnyCodable]?, receivedAt: Date) {
         self.toolUseID = toolUseID
         self.toolName = toolName
         self.receivedAt = receivedAt
@@ -150,7 +150,7 @@ enum SessionPhase: Sendable {
     }
 
     /// Whether this is a waitingForApproval phase
-    var isWaitingForApproval: Bool {
+    nonisolated var isWaitingForApproval: Bool {
         if case .waitingForApproval = self {
             return true
         }
@@ -197,7 +197,7 @@ enum SessionPhase: Sendable {
 
         // MARK: Internal
 
-        func matches(_ phase: SessionPhase) -> Bool {
+        nonisolated func matches(_ phase: SessionPhase) -> Bool {
             switch (self, phase) {
             case (.idle, .idle),
                  (.processing, .processing),
@@ -213,7 +213,7 @@ enum SessionPhase: Sendable {
     }
 
     /// Valid transitions from each phase
-    private static func allowedTransitions(from phase: Self) -> [PhaseKey] {
+    private nonisolated static func allowedTransitions(from phase: Self) -> [PhaseKey] {
         switch phase {
         case .idle:
             // Note: .waitingForInput is allowed for history loading where we discover actual state

ClaudeIsland/Models/SessionState.swift

@@ -234,17 +234,17 @@ struct ToolTracker: Equatable, Sendable {
     var lastSyncTime: Date?
 
     /// Mark a tool ID as seen, returns true if it was new
-    mutating func markSeen(_ id: String) -> Bool {
+    nonisolated mutating func markSeen(_ id: String) -> Bool {
         self.seenIDs.insert(id).inserted
     }
 
     /// Check if a tool ID has been seen
-    func hasSeen(_ id: String) -> Bool {
+    nonisolated func hasSeen(_ id: String) -> Bool {
         self.seenIDs.contains(id)
     }
 
     /// Start tracking a tool
-    mutating func startTool(id: String, name: String) {
+    nonisolated mutating func startTool(id: String, name: String) {
         guard self.markSeen(id) else { return }
         self.inProgress[id] = ToolInProgress(
             id: id,
@@ -255,7 +255,7 @@ struct ToolTracker: Equatable, Sendable {
     }
 
     /// Complete a tool
-    mutating func completeTool(id: String, success: Bool) {
+    nonisolated mutating func completeTool(id: String, success: Bool) {
         self.inProgress.removeValue(forKey: id)
     }
 }
@@ -304,12 +304,12 @@ struct SubagentState: Equatable, Sendable {
     var agentDescriptions: [String: String]
 
     /// Whether there's an active subagent
-    var hasActiveSubagent: Bool {
+    nonisolated var hasActiveSubagent: Bool {
         !self.activeTasks.isEmpty
     }
 
     /// Start tracking a Task tool
-    mutating func startTask(taskToolID: String, description: String? = nil) {
+    nonisolated mutating func startTask(taskToolID: String, description: String? = nil) {
         self.activeTasks[taskToolID] = TaskContext(
             taskToolID: taskToolID,
             startTime: Date(),
@@ -320,30 +320,30 @@ struct SubagentState: Equatable, Sendable {
     }
 
     /// Stop tracking a Task tool
-    mutating func stopTask(taskToolID: String) {
+    nonisolated mutating func stopTask(taskToolID: String) {
         self.activeTasks.removeValue(forKey: taskToolID)
     }
 
     /// Set the agentID for a Task (called when agent file is discovered)
-    mutating func setAgentID(_ agentID: String, for taskToolID: String) {
+    nonisolated mutating func setAgentID(_ agentID: String, for taskToolID: String) {
         self.activeTasks[taskToolID]?.agentID = agentID
         if let description = activeTasks[taskToolID]?.description {
             self.agentDescriptions[agentID] = description
         }
     }
 
     /// Add a subagent tool to a specific Task by ID
-    mutating func addSubagentToolToTask(_ tool: SubagentToolCall, taskID: String) {
+    nonisolated mutating func addSubagentToolToTask(_ tool: SubagentToolCall, taskID: String) {
         self.activeTasks[taskID]?.subagentTools.append(tool)
     }
 
     /// Set all subagent tools for a specific Task (used when updating from agent file)
-    mutating func setSubagentTools(_ tools: [SubagentToolCall], for taskID: String) {
+    nonisolated mutating func setSubagentTools(_ tools: [SubagentToolCall], for taskID: String) {
         self.activeTasks[taskID]?.subagentTools = tools
     }
 
     /// Add a subagent tool to the most recent active Task
-    mutating func addSubagentTool(_ tool: SubagentToolCall) {
+    nonisolated mutating func addSubagentTool(_ tool: SubagentToolCall) {
         // Find most recent active task (for parallel Task support)
         guard let mostRecentTaskID = activeTasks.keys.max(by: {
             (activeTasks[$0]?.startTime ?? .distantPast) < (activeTasks[$1]?.startTime ?? .distantPast)
@@ -354,7 +354,7 @@ struct SubagentState: Equatable, Sendable {
     }
 
     /// Update the status of a subagent tool across all active Tasks
-    mutating func updateSubagentToolStatus(toolID: String, status: ToolStatus) {
+    nonisolated mutating func updateSubagentToolStatus(toolID: String, status: ToolStatus) {
         for taskID in self.activeTasks.keys {
             if let index = activeTasks[taskID]?.subagentTools.firstIndex(where: { $0.id == toolID }) {
                 self.activeTasks[taskID]?.subagentTools[index].status = status

ClaudeIsland/Models/ToolResultData.swift

@@ -247,9 +247,10 @@ struct ExitPlanModeResult: Equatable, Sendable {
 struct MCPResult: Equatable, @unchecked Sendable {
     let serverName: String
     let toolName: String
-    let rawResult: [String: Any]
+    /// nonisolated(unsafe) because [String: Any] isn't Sendable but we need cross-context access
+    nonisolated(unsafe) let rawResult: [String: Any]
 
-    static func == (lhs: Self, rhs: Self) -> Bool {
+    nonisolated static func == (lhs: Self, rhs: Self) -> Bool {
         lhs.serverName == rhs.serverName &&
             lhs.toolName == rhs.toolName &&
             NSDictionary(dictionary: lhs.rawResult).isEqual(to: rhs.rawResult)
@@ -260,9 +261,10 @@ struct MCPResult: Equatable, @unchecked Sendable {
 
 struct GenericResult: Equatable, @unchecked Sendable {
     let rawContent: String?
-    let rawData: [String: Any]?
+    /// nonisolated(unsafe) because [String: Any] isn't Sendable but we need cross-context access
+    nonisolated(unsafe) let rawData: [String: Any]?
 
-    static func == (lhs: Self, rhs: Self) -> Bool {
+    nonisolated static func == (lhs: Self, rhs: Self) -> Bool {
         lhs.rawContent == rhs.rawContent
     }
 }

ClaudeIsland/Services/Hooks/HookInstaller.swift

@@ -228,11 +228,11 @@ enum HookInstaller {
 
         var updated = false
         for i in existingEvent.indices {
-            if var entry = existingEvent[i] as? [String: Any],
-               var entryHooks = entry["hooks"] as? [[String: Any]] {
+            var entry = existingEvent[i]
+            if var entryHooks = entry["hooks"] as? [[String: Any]] {
                 for j in entryHooks.indices {
-                    if var hook = entryHooks[j] as? [String: Any],
-                       let cmd = hook["command"] as? String,
+                    var hook = entryHooks[j]
+                    if let cmd = hook["command"] as? String,
                        cmd.contains("claude-island-state.py") {
                         hook["command"] = command
                         entryHooks[j] = hook