@@ -241,6 +241,81 @@ extension RunnerTests {
     XCTAssertNil(box.error)
     XCTAssertEqual(box.observedMainThread, true)
   }
+
+  func testRunMainThreadWorkTimeoutMarksAbandonedUntilDrained() {
+    final class ResultBox {
+      var error: Error?
+      var abandonedCount: Int?
+      var abandonedSinceSet: Bool?
+      var drainedCount: Int?
+      var drainedSinceCleared: Bool?
+    }
+    let box = ResultBox()
+    let releaseWork = DispatchSemaphore(value: 0)
+    let observedAbandoned = DispatchSemaphore(value: 0)
+    let finished = expectation(description: "off-main caller timed out")
+    let drained = expectation(description: "abandoned main work drained")
+
+    DispatchQueue(label: "agent-device.runner.tests.timeout").async {
+      do {
+        _ = try self.runMainThreadWork(
+          command: nil,
+          timeout: 0,
+          timeoutError: self.mainThreadExecutionTimeoutError,
+          onAbandoned: {
+            box.abandonedCount = self.abandonedMainThreadWorkCount
+            box.abandonedSinceSet = self.abandonedMainThreadWorkSince != nil
+            observedAbandoned.signal()
+          },
+          onDrained: {
+            self.mainThreadWorkLock.lock()
+            box.drainedCount = self.abandonedMainThreadWorkCount
+            box.drainedSinceCleared = self.abandonedMainThreadWorkSince == nil
+            self.mainThreadWorkLock.unlock()
+            drained.fulfill()
+          }
+        ) {
+          _ = releaseWork.wait(timeout: .now() + 1)
+          return true
+        }
+      } catch {
+        box.error = error
+      }
+      finished.fulfill()
+    }
+
+    DispatchQueue(label: "agent-device.runner.tests.release-timeout").async {
+      _ = observedAbandoned.wait(timeout: .now() + 1)
+      releaseWork.signal()
+    }
+
+    wait(for: [finished, drained], timeout: 2)
+    XCTAssertEqual((box.error as NSError?)?.code, RunnerErrorCode.mainThreadExecutionTimedOut)
+    XCTAssertEqual(box.abandonedCount, 1)
+    XCTAssertEqual(box.abandonedSinceSet, true)
+    XCTAssertEqual(box.drainedCount, 0)
+    XCTAssertEqual(box.drainedSinceCleared, true)
+  }
+
+  func testPostSnapshotDelayMarkDoesNotQueueBehindAbandonedTreeCapture() {
+    abandonedTreeCaptureCount = 1
+    defer {
+      abandonedTreeCaptureCount = 0
+      needsPostSnapshotInteractionDelay = false
+    }
+
+    let finished = expectation(description: "off-main caller finished")
+    DispatchQueue(label: "agent-device.runner.tests.post-snapshot-delay").async {
+      self.setNeedsPostSnapshotInteractionDelay()
+      finished.fulfill()
+    }
+
+    wait(for: [finished], timeout: 1)
+    mainThreadWorkLock.lock()
+    let abandonedWorkCount = abandonedMainThreadWorkCount
+    mainThreadWorkLock.unlock()
+    XCTAssertEqual(abandonedWorkCount, 0)
+  }
 #endif
 
   func execute(command: Command) throws -> Response {
@@ -583,7 +658,7 @@ extension RunnerTests {
       timeout: mainThreadExecutionTimeout,
       timeoutError: mainThreadExecutionTimeoutError
     ) {
-      self.prepareActiveCommandContext(command: command)
+      try self.prepareActiveCommandContextSafely(command: command)
     }
     switch preparation {
     case .response(let response):
@@ -627,6 +702,10 @@ extension RunnerTests {
       needsPostSnapshotInteractionDelay = true
       return
     }
+    guard !hasAbandonedTreeCapture() else {
+      NSLog("AGENT_DEVICE_RUNNER_POST_SNAPSHOT_DELAY_MARK_SKIPPED_XCTEST_OCCUPIED")
+      return
+    }
     do {
       try runMainThreadWork(
         command: nil,
@@ -658,6 +737,28 @@ extension RunnerTests {
     }
   }
 
+  private func prepareActiveCommandContextSafely(command: Command) throws -> ActiveCommandPreparation {
+    var preparation: ActiveCommandPreparation?
+    let exceptionMessage = RunnerObjCExceptionCatcher.catchException({
+      preparation = self.prepareActiveCommandContext(command: command)
+    })
+    if let exceptionMessage {
+      throw NSError(
+        domain: RunnerErrorDomain.exception,
+        code: RunnerErrorCode.objcException,
+        userInfo: [NSLocalizedDescriptionKey: exceptionMessage]
+      )
+    }
+    guard let preparation else {
+      throw NSError(
+        domain: RunnerErrorDomain.general,
+        code: RunnerErrorCode.commandReturnedNoResponse,
+        userInfo: [NSLocalizedDescriptionKey: "snapshot preflight returned no response"]
+      )
+    }
+    return preparation
+  }
+
   private func executeOnMain(command: Command) throws -> Response {
     let preparation = prepareActiveCommandContext(command: command)
     let activeApp: XCUIApplication
 
@@ -103,6 +103,10 @@ extension RunnerTests {
     return ([.privateAX, .querySweep, .recursiveTree], true)
   }
 
+  func shouldSkipSnapshotBackendForAbandonedTreeCapture(_ kind: SnapshotBackendKind) -> Bool {
+    kind != .privateAX && hasAbandonedTreeCapture()
+  }
+
   // MARK: Plan runner
 
   func runSnapshotCapturePlan(
@@ -144,7 +148,7 @@ extension RunnerTests {
       }
       // While an abandoned tree capture is still grinding inside testmanagerd, XCTest-backed
       // tiers would block behind it; only the private AX backend stays responsive (#1105).
-      if kind != .privateAX, hasAbandonedTreeCapture() {
+      if shouldSkipSnapshotBackendForAbandonedTreeCapture(kind) {
         NSLog("AGENT_DEVICE_RUNNER_SNAPSHOT_TIER_SKIPPED_XCTEST_OCCUPIED tier=%@", kind.rawValue)
         if firstFailure == nil {
           firstFailure = (
@@ -543,6 +547,15 @@ extension RunnerTests {
     XCTAssertFalse(isSnapshotTreeBackendPenalized(bundleId: "com.other.app"))
   }
 
+  func testAbandonedTreeCaptureSkipsOnlyXCTestBackedSnapshotTiers() {
+    abandonedTreeCaptureCount = 1
+    defer { abandonedTreeCaptureCount = 0 }
+
+    XCTAssertTrue(shouldSkipSnapshotBackendForAbandonedTreeCapture(.recursiveTree))
+    XCTAssertTrue(shouldSkipSnapshotBackendForAbandonedTreeCapture(.querySweep))
+    XCTAssertFalse(shouldSkipSnapshotBackendForAbandonedTreeCapture(.privateAX))
+  }
+
   // Pins the record(_:) suppression class via its pure classifier. record(_:) itself is not
   // invoked here: feeding it the must-record variants would record real failures and fail
   // this very test run.
 
@@ -77,9 +77,9 @@ final class RunnerTests: XCTestCase {
   // Bluesky-class screens grind ~4-8s before the tree backend fails; anything past this
   // threshold marks the screen hostile so the next capture leads with private AX.
   let snapshotTreeSlowCaptureThreshold: TimeInterval = 3
-  // The blocking XCTest tree snapshot XPC runs on a worker thread with this slice so a
+  // The blocking XCTest tree snapshot XPC runs on the main thread with this slice so a
   // content-dependent grind (#1105: seconds to minutes on live Bluesky screens) cannot pin
-  // the capture plan. On timeout the XPC keeps grinding on its worker; while any abandoned
+  // the capture plan. On timeout the XPC keeps grinding on main; while any abandoned
   // tree capture is outstanding, plans skip the XCTest-backed tiers (tree, query sweep) and
   // use the private AX backend, which does not go through testmanagerd.
   let treeCaptureLock = NSLock()
 
@@ -106,6 +106,8 @@ function extractSwiftFunction(source: string, name: string): string {
   assert.notEqual(signatureIndex, -1, `missing Swift function ${name}`);
   const bodyStart = source.indexOf('{', signatureIndex);
   assert.notEqual(bodyStart, -1, `missing Swift function body ${name}`);
+  // This lightweight guard assumes the target Swift function does not contain unmatched braces
+  // inside string literals or comments; keep the source guard focused on small functions.
   let depth = 0;
   for (let index = bodyStart; index < source.length; index += 1) {
     const char = source[index];