@@ -93,6 +93,11 @@ extension RunnerTests {
     }
     let waitResult = semaphore.wait(timeout: .now() + timeout)
     if waitResult == .timedOut {
+      #if AGENT_DEVICE_RUNNER_UNIT_TESTS
+      mainThreadWorkTimedOutForTesting?()
+      #endif
+      // Work that finished before the lock was taken already stored its result: it is answered
+      // like work that finished in time, so an action that happened is never reported as a timeout.
       mainThreadWorkLock.lock()
       let abandoned = !workState.finished
       if abandoned {
@@ -110,8 +115,8 @@ extension RunnerTests {
           timeout
         )
         onAbandoned?()
+        throw timeoutError()
       }
-      throw timeoutError()
     }
     switch result {
     case .success(let value):
@@ -225,5 +230,71 @@ extension RunnerTests {
       return XCTFail("expected the runner idle once the abandoned work drained")
     }
   }
+
+  func testRunMainThreadWorkReturnsWorkThatFinishedAtTheTimeoutBoundary() {
+    let outcome = runMainThreadWorkFinishingAtTheTimeoutBoundary { 42 }
+
+    XCTAssertNil(outcome.error, "work that finished before the lock must not read as a timeout")
+    XCTAssertEqual(outcome.value, 42)
+    XCTAssertEqual(outcome.abandonedCount, 0)
+    XCTAssertEqual(outcome.onAbandonedCalls, 0)
+  }
+
+  func testRunMainThreadWorkRethrowsWorkThatFailedAtTheTimeoutBoundary() {
+    let outcome = runMainThreadWorkFinishingAtTheTimeoutBoundary { () throws -> Int in
+      throw NSError(domain: "agent-device.runner.tests", code: 7)
+    }
+
+    XCTAssertNil(outcome.value)
+    XCTAssertEqual((outcome.error as NSError?)?.domain, "agent-device.runner.tests")
+    XCTAssertEqual((outcome.error as NSError?)?.code, 7)
+    XCTAssertEqual(outcome.abandonedCount, 0)
+    XCTAssertEqual(outcome.onAbandonedCalls, 0)
+  }
+
+  private final class BoundaryOutcome {
+    var value: Int?
+    var error: Error?
+    var abandonedCount: Int?
+    var onAbandonedCalls = 0
+  }
+
+  /// Times the wait out immediately, then lets the work finish before the watchdog takes the lock:
+  /// the seam releases the blocked work and waits for the serial main queue to run past it.
+  private func runMainThreadWorkFinishingAtTheTimeoutBoundary(
+    _ produce: @escaping () throws -> Int
+  ) -> BoundaryOutcome {
+    let outcome = BoundaryOutcome()
+    let releaseWork = DispatchSemaphore(value: 0)
+    let finished = expectation(description: "off-main caller finished")
+    mainThreadWorkTimedOutForTesting = {
+      releaseWork.signal()
+      DispatchQueue.main.sync {}
+    }
+    defer { mainThreadWorkTimedOutForTesting = nil }
+
+    DispatchQueue(label: "agent-device.runner.tests.timeout-boundary").async {
+      do {
+        outcome.value = try self.runMainThreadWork(
+          "command_execution",
+          timeout: 0,
+          timeoutError: self.mainThreadExecutionTimeoutError,
+          onAbandoned: { outcome.onAbandonedCalls += 1 }
+        ) {
+          _ = releaseWork.wait(timeout: .now() + 2)
+          return try produce()
+        }
+      } catch {
+        outcome.error = error
+      }
+      self.mainThreadWorkLock.lock()
+      outcome.abandonedCount = self.abandonedMainThreadWorkCount
+      self.mainThreadWorkLock.unlock()
+      finished.fulfill()
+    }
+
+    wait(for: [finished], timeout: 3)
+    return outcome
+  }
 }
 #endif
@@ -197,6 +197,9 @@ final class RunnerTests: XCTestCase {
   var blockingSystemModalPresenceOverrideForTesting: Bool?
   var alertResolutionOverrideForTesting: ((Date) -> RunnerAlert?)?
   var alertButtonHittabilityProbeOverrideForTesting: ((Date) -> Bool)?
+  // Runs on the waiting thread after `runMainThreadWork`'s wait timed out and before it takes the
+  // lock that decides between finished and abandoned, so a test can finish the work in that window.
+  var mainThreadWorkTimedOutForTesting: (() -> Void)?
   #endif
   // Observability for the record(_:) suppression below: how many AX-broken-screen snapshot
   // issues this session muted, so wedge investigations see the volume without grepping logs.