test: restore cmuxTests compile on main

CLI/CMUXCLI+VMTransfer.swift

@@ -1,3 +1,4 @@
+import CmuxFoundation
 import CmuxSettings
 import CmuxSurfaceCatalogModel
 import CryptoKit
@@ -835,26 +836,14 @@ extension CMUXCLI {
             }
             let remainingSeconds = deadline.timeIntervalSinceNow
             if remainingSeconds > 0 {
-                Thread.sleep(forTimeInterval: min(Self.vmReadyPollInterval(), remainingSeconds))
+                Thread.sleep(forTimeInterval: min(
+                    CLIVMWaitPollInterval.resolve(environment: ProcessInfo.processInfo.environment),
+                    remainingSeconds
+                ))
             }
         }
     }
 
-    /// Seconds between `vm.status` polls. `CMUX_VM_WAIT_POLL_SECONDS` overrides the
-    /// default so tests against a mock socket do not wait out the real cadence.
-    static func vmReadyPollInterval(
-        environment: [String: String] = ProcessInfo.processInfo.environment
-    ) -> TimeInterval {
-        guard let raw = environment["CMUX_VM_WAIT_POLL_SECONDS"],
-              let parsed = TimeInterval(raw),
-              parsed.isFinite,
-              parsed >= 0.01,
-              parsed <= 3 else {
-            return 3
-        }
-        return parsed
-    }
-
     // MARK: - transfer plumbing
 
     /// Chunk progress: rewrites one line on a TTY, but emits whole lines when

Packages/macOS/CmuxFoundation/Sources/CmuxFoundation/CLIVMWaitPollInterval.swift

@@ -0,0 +1,30 @@
+public import Foundation
+
+/// Seconds between `vm.status` polls in `cmux vm wait`.
+///
+/// `CMUX_VM_WAIT_POLL_SECONDS` lets tests against a mock control socket poll
+/// faster than the production cadence. An override may only shorten the
+/// cadence, so a bad value can never outlive the command's `--timeout`.
+public enum CLIVMWaitPollInterval {
+    /// The environment key that overrides the cadence.
+    public static let environmentKey = "CMUX_VM_WAIT_POLL_SECONDS"
+    /// The production cadence, and the upper bound for an override.
+    public static let defaultSeconds: TimeInterval = 3
+    /// The smallest override that is honored.
+    public static let minimumOverrideSeconds: TimeInterval = 0.01
+
+    /// Resolves the poll interval for a process environment.
+    ///
+    /// - Parameter environment: The CLI process environment.
+    /// - Returns: The override when it is a finite value in
+    ///   `minimumOverrideSeconds...defaultSeconds`, otherwise `defaultSeconds`.
+    public static func resolve(environment: [String: String]) -> TimeInterval {
+        guard let raw = environment[environmentKey],
+              let parsed = TimeInterval(raw),
+              parsed.isFinite,
+              (minimumOverrideSeconds...defaultSeconds).contains(parsed) else {
+            return defaultSeconds
+        }
+        return parsed
+    }
+}

Packages/macOS/CmuxFoundation/Tests/CmuxFoundationTests/CLIVMWaitPollIntervalTests.swift

@@ -0,0 +1,20 @@
+import Foundation
+import Testing
+@testable import CmuxFoundation
+
+@Suite struct CLIVMWaitPollIntervalTests {
+    @Test func usesProductionCadenceWithoutOverride() {
+        #expect(CLIVMWaitPollInterval.resolve(environment: [:]) == 3)
+    }
+
+    @Test(arguments: ["0.01", "0.05", "3"])
+    func honorsShortOverride(_ raw: String) throws {
+        let expected = try #require(TimeInterval(raw))
+        #expect(CLIVMWaitPollInterval.resolve(environment: ["CMUX_VM_WAIT_POLL_SECONDS": raw]) == expected)
+    }
+
+    @Test(arguments: ["3600", "3.5", "0.001", "0", "-1", "inf", "nan", "soon", ""])
+    func rejectsOverrideOutsideCommandSafeRange(_ raw: String) {
+        #expect(CLIVMWaitPollInterval.resolve(environment: ["CMUX_VM_WAIT_POLL_SECONDS": raw]) == 3)
+    }
+}

cmuxCLITests/ClaudeHookSessionStoreRecoveryTests.swift

@@ -1,58 +1,122 @@
 import Foundation
 import Testing
 
-@testable import cmux_cli
-
+/// Hook state recovery after decode drift, driven through the bundled CLI.
+///
+/// The CLI is a tool target that this bundle cannot import, so each test seeds
+/// `claude-hook-sessions.json`, runs a real `hooks claude session-start`, and
+/// reads back what the store persisted.
 @Suite(.serialized)
 struct ClaudeHookSessionStoreRecoveryTests {
+    private typealias Harness = ClaudeHookLiveDeliveryHarness
+
+    private static let liveWorkspaceId = "11111111-1111-1111-1111-111111111111"
+    private static let liveSurfaceId = "22222222-2222-2222-2222-222222222222"
+    private static let otherWorkspaceId = "33333333-3333-3333-3333-333333333333"
+    private static let otherSurfaceId = "44444444-4444-4444-4444-444444444444"
+
     @Test("One malformed hook record does not discard valid session mappings")
     func malformedHookRecordDoesNotDiscardValidSessionMappings() throws {
-        let validSessionID = "valid-hook-session"
-        let data = try JSONSerialization.data(withJSONObject: [
+        let context = try Harness.makeContext(name: "hook-store-salvage")
+        defer { context.cleanup() }
+        let validSessionId = "valid-hook-session"
+        let malformedSessionId = "malformed-hook-session"
+        let newSessionId = "new-hook-session"
+        let now = Date().timeIntervalSince1970
+        let store: [String: Any] = [
             "version": 1,
             "sessions": [
-                validSessionID: [
-                    "sessionId": validSessionID,
-                    "workspaceId": "workspace-valid",
-                    "surfaceId": "surface-valid",
-                    "startedAt": 1,
-                    "updatedAt": 2,
+                validSessionId: [
+                    "sessionId": validSessionId,
+                    "workspaceId": Self.otherWorkspaceId,
+                    "surfaceId": Self.otherSurfaceId,
+                    "cwd": context.root.path,
+                    "isRestorable": true,
+                    "startedAt": now,
+                    "updatedAt": now,
                 ],
-                "malformed-hook-session": [
+                malformedSessionId: [
                     "sessionId": 42,
-                    "workspaceId": "workspace-malformed",
-                    "surfaceId": "surface-malformed",
-                    "startedAt": 1,
-                    "updatedAt": 2,
+                    "workspaceId": Self.otherWorkspaceId,
+                    "surfaceId": Self.otherSurfaceId,
+                    "startedAt": now,
+                    "updatedAt": now,
                 ],
             ],
-        ])
+        ]
+        try JSONSerialization.data(withJSONObject: store, options: [.prettyPrinted, .sortedKeys])
+            .write(to: context.storeURL)
+        startServer(context: context)
+
+        let result = runSessionStart(context: context, sessionId: newSessionId)
 
-        let decoded = try JSONDecoder().decode(ClaudeHookSessionStoreFile.self, from: data)
-        #expect(decoded.sessions.count == 1)
-        #expect(decoded.sessions[validSessionID]?.workspaceId == "workspace-valid")
+        assertSuccessfulHook(result)
+        let saved = try #require(
+            JSONSerialization.jsonObject(with: Data(contentsOf: context.storeURL)) as? [String: Any]
+        )
+        let sessions = try #require(saved["sessions"] as? [String: Any])
+        #expect(Set(sessions.keys) == [validSessionId, newSessionId])
+        let valid = try #require(sessions[validSessionId] as? [String: Any])
+        #expect(valid["workspaceId"] as? String == Self.otherWorkspaceId)
+        #expect(valid["surfaceId"] as? String == Self.otherSurfaceId)
+        #expect(quarantineBackups(in: context.root).isEmpty, "A salvageable store must not be quarantined")
     }
 
     @Test("Repeated hook state quarantine keeps every recovery backup")
     func repeatedHookStateQuarantineKeepsEveryRecoveryBackup() throws {
-        let root = FileManager.default.temporaryDirectory
-            .appendingPathComponent("cmux-hook-state-quarantine-\(UUID().uuidString)", isDirectory: true)
-        try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
-        defer { try? FileManager.default.removeItem(at: root) }
-        let stateURL = root.appendingPathComponent("claude-hook-sessions.json", isDirectory: false)
-        let environment = ["CMUX_CLAUDE_HOOK_STATE_PATH": stateURL.path]
-        let store = ClaudeHookSessionStore(processEnv: environment)
-
-        for _ in 0..<2 {
-            try Data(#"{"sessions":["#.utf8).write(to: stateURL, options: .atomic)
-            #expect(try store.lookup(sessionId: "any-session") == nil)
+        let context = try Harness.makeContext(name: "hook-store-quarantine")
+        defer { context.cleanup() }
+        startServer(context: context)
+
+        for attempt in 0..<2 {
+            try Data(#"{"sessions":["#.utf8).write(to: context.storeURL, options: .atomic)
+            let result = runSessionStart(context: context, sessionId: "quarantine-session-\(attempt)")
+            assertSuccessfulHook(result)
         }
 
-        let backups = try FileManager.default.contentsOfDirectory(
+        #expect(quarantineBackups(in: context.root).count == 2)
+    }
+
+    /// One mock server serves every hook process in a test: its accept loop
+    /// keeps running until the context closes the listener.
+    private func startServer(context: Harness.Context) {
+        _ = Harness.startDeliveryTargetServer(
+            context: context,
+            surfacesByWorkspace: [
+                Self.liveWorkspaceId: [Self.liveSurfaceId],
+                Self.otherWorkspaceId: [Self.otherSurfaceId],
+            ],
+            pidTarget: (workspaceId: Self.liveWorkspaceId, surfaceId: Self.liveSurfaceId)
+        )
+    }
+
+    private func runSessionStart(
+        context: Harness.Context,
+        sessionId: String
+    ) -> Harness.ProcessRunResult {
+        var environment = Harness.hookEnvironment(context: context)
+        environment["CMUX_WORKSPACE_ID"] = Self.liveWorkspaceId
+        environment["CMUX_SURFACE_ID"] = Self.liveSurfaceId
+        environment["CMUX_CLAUDE_PID"] = "43401"
+        return Harness.runHookProcess(
+            context: context,
+            arguments: ["hooks", "claude", "session-start"],
+            environment: environment,
+            standardInput: #"{"session_id":"\#(sessionId)","source":"startup","cwd":"\#(context.root.path)","hook_event_name":"SessionStart"}"#
+        )
+    }
+
+    private func quarantineBackups(in root: URL) -> [URL] {
+        let entries = (try? FileManager.default.contentsOfDirectory(
             at: root,
             includingPropertiesForKeys: nil,
             options: []
-        ).filter { $0.lastPathComponent.contains(".claude-hook-sessions.json.quarantined.") }
-        #expect(backups.count == 2)
+        )) ?? []
+        return entries.filter { $0.lastPathComponent.contains(".claude-hook-sessions.json.quarantined.") }
+    }
+
+    private func assertSuccessfulHook(_ result: Harness.ProcessRunResult) {
+        #expect(!result.timedOut, Comment(rawValue: result.stderr))
+        #expect(result.status == 0, Comment(rawValue: result.stderr))
     }
 }

cmuxTests/CLIVMTransferTests.swift

@@ -726,13 +726,10 @@ extension CLINotifyProcessIntegrationRegressionTests {
         var environment = ProcessInfo.processInfo.environment
         environment["CMUX_SOCKET_PATH"] = socketPath
         environment["CMUX_CLI_SENTRY_DISABLED"] = "1"
-        XCTAssertEqual(
-            CMUXCLI.vmReadyPollInterval(environment: ["CMUX_VM_WAIT_POLL_SECONDS": "3600"]),
-            3,
-            "oversized poll overrides must fall back to the command-safe cadence"
-        )
-        // The mock answers instantly, so keep the process-level check on a
-        // valid short override rather than waiting out the production cadence.
+        // CmuxFoundation's CLIVMWaitPollIntervalTests cover the override
+        // parser, including the oversized fallback. The mock answers instantly,
+        // so keep the process-level check on a valid short override rather than
+        // waiting out the production cadence.
         environment["CMUX_VM_WAIT_POLL_SECONDS"] = "0.05"
 
         let result = runProcess(

cmuxTests/CloudWorkspaceLiveProjectionTests.swift

@@ -337,12 +337,17 @@ struct CloudWorkspaceLiveProjectionTests {
     func progressingPassesStayAdmitted() throws {
         let state = try graph(["first": "a"], revision: 1)
         var budget = CloudWorkspaceReconcileBudget()
+        // `admit` is mutating, and #expect expands a method call into a closure
+        // over an immutable copy, so record each result before asserting it.
         for version in 0..<UInt64(CloudWorkspaceReconcileBudget.maxPassesPerState) {
-            #expect(budget.admit(.init(state: state, projectionVersion: version, bindings: [:])))
+            let admitted = budget.admit(.init(state: state, projectionVersion: version, bindings: [:]))
+            #expect(admitted)
         }
-        #expect(!budget.admit(.init(state: state, projectionVersion: 1_000, bindings: [:])))
+        let admittedPastCeiling = budget.admit(.init(state: state, projectionVersion: 1_000, bindings: [:]))
+        #expect(!admittedPastCeiling)
         let next = try graph(["first": "a"], revision: 2)
-        #expect(budget.admit(.init(state: next, projectionVersion: 1_000, bindings: [:])), "A new graph starts a new budget")
+        let admittedNewGraph = budget.admit(.init(state: next, projectionVersion: 1_000, bindings: [:]))
+        #expect(admittedNewGraph, "A new graph starts a new budget")
     }
 
     @Test("Lifecycle cancellation is not retained as a projection failure")

cmuxTests/PaneResizeShortcutTests.swift

@@ -63,6 +63,8 @@ struct PaneResizeShortcutTests {
             #expect(await AppKitTestEventPump().waitUntil(timeout: .seconds(3)) {
                 workspace.tmuxLayoutSnapshot?.panes.count == 2
             })
+            let controller = workspace.bonsplitController
+            controller.setContainerFrame(CGRect(x: 0, y: 0, width: 1000, height: 1000))
             let split = try rootSplit(controller)
             #expect(controller.setDividerPosition(0.5, forSplit: try #require(UUID(uuidString: split.id))))
             workspace.didProgrammaticallyChangeSplitGeometry()

cmuxTests/TabManagerUnitTests.swift

@@ -21,12 +21,12 @@ import CmuxSettings
 
 let lastSurfaceCloseShortcutDefaultsKey = "closeWorkspaceOnLastSurfaceShortcut"
 
-func drainMainQueue() {
+func drainMainQueue(timeout: TimeInterval = 1.0) {
     let expectation = XCTestExpectation(description: "drain main queue")
     DispatchQueue.main.async {
         expectation.fulfill()
     }
-    XCTWaiter().wait(for: [expectation], timeout: 1.0)
+    XCTWaiter().wait(for: [expectation], timeout: timeout)
 }
 
 @discardableResult