Make app-host unit tests green on main

CLI/CMUXCLI+AgentHookDefinitions.swift

@@ -428,20 +428,8 @@ extension CMUXCLI {
         // environments, and for a stale socket node left by an exited app: the
         // ambient invocation must succeed, otherwise the pinned chain runs.
         // https://github.com/manaflow-ai/cmux/issues/5473
-        let ambientGuard: String
-        let ambientInvocation: String
-        if def.name == "grok" {
-            // Grok validates interpolated CMUX variables as required hook
-            // environment. Optional lookups preserve ambient-first routing
-            // when present and allow the pinned fallback when Grok strips them.
-            let socket = "\"$(printenv CMUX_SOCKET_PATH || true)\""
-            let executable = "\"$(printenv CMUX_BUNDLED_CLI_PATH || true)\""
-            ambientGuard = "[ -n \(socket) ] && [ -S \(socket) ] && [ -f \(executable) ] && [ -x \(executable) ]"
-            ambientInvocation = "\(pinnedHookEnvironmentPrefix(routedArguments: routedArguments))\(executable) --socket \(socket) \(routedArguments)"
-        } else {
-            ambientGuard = pinnedHookAmbientDispatchGuard
-            ambientInvocation = pinnedHookAmbientInvocation(routedArguments: routedArguments)
-        }
+        let ambientGuard = pinnedHookAmbientDispatchGuard
+        let ambientInvocation = pinnedHookAmbientInvocation(routedArguments: routedArguments)
         let dispatch: String
         if let cliPath = pinnedAgentHookCLIPath() {
             let quotedCLIPath = shellSingleQuote(cliPath)

CLI/CMUXCLI+SSHStartupScripts.swift

@@ -130,7 +130,13 @@ extension CMUXCLI {
             "      if {[string length $cmux_buffer] > 0} { send_user -- $cmux_buffer }",
             "      cmux_relay_session",
             "    }",
-            "    eof { set status [wait]; exit [lindex $status 3] }",
+            // A session that authenticates and ends inside this window still
+            // owes the user its output: flush what expect buffered before exiting.
+            "    eof {",
+            "      catch { send_user -- $expect_out(buffer) }",
+            "      set status [wait]",
+            "      exit [lindex $status 3]",
+            "    }",
             "  }",
             "}",
             "expect {",
@@ -217,7 +223,13 @@ extension CMUXCLI {
             "      if {[string length $cmux_buffer] > 0} { send_user -- $cmux_buffer }",
             "      cmux_relay_session",
             "    }",
-            "    eof { set status [wait]; exit [lindex $status 3] }",
+            // A session that authenticates and ends inside this window still
+            // owes the user its output: flush what expect buffered before exiting.
+            "    eof {",
+            "      catch { send_user -- $expect_out(buffer) }",
+            "      set status [wait]",
+            "      exit [lindex $status 3]",
+            "    }",
             "  }",
             "}",
             "expect {",

CLI/CMUXCLI+VMSCP.swift

@@ -73,6 +73,9 @@ extension CMUXCLI {
             "-F", "/dev/null",
             "-o", "StrictHostKeyChecking=yes",
             "-o", "HostKeyAlgorithms=ssh-ed25519", "-o", "HostKeyAlias=cmux-scp",
+            // Keep host-key failures actionable while avoiding OpenSSH's
+            // multi-page warning banner filling a PTY-backed stderr pipe.
+            "-o", "LogLevel=ERROR",
             "-o", "UserKnownHostsFile=" + directory.appendingPathComponent("known_hosts").path.replacingOccurrences(of: "%", with: "%%"),
             "-o", "GlobalKnownHostsFile=/dev/null",
             "-o", "ConnectTimeout=15", "-o", "ServerAliveInterval=15", "-o", "ServerAliveCountMax=3",

CLI/cmux.swift

@@ -35979,19 +35979,18 @@ export default CMUXSessionRestore;
             // this narrow transcript check for pre-ledger launches so stale
             // prompt-depth records cannot strand an older session; it is never
             // part of the modern child-work decision.
+            let activePromptTurnStackForStop = mapped?.activePromptTurnIds?
+                .compactMap({ normalizedHookValue($0) }) ?? []
+            let activePromptTurnIdsForStop = activePromptTurnStackForStop.isEmpty
+                ? normalizedHookValue(mapped?.activePromptTurnId).map { [$0] } ?? []
+                : activePromptTurnStackForStop
             let terminalActivePromptTurnIdsForStop: Set<String>
             if !relayOrigin,
                !staleIdleStopHasNewerRunningSession,
                def.name == "codex",
                codexLifecycle?.usesLegacyIdentity == true,
                let incomingTurnId = normalizedHookValue(input.turnId) {
-                let activePromptTurnStack = mapped?.activePromptTurnIds?
-                    .compactMap({ normalizedHookValue($0) }) ?? []
-                let activePromptTurnId = activePromptTurnStack.last ?? normalizedHookValue(mapped?.activePromptTurnId)
-                let activeTurnIds = activePromptTurnStack.isEmpty
-                    ? activePromptTurnId.map { [$0] } ?? []
-                    : activePromptTurnStack
-                let activeTurnIdsToCheck = activeTurnIds.filter { $0 != incomingTurnId }
+                let activeTurnIdsToCheck = activePromptTurnIdsForStop.filter { $0 != incomingTurnId }
                 if !activeTurnIdsToCheck.isEmpty,
                    let transcriptPath = normalizedHookValue(localTranscriptPath(mapped: mapped))
                        ?? findCodexTranscriptPath(sessionId: sessionId, env: env) {
@@ -36133,6 +36132,27 @@ export default CMUXSessionRestore;
                 }
             }
 
+            if def.name == "codex", codexLifecycle?.usesLegacyIdentity == true,
+               !suppressCompletionNotification {
+                for priorTurnId in activePromptTurnIdsForStop
+                    where terminalActivePromptTurnIdsForStop.contains(priorTurnId) {
+                    emitAgentJournalEvent(
+                        client: client,
+                        kind: .idleObserved,
+                        source: def.name,
+                        agentKey: def.statusKey,
+                        sessionId: sessionId,
+                        workspaceId: workspaceId,
+                        surfaceId: surfaceId,
+                        nativeEvent: "transcript-terminal",
+                        attention: AgentAttentionContext(turnIdentity: priorTurnId),
+                        occurredAtMs: Self.semanticOccurredAtMs(input.rawObject),
+                        store: store,
+                        telemetry: telemetry
+                    )
+                }
+            }
+
             // The journal records the turn boundary unconditionally: the
             // reducer's per-session fold handles stale sessions (a newer
             // running session outranks this one) and subagent tagging keeps

Packages/macOS/CmuxControlSocket/Sources/CmuxControlSocket/Wire/ControlCommandExecutionPolicy.swift

@@ -125,8 +125,11 @@ public enum ControlCommandExecutionPolicy: Sendable, Equatable {
         // surfaces. Keep them on the worker lane so markdown/file-preview panes
         // reach TerminalController's mobile.panel.artifact.* dispatcher instead
         // of the main-actor switch returning method_not_found.
+        // `mobile.panel.artifact.fetch` is deliberately absent: it needs the
+        // authenticated mobile RPC execution context, so the local control
+        // socket answers method_not_found instead of bypassing
+        // artifact-transfer authorization (the worker switch has no case for it).
         "mobile.panel.artifact.stat",
-        "mobile.panel.artifact.fetch",
         "mobile.panel.artifact.thumbnail",
         "system.top",
         "system.memory",

Packages/macOS/CmuxControlSocket/Tests/CmuxControlSocketTests/ControlCommandExecutionPolicyTests.swift

@@ -56,8 +56,7 @@ struct ControlCommandExecutionPolicyTests {
             "vault.sessions", "vault.search", "vault.checkpoints",
             "vault.checkpoint", "vault.fork",
             "mobile.compatible_tags.get", "mobile.compatible_tags.set",
-            "mobile.panel.artifact.stat", "mobile.panel.artifact.fetch",
-            "mobile.panel.artifact.thumbnail",
+            "mobile.panel.artifact.stat", "mobile.panel.artifact.thumbnail",
             // JavaScript-evaluating browser methods block on page JS and must
             // not hold the main actor (see socketWorkerMethods rationale).
             "browser.eval", "browser.wait", "browser.snapshot", "browser.click",
@@ -89,6 +88,9 @@ struct ControlCommandExecutionPolicyTests {
             "workspace.create", "browser.url.get",
             "browser.open_split", "browser.get.title", "browser.frame.main",
             "mobile.terminal.create", "mobile.task.attachment.upload",
+            // Artifact fetch needs the authenticated mobile execution context;
+            // the local socket must answer method_not_found, not serve bytes.
+            "mobile.panel.artifact.fetch",
             "vmx.create", "",
             // Focus-intent verbs stay on the main lane until the mutations
             // tranche decides them deliberately.
@@ -174,7 +176,7 @@ struct ControlCommandExecutionPolicyTests {
         #expect(ControlCommandExecutionPolicy(forMethod: "system.top") == .socketWorker(mainThreadCallable: false))
         #expect(ControlCommandExecutionPolicy(forMethod: "mobile.task.models.list") == .socketWorker(mainThreadCallable: false))
         #expect(ControlCommandExecutionPolicy(forMethod: "mobile.panel.artifact.stat") == .socketWorker(mainThreadCallable: false))
-        #expect(ControlCommandExecutionPolicy(forMethod: "mobile.panel.artifact.fetch") == .socketWorker(mainThreadCallable: false))
+        #expect(ControlCommandExecutionPolicy(forMethod: "mobile.panel.artifact.fetch") == .mainActor)
         #expect(ControlCommandExecutionPolicy(forMethod: "mobile.panel.artifact.thumbnail") == .socketWorker(mainThreadCallable: false))
         #expect(ControlCommandExecutionPolicy(forMethod: "vm.create") == .socketWorker(mainThreadCallable: false))
     }

Resources/markdown-viewer/shell.html

@@ -1188,6 +1188,13 @@
     return Math.max(0, Math.min(markdownMaxScrollY(), y));
   }
 
+  // `setMarkdownScrollY` is the viewer's only programmatic scroll, so the
+  // position it last wrote is the position the viewer is in unless something
+  // else moved it: the reader, a find match, an anchor jump. Recording it lets
+  // the scroll listener below tell those apart from a reflow, which moves
+  // content under a stationary viewer without scrolling it.
+  var markdownScrollYWeWrote = null;
+
   function setMarkdownScrollY(y) {
     var targetY = clampScrollY(y);
     var scroller = markdownScroller();
@@ -1201,6 +1208,7 @@
       }
     } finally {
       root.style.scrollBehavior = previousBehavior;
+      markdownScrollYWeWrote = markdownScrollY();
     }
   }
 
@@ -1233,8 +1241,55 @@
     };
   }
 
+  // The restore runs once synchronously, then again on the next two animation
+  // frames so late layout (images, web fonts, Mermaid) that moves the anchor is
+  // still corrected. Those follow-up passes must keep making that correction,
+  // but must never fight a scroll that happened after the content update: a
+  // queued pass that fires once the reader -- or a find match, or an anchor
+  // jump -- has already moved the viewer would yank it back to the pre-update
+  // position.
+  //
+  // The two cases are told apart causally, not by comparing positions. A reflow
+  // moves content under a stationary viewer and fires no scroll event, so the
+  // correction still runs -- that is the whole reason the frames exist. A real
+  // scroll fires one, and since `setMarkdownScrollY` is the viewer's only
+  // programmatic scroll, any scroll that leaves the viewer somewhere other than
+  // the position we last wrote came from someone else, and this transaction
+  // stands down. A new content update also cancels the frames the previous one
+  // queued.
+  //
+  // The synchronous pass is the authoritative one. Nothing in the viewer, and
+  // nothing in its tests, may treat an animation frame as the completion signal
+  // for a render: a window that is not on an active display never gets one.
+  var markdownScrollRestoreFrame = 0;
+  var markdownScrollRestoreAbandoned = true;
+  var markdownScrollListenerInstalled = false;
+
+  function installMarkdownScrollListenerIfNeeded() {
+    if (markdownScrollListenerInstalled) { return; }
+    markdownScrollListenerInstalled = true;
+    window.addEventListener('scroll', function() {
+      if (markdownScrollRestoreAbandoned) { return; }
+      if (markdownScrollYWeWrote === null) { return; }
+      if (Math.abs(markdownScrollY() - markdownScrollYWeWrote) > 1) {
+        cancelPendingMarkdownScrollRestore();
+      }
+    }, { passive: true });
+  }
+
+  function cancelPendingMarkdownScrollRestore() {
+    if (markdownScrollRestoreFrame) {
+      window.cancelAnimationFrame(markdownScrollRestoreFrame);
+    }
+    markdownScrollRestoreFrame = 0;
+    markdownScrollRestoreAbandoned = true;
+  }
+
   function restoreMarkdownScrollState(state) {
+    cancelPendingMarkdownScrollRestore();
     if (!state) { return; }
+    installMarkdownScrollListenerIfNeeded();
+    markdownScrollRestoreAbandoned = false;
     function apply() {
       var targetY;
       if (state.nearTop) {
@@ -1252,10 +1307,18 @@
       }
       setMarkdownScrollY(targetY);
     }
-    apply();
-    window.requestAnimationFrame(function() {
+    function reapplyUnlessAbandoned() {
+      markdownScrollRestoreFrame = 0;
+      if (markdownScrollRestoreAbandoned) { return false; }
       apply();
-      window.requestAnimationFrame(apply);
+      return true;
+    }
+    apply();
+    markdownScrollRestoreFrame = window.requestAnimationFrame(function() {
+      if (!reapplyUnlessAbandoned()) { return; }
+      markdownScrollRestoreFrame = window.requestAnimationFrame(function() {
+        reapplyUnlessAbandoned();
+      });
     });
   }
 

Sources/AppDelegate+NewCloudWorkspace.swift

@@ -65,11 +65,26 @@ extension AppDelegate {
         }
     }
 
+    /// The window a finished Cloud creation is allowed to navigate: the window
+    /// that started the creation, and only while that window is still key.
+    /// A creation that lands while the user is working in another window must
+    /// not pull them away from it.
+    ///
+    /// This asks the window itself, the same way every other focus-gated path
+    /// in the app does, rather than comparing against `NSApp.keyWindow`. The
+    /// two agree in the running app, and the window-scoped question is the one
+    /// this rule is actually about.
+    func cloudWorkspaceCreationFocusWindow(windowID: UUID) -> NSWindow? {
+        guard let context = mainWindowContexts.values.first(where: { $0.windowId == windowID }),
+              let window = resolvedWindow(for: context),
+              window.isKeyWindow else { return nil }
+        return window
+    }
+
     private func focusCreatedCloudWorkspace(_ workspaceID: UUID, manager: TabManager?, revision: UInt64, windowID: UUID) {
         guard let manager, manager.cloudWorkspaceSelection.revision == revision,
               tabManagerFor(windowId: windowID) === manager,
-              let window = mainWindowContexts.values.first(where: { $0.windowId == windowID }).flatMap({ resolvedWindow(for: $0) }),
-              window === NSApp.keyWindow,
+              cloudWorkspaceCreationFocusWindow(windowID: windowID) != nil,
               let workspace = manager.workspacesById[workspaceID] else { return }
         manager.selectWorkspace(workspace)
     }

Sources/AppDelegate.swift

@@ -9719,8 +9719,14 @@ final class AppDelegate: NSObject, NSApplicationDelegate, UNUserNotificationCent
         // An addressable duplicate window can fail closed during reindexing;
         // retain the validated active owner until routing resolves rather than
         // pruning it merely because its cached AppKit identity is transiently
-        // absent. Windowless app shortcuts still prune as before.
-        if (event == nil || eventContext != nil) && pruneWindowlessActiveMainWindowContext() {
+        // absent. That race only exists when the event names a window, so gate
+        // the deferral on the event's addressability: an event that carries no
+        // window at all (windowNumber 0 responder-chain shortcuts) has no
+        // reindexing candidate to protect, and must still prune as before.
+        let eventDefersActiveContextPrune = event.map { event in
+            eventContext == nil && shortcutEventHasAddressableWindow(event)
+        } ?? false
+        if !eventDefersActiveContextPrune && pruneWindowlessActiveMainWindowContext() {
 #if DEBUG
             logWorkspaceCreationRouting(
                 phase: "choose",

Sources/Cloud/CloudTreeNode.swift

@@ -578,7 +578,8 @@ enum CloudTreeNodeBuilder {
         let projectionIndex = LocalProjectionIndex(snapshot: snapshot, unreadTerminalIDs: unreadTerminalIDs)
         let resourceNodeBuilder = CloudTreeMachineResourceNodeBuilder()
         var identities = adoptedOperationIDs
-        for operation in pendingCreates where !operation.request.isBaseSetup {
+        for operation in pendingCreates where !operation.request.isBaseSetup &&
+            (operation.isRunning || operation.isReconciling) {
             if let id = operation.createdMachineID ?? operation.reconcilingMachineID, identities[id] == nil {
                 identities[id] = operation.id
             }
@@ -600,9 +601,8 @@ enum CloudTreeNodeBuilder {
             nodes.append(CloudTreeNode(id: nodeID(pendingCreate: operation.id), kind: .pendingMachine(operation)))
         }
         let infoByMachine = Dictionary(snapshot.machines.map { ($0.id, $0) }, uniquingKeysWith: { first, _ in first })
-        let failedIDs = Set(pendingCreates.filter { !$0.request.isBaseSetup && $0.failureOutput != nil }.compactMap(\.createdMachineID))
-        var seen = failedIDs
-        for machine in machines where !failedIDs.contains(machine.id) {
+        var seen = Set<String>()
+        for machine in machines {
             seen.insert(machine.id)
             let info = infoByMachine[.cloud(machine.id)]
             let stableID = identities[machine.id].map { nodeID(pendingCreate: $0) }

Sources/Cloud/MachineCreateCoordinator.swift

@@ -34,7 +34,10 @@ final class MachineCreateCoordinator {
         cancelCreatedMachine: { CloudVMActionLauncher.shared.destroyMachineBestEffort($0) },
         cancelOperation: { operation in
             guard let workspaceID = operation.request.presentationWorkspaceID else { return }
-            NewMachineSheetPresenter.closeReservedWorkspace(workspaceID)
+            NewMachineSheetPresenter.closeReservedWorkspace(
+                workspaceID,
+                machineID: operation.createdMachineID ?? operation.reconcilingMachineID
+            )
         }
     )
     static let didChangeNotification = Notification.Name("cmux.machineCreate.didChange")