@@ -91,6 +91,16 @@
       "file": "packages/platform-apple/src/app-resolution-facade.ts",
       "exports": ["buildAppNotInstalledError"]
     },
+    {
+      "comment": "Runner operations reach the daemon only through the memoized loader in src/platform-runtime-apple-application-tools.ts (one dynamic import per specifier, #2314). Fallow cannot connect a member read off that loader's promise to these re-exports; keep the list to the facade members no static import consumes.",
+      "file": "packages/platform-apple/src/runner-operations-facade.ts",
+      "exports": [
+        "detachIosSimulatorRunnerSessionsForShutdown",
+        "hasLiveIosRunnerSession",
+        "releaseSpeculativeIosRunnerSessionFor",
+        "stopAllIosRunnerSessions"
+      ]
+    },
     {
       "comment": "Apple install mechanics are reached through the named install-artifact façade. Fallow cannot connect workspace package exports to these source exports; keep this list limited to the actual facade re-exports.",
       "file": "packages/platform-apple/src/core/install-artifact.ts",
 
@@ -29,7 +29,7 @@ on:
       - 'packages/*/src/**/*.test.ts'
       - 'packages/*/src/**/__tests__/**/*.ts'
       - 'packages/platform-android/src/**'
-      - 'src/snapshot/snapshot-presentation/android/**'
+      - 'packages/capture-kit/src/snapshot/snapshot-presentation/android/**'
       - 'packages/platform-harmonyos/src/**'
       - 'packages/platform-linux/src/**'
       - 'packages/platform-vega/src/**'
@@ -153,6 +153,8 @@ jobs:
             -xctestrun "$XCTESTRUN_PATH" \
             -destination "platform=iOS Simulator,id=${{ steps.ios-simulator.outputs.simulator-udid }}" \
             -only-testing:AgentDeviceRunnerUITests/RunnerTests/testSinglePointerFlingFallsBackToXCTestCoordinateDragWhenPrivateSynthesisFails \
+            -only-testing:AgentDeviceRunnerUITests/RunnerTests/testAlertDispatchResolvesItsOwnModalWithoutCoordinateTapRoutingProbe \
+            -only-testing:AgentDeviceRunnerUITests/RunnerTests/testAlertResolutionCannotBypassRequestedDeadline \
             -only-testing:AgentDeviceRunnerUITests/RunnerTests/testTypeWithoutResolvedInputReturnsTypedFailureBeforeDispatchingText \
             -only-testing:AgentDeviceRunnerUITests/RunnerTests/testBareTypeUsesTappedInputWhenSoftwareKeyboardIsHidden \
             -only-testing:AgentDeviceRunnerUITests/RunnerTests/testHardwareKeyboardResponderConfirmsItsOwnKeyboardFocus \
 
@@ -9,6 +9,13 @@
   opening the request log. Long waits keep the first five and last twenty-five polls. The replay
   landmark-mismatch refusal carries the same poll evidence next to its mismatch details; `wait
   --stable` timeouts and a never-readable strict absence keep their existing diagnostics.
+- Fixed: Android `orientation` now returns once the display reports the requested rotation
+  (polling `dumpsys display`, up to 15s) instead of right after writing the settings. On a loaded
+  emulator the rotation takes seconds, during which accessibility reads hang, so the next command
+  paid for the transition; a `wait` issued right after `orientation` could spend its whole budget
+  there. A display that never reaches the requested rotation now fails the command with the
+  observed rotation instead of reporting success; a display that reports no rotation is left to
+  the setting as before.
 - Fixed: the iOS Simulator AX snapshot route bounds how long a capture waits for app discovery
   and stops starting a discovery per capture. Discovery (`simctl launchctl list` through xcrun)
   takes seconds on a loaded host; a capture now waits at most 1.5s for the one in-flight
 
@@ -110,24 +110,25 @@ A device-scoped pause on agent mutations during human operation.
 ### Commands and routing
 
 **Command surface**:
-The catalog of public command identity, interface exposure, adapter policy, and metadata across
-entrypoints.
+The catalog of public command identity, exposure, adapter policy, and metadata across entrypoints.
 
 **Runtime use**:
-A command's platform-neutral declaration of required operations and optional preferred fast paths.
+A command's platform-neutral declaration of required operations and preferred fast paths.
 
 **Inventory use**:
-An inventory command's platform-neutral declaration for composing device sources without binding one.
+An inventory command's platform-neutral declaration for composing device sources unbound.
 
 **Daemon command registry**:
 The daemon-side truth for route ownership and request-policy traits.
 
 **Runner command traits**:
-Per-command classifications controlling Apple runner lifecycle and recovery behavior
-independently of the public command surface.
+Per-command classes steering Apple runner lifecycle and recovery, independent of the public surface.
+
+**Runner demand**:
+What a Simulator open prepares, or releases unused, of the XCTest runner for remaining steps.
 
 **Daemon RPC protocol version**:
-The integer used to detect breaking compatibility across the remote daemon boundary.
+The integer that detects breaking compatibility across the remote daemon boundary.
 
 **Version-skew invariant**:
 Local client and daemon versions must match; only remote daemons, separately versioned helpers,
 
@@ -825,70 +825,6 @@ extension RunnerTests {
     XCTAssertTrue(response.error?.hint?.contains("runner session will be restarted") == true)
   }
 
-#if os(iOS)
-  func testAlertResolutionCannotBypassRequestedDeadline() throws {
-    final class ResultBox {
-      var error: Error?
-      var probeDeadline: Date?
-      var observedDeadline: Date?
-      var commandStartedAt: Date?
-    }
-    let box = ResultBox()
-    let releaseResolution = DispatchSemaphore(value: 0)
-    let resolutionExited = expectation(description: "bounded alert resolution exited")
-    let commandFinished = expectation(description: "alert command respected its deadline")
-    let command = try runnerCommandFixture(
-      #"{"command":"alert","commandId":"alert-deadline","appBundleId":"com.apple.springboard","action":"get","timeoutMs":500}"#
-    )
-    currentApp = springboard
-    currentBundleId = Self.springboardBundleId
-    systemModalProbeOverrideForTesting = { deadline in
-      box.probeDeadline = deadline
-      return nil
-    }
-    alertResolutionOverrideForTesting = { deadline in
-      box.observedDeadline = deadline
-      _ = releaseResolution.wait(timeout: .now() + 1)
-      resolutionExited.fulfill()
-      return nil
-    }
-    defer {
-      releaseResolution.signal()
-      systemModalProbeOverrideForTesting = nil
-      alertResolutionOverrideForTesting = nil
-      currentApp = nil
-      currentBundleId = nil
-    }
-
-    DispatchQueue(label: "agent-device.runner.tests.alert-deadline").async {
-      box.commandStartedAt = Date()
-      do {
-        _ = try self.executeDispatched(command: command)
-      } catch {
-        box.error = error
-      }
-      commandFinished.fulfill()
-    }
-
-    wait(for: [commandFinished], timeout: 1)
-    let error = box.error as NSError?
-    XCTAssertEqual(error?.domain, RunnerErrorDomain.general)
-    XCTAssertEqual(error?.code, RunnerErrorCode.mainThreadExecutionTimedOut)
-    XCTAssertNotNil(box.probeDeadline)
-    XCTAssertNotNil(box.observedDeadline)
-    if let probeDeadline = box.probeDeadline,
-      let observedDeadline = box.observedDeadline,
-      let commandStartedAt = box.commandStartedAt
-    {
-      XCTAssertEqual(probeDeadline.timeIntervalSince(observedDeadline), 0, accuracy: 0.01)
-      XCTAssertEqual(observedDeadline.timeIntervalSince(commandStartedAt), 0.5, accuracy: 0.05)
-    }
-
-    releaseResolution.signal()
-    wait(for: [resolutionExited], timeout: 1)
-  }
-#endif
-
   func testRunMainThreadWorkExecutesOffMainCallerOnMainThread() {
     final class ResultBox {
       var observedMainThread: Bool?
@@ -1135,10 +1071,7 @@ extension RunnerTests {
       ? Date().addingTimeInterval(Self.alertCommandTimeout(timeoutMs: command.timeoutMs))
       : nil
     if Thread.isMainThread {
-      let routeToSpringboard = shouldRouteToSpringboardBlockingSystemModal(
-        command,
-        deadline: alertDeadline
-      )
+      let routeToSpringboard = shouldRouteToSpringboardBlockingSystemModal(command)
       return try executeOnMainSafely(
         command: command,
         alertDeadline: alertDeadline,
@@ -1148,10 +1081,7 @@ extension RunnerTests {
     // Resolve this before the command's outer main-thread block. If the bounded probe abandons
     // slow XCTest enumeration, return the established recoverable response instead of queueing
     // command preparation behind work that may outlive the 30-second command watchdog.
-    let routeToSpringboard = shouldRouteToSpringboardBlockingSystemModal(
-      command,
-      deadline: alertDeadline
-    )
+    let routeToSpringboard = shouldRouteToSpringboardBlockingSystemModal(command)
     if let unavailable = runnerUnavailableResponse(command: command) {
       return unavailable
     }
@@ -2652,20 +2582,18 @@ extension RunnerTests {
   }
 
   private func shouldRouteToSpringboardBlockingSystemModal(
-    _ command: Command,
-    deadline: Date? = nil
+    _ command: Command
   ) -> Bool {
 #if os(iOS)
-    guard command.command == .alert || isCoordinateOnlyTap(command) else {
+    guard isCoordinateOnlyTap(command) else {
       return false
     }
     #if AGENT_DEVICE_RUNNER_UNIT_TESTS
     if let override = blockingSystemModalPresenceOverrideForTesting {
       return override
     }
     #endif
-    let budgetDeadline = Date().addingTimeInterval(systemModalProbeBudget)
-    let probeDeadline = deadline.map { min($0, budgetDeadline) } ?? budgetDeadline
+    let probeDeadline = Date().addingTimeInterval(systemModalProbeBudget)
     // `runMainThreadWork` executes inline for a main-thread caller, so that path cannot use its
     // timeout machinery. Direct main-thread dispatch keeps the prior synchronous modal check;
     // normal off-main command dispatch uses the bounded probe and post-probe busy recovery.
 
@@ -108,7 +108,7 @@ extension RunnerTests {
     // old PID before refreshCachedTargetIfProcessChanged can observe it.
     clearSnapshotXCTestChannelPenalty(reason: "external_app_relaunch")
     clearPrivateAXAcceptedDepth(reason: "external_app_relaunch")
-    needsFirstInteractionDelay = true
+    beginFirstInteractionStabilization()
     return Response(ok: true, data: DataPayload(message: "target reset"))
   }
 
@@ -132,7 +132,7 @@ extension RunnerTests {
     clearSnapshotXCTestChannelPenalty(reason: "target_process_changed")
     clearPrivateAXAcceptedDepth(reason: "target_process_changed")
     snapshotXCTestPenaltyWarmupExemptionPending = true
-    needsFirstInteractionDelay = true
+    beginFirstInteractionStabilization()
   }
 
   static func processIdentifier(of target: XCUIApplication) -> Int? {
@@ -205,7 +205,7 @@ extension RunnerTests {
     currentAppProcessIdentifier = Self.processIdentifier(of: target)
     clearRememberedTextEntryTap()
     snapshotXCTestPenaltyWarmupExemptionPending = false
-    needsFirstInteractionDelay = true
+    beginFirstInteractionStabilization()
     return target
   }
 
@@ -320,12 +320,19 @@ extension RunnerTests {
       sleepFor(postSnapshotInteractionDelay)
       needsPostSnapshotInteractionDelay = false
     }
-    if needsFirstInteractionDelay {
-      sleepFor(firstInteractionAfterActivateDelay)
-      needsFirstInteractionDelay = false
+    if let readyUptime = firstInteractionReadyUptime {
+      sleepFor(readyUptime - ProcessInfo.processInfo.systemUptime)
+      firstInteractionReadyUptime = nil
     }
   }
 
+  /// Start the post-activation settling window. Measured from now, so the time the caller spends
+  /// getting back to us counts towards it instead of being charged twice.
+  func beginFirstInteractionStabilization() {
+    firstInteractionReadyUptime =
+      ProcessInfo.processInfo.systemUptime + firstInteractionAfterActivateDelay
+  }
+
   func sleepFor(_ delay: TimeInterval) {
     guard delay > 0 else { return }
     // Keep XCTest/UI sources moving during command-local pauses such as delayed typing.
 
@@ -66,7 +66,11 @@ final class RunnerTests: XCTestCase {
   let minRecordingFps = 1
   let maxRecordingFps = 120
   var needsPostSnapshotInteractionDelay = false
-  var needsFirstInteractionDelay = false
+  /// When the first interaction after an activation may run, on the monotonic uptime clock.
+  /// The guarantee is a minimum gap *since the activation*, not a pause at the interaction:
+  /// a caller that already spent that gap elsewhere (an agent's round trip is 190-260 ms)
+  /// has satisfied it and waits for nothing. `nil` = no activation is pending stabilization.
+  var firstInteractionReadyUptime: TimeInterval?
   var runnerAccessibilityHealth: RunnerAccessibilityHealth = .unknown
   var activeRecording: ScreenRecorder?
   let commandJournal = RunnerCommandJournal()
 
@@ -0,0 +1,101 @@
+import XCTest
+
+#if AGENT_DEVICE_RUNNER_UNIT_TESTS && os(iOS)
+extension RunnerTests {
+  func testAlertDispatchResolvesItsOwnModalWithoutCoordinateTapRoutingProbe() throws {
+    final class ResultBox {
+      var routingProbeCount = 0
+      var resolutionCount = 0
+      var response: Response?
+      var error: Error?
+    }
+    let box = ResultBox()
+    let finished = expectation(description: "alert dispatch finished")
+    currentApp = springboard
+    currentBundleId = Self.springboardBundleId
+    systemModalProbeOverrideForTesting = { _ in
+      box.routingProbeCount += 1
+      return nil
+    }
+    alertResolutionOverrideForTesting = { _ in
+      box.resolutionCount += 1
+      return nil
+    }
+    defer {
+      systemModalProbeOverrideForTesting = nil
+      alertResolutionOverrideForTesting = nil
+      currentApp = nil
+      currentBundleId = nil
+    }
+    let command = try runnerCommandFixture(
+      #"{"command":"alert","commandId":"alert-routing-once","appBundleId":"com.apple.springboard","action":"get","timeoutMs":1000}"#
+    )
+    DispatchQueue(label: "agent-device.runner.tests.alert-routing").async {
+      do {
+        box.response = try self.execute(command: command)
+      } catch {
+        box.error = error
+      }
+      finished.fulfill()
+    }
+    wait(for: [finished], timeout: 2)
+    XCTAssertNil(box.error)
+    XCTAssertEqual(box.response?.error?.code, "ALERT_NOT_FOUND")
+    XCTAssertEqual(box.resolutionCount, 1)
+    XCTAssertEqual(box.routingProbeCount, 0)
+  }
+
+  func testAlertResolutionCannotBypassRequestedDeadline() throws {
+    final class ResultBox {
+      var error: Error?
+      var observedDeadline: Date?
+      var commandStartedAt: Date?
+    }
+    let box = ResultBox()
+    let releaseResolution = DispatchSemaphore(value: 0)
+    let resolutionExited = expectation(description: "bounded alert resolution exited")
+    let commandFinished = expectation(description: "alert command respected its deadline")
+    let command = try runnerCommandFixture(
+      #"{"command":"alert","commandId":"alert-deadline","appBundleId":"com.apple.springboard","action":"get","timeoutMs":500}"#
+    )
+    currentApp = springboard
+    currentBundleId = Self.springboardBundleId
+    alertResolutionOverrideForTesting = { deadline in
+      box.observedDeadline = deadline
+      _ = releaseResolution.wait(timeout: .now() + 1)
+      resolutionExited.fulfill()
+      return nil
+    }
+    defer {
+      releaseResolution.signal()
+      alertResolutionOverrideForTesting = nil
+      currentApp = nil
+      currentBundleId = nil
+    }
+
+    DispatchQueue(label: "agent-device.runner.tests.alert-deadline").async {
+      box.commandStartedAt = Date()
+      do {
+        _ = try self.execute(command: command)
+      } catch {
+        box.error = error
+      }
+      commandFinished.fulfill()
+    }
+
+    wait(for: [commandFinished], timeout: 1)
+    let error = box.error as NSError?
+    XCTAssertEqual(error?.domain, RunnerErrorDomain.general)
+    XCTAssertEqual(error?.code, RunnerErrorCode.mainThreadExecutionTimedOut)
+    XCTAssertNotNil(box.observedDeadline)
+    if let observedDeadline = box.observedDeadline,
+      let commandStartedAt = box.commandStartedAt
+    {
+      XCTAssertEqual(observedDeadline.timeIntervalSince(commandStartedAt), 0.5, accuracy: 0.05)
+    }
+
+    releaseResolution.signal()
+    wait(for: [resolutionExited], timeout: 1)
+  }
+}
+#endif