@@ -317,7 +317,7 @@ extension RunnerTests {
       && deadline.timeIntervalSince(now) >= Self.penalizedXCTestProbeTreeSliceBudget
   }
 
-  private func runScheduledSnapshotXCTestRecoveryProbeIfNeeded(
+  private func scheduleSnapshotXCTestRecoveryProbeIfNeeded(
     effective: EffectiveSnapshotCapturePlan,
     acceptedBackend: SnapshotBackendKind,
     target: SnapshotCaptureTarget,
@@ -338,10 +338,34 @@ extension RunnerTests {
       hasAbandonedWork: abandoned
     )
     if scheduled {
-      snapshotXCTestChannelNextRecoveryProbeAt = now.addingTimeInterval(Self.snapshotXCTestRecoveryProbeInterval)
+      snapshotXCTestChannelNextRecoveryProbeAt = .distantFuture
     }
+    let penaltyUntil = snapshotXCTestChannelPenaltyUntil
     snapshotXCTestChannelPenaltyLock.unlock()
     guard scheduled else { return }
+    commandExecutionQueue.async {
+      self.snapshotXCTestChannelPenaltyLock.lock()
+      let stillCurrent = self.snapshotXCTestChannelPenaltyUntil == penaltyUntil
+        && Date() < penaltyUntil
+      if stillCurrent {
+        self.snapshotXCTestChannelNextRecoveryProbeAt = Date().addingTimeInterval(Self.snapshotXCTestRecoveryProbeInterval)
+      }
+      self.snapshotXCTestChannelPenaltyLock.unlock()
+      guard stillCurrent, !self.hasAbandonedMainThreadWork(),
+        deadline.timeIntervalSinceNow >= Self.penalizedXCTestProbeTreeSliceBudget
+      else { return }
+      self.runScheduledSnapshotXCTestRecoveryProbe(
+        target: target, options: options, channelState: effective.xCTestChannelState
+      )
+    }
+  }
+
+  private func runScheduledSnapshotXCTestRecoveryProbe(
+    target: SnapshotCaptureTarget,
+    options: PresentationOptions,
+    channelState: SnapshotXCTestChannelPlanState
+  ) {
+    let now = Date()
     let slice = Self.penalizedXCTestProbeTreeSliceBudget
     NSLog("AGENT_DEVICE_RUNNER_SNAPSHOT_XCTEST_RECOVERY_PROBE_SCHEDULED bundle=%@", target.bundleId ?? "")
     defer {
@@ -368,7 +392,7 @@ extension RunnerTests {
       attempt: attempt,
       bundleId: target.bundleId,
       penaltySuppressed: false,
-      channelState: effective.xCTestChannelState
+      channelState: channelState
     )
   }
 
@@ -512,7 +536,7 @@ extension RunnerTests {
           verdictReason?.reason ?? "sparse tree"
         )
       }
-      runScheduledSnapshotXCTestRecoveryProbeIfNeeded(
+      scheduleSnapshotXCTestRecoveryProbeIfNeeded(
         effective: effective,
         acceptedBackend: kind,
         target: target,
 
@@ -548,19 +548,37 @@ extension RunnerTests {
     snapshotXCTestChannelNextRecoveryProbeAt = .distantPast
     let expiry = snapshotXCTestChannelPenaltyUntil
     let started = Date()
-    let payload = try runDeferredPlanOffMain(target: captureTarget) {
+    let payload = try runDeferredPlanOffMain(target: captureTarget)
+    XCTAssertLessThan(Date().timeIntervalSince(started), 0.5, "the accepted capture must answer before the optional probe")
+    let probeFinished = expectation(description: "scheduled probe answered")
+    commandExecutionQueue.async {
       RunnerBlockingSnapshotGate.release.signal()
+      probeFinished.fulfill()
     }
+    wait(for: [probeFinished], timeout: 3)
     XCTAssertEqual(payload.snapshotQuality?.backend, SnapshotBackendKind.privateAX.rawValue)
     XCTAssertEqual(RunnerBlockingSnapshotGate.entered.wait(timeout: .now()), .success)
     XCTAssertLessThan(Date().timeIntervalSince(started), 2)
     XCTAssertEqual(snapshotXCTestChannelPenaltyUntil, expiry)
     let next = snapshotXCTestChannelNextRecoveryProbeAt
     XCTAssertGreaterThan(next.timeIntervalSince(started), 29)
     _ = try runDeferredPlanOffMain(target: captureTarget)
+    let queueDrained = expectation(description: "second capture queued no probe")
+    commandExecutionQueue.async { queueDrained.fulfill() }
+    wait(for: [queueDrained], timeout: 3)
     XCTAssertEqual(snapshotXCTestChannelNextRecoveryProbeAt, next)
     XCTAssertEqual(snapshotXCTestChannelPenaltyUntil, expiry)
     XCTAssertEqual(RunnerBlockingSnapshotGate.entered.wait(timeout: .now()), .timedOut)
+
+    snapshotXCTestChannelNextRecoveryProbeAt = .distantPast
+    _ = try runDeferredPlanOffMain(target: captureTarget) {
+      self.clearSnapshotXCTestChannelPenalty(reason: "replace-before-probe")
+      self.penalizeSnapshotXCTestChannel(bundleId: captureTarget.bundleId, reason: "new-penalty")
+    }
+    let staleProbeDrained = expectation(description: "stale queued probe refused")
+    commandExecutionQueue.async { staleProbeDrained.fulfill() }
+    wait(for: [staleProbeDrained], timeout: 3)
+    XCTAssertEqual(RunnerBlockingSnapshotGate.entered.wait(timeout: .now()), .timedOut)
   }
 
   private func launchPenalizedPrivateAXBlindTarget(bundleId: String) throws -> SnapshotCaptureTarget {
@@ -602,7 +620,7 @@ extension RunnerTests {
     }
     let box = ResultBox()
     let planned = expectation(description: "deferred plan answered")
-    DispatchQueue(label: "agent-device.runner.tests.deferred-plan").async {
+    commandExecutionQueue.async {
       do {
         box.payload = try self.runSnapshotCapturePlan(
           Self.regularVisiblePlan,
 
@@ -246,6 +246,8 @@ After an independent backend succeeds, a penalized regular plan can schedule the
 The interval starts when the penalty is armed.
 The one-second idle-only probe bounds all acquisition and processing work.
 The accepted independent capture remains the response.
+The existing serial command queue runs the optional probe after that response.
+A queued probe reserves the interval and checks that its penalty is still current before it starts.
 The schedule excludes physical-device plans, explicit backend pins, occupied main-thread work, and plans with less than one second remaining.
 The interval limits hostile-screen probe cost while giving healthy screens a recovery opportunity before penalty expiry.
 A normal-plan query-sweep timeout rejects the partial capture and penalizes the channel.