@@ -118,6 +118,7 @@ jobs:
             -only-testing:AgentDeviceRunnerUITests/RunnerTests/testBoundedSystemModalProbeTimeoutRecoversThenReleasesOnDrainForSnapshotRaw \
             -only-testing:AgentDeviceRunnerUITests/RunnerTests/testSnapshotTraversalIdentityPreservesSameOriginNodesWithDifferentBounds \
             -only-testing:AgentDeviceRunnerUITests/RunnerTests/testSnapshotPresentationPreservesCurrentWireShape \
+            -only-testing:AgentDeviceRunnerUITests/RunnerTests/testSnapshotPresentationOwnsBackendNeutralEligibility \
             -only-testing:AgentDeviceRunnerUITests/RunnerTests/testFlatSnapshotProjectionMatchesElementReverseScrollCapture \
             -only-testing:AgentDeviceRunnerUITests/RunnerTests/testPrivateAXDepthLimitedRequiresEveryFrontierResolved \
             -only-testing:AgentDeviceRunnerUITests/RunnerTests/testDeepExtensionCountsMissedFrontiers \
 
@@ -2,6 +2,7 @@
 
 ## Unreleased
 
+- iOS regular snapshots now apply one backend-neutral eligibility rule after every capture backend: a node survives when its accessibility type is interactive or it carries a non-empty label, identifier, or value. This removes the tree backend's extra "hittable non-Other" membership path and drops unlabeled decorative nodes consistently; labeled images, identifier-only nodes, and value-only nodes still survive. Raw snapshot membership is unchanged.
 - `agent-device mcp` now carries its own usage guidance, so MCP-only clients (Codex CLI, Cursor, custom agents) no longer depend on a separately installed skill (#1833). The handshake `instructions` — returned by both `server/discover` and, newly, the legacy `initialize` — is a compact (< 2 KB, the Claude Code truncation limit) workflow card: start with `open {app, foreground: true}` instead of probing, act with `settle: true` and continue from the diff, verify with `wait`/`is`/`get`/`find`, copy `@refs` byte-for-byte, recover from sparse/AX-unavailable, follow error hints, `close`. A new MCP-only `help` tool serves the full guides on demand: no `topic` returns the CLI's decision card; `topic` returns `agent-device help <topic|command>` verbatim (workflow, gestures, scripting, tv, macos, web, remote, debugging, …, or any tool name for its complete flag reference), prefixed with the one-line CLI→tool-property mapping. `help` is router-owned rather than a command descriptor, so it appears in `tools/list` only — not in the CLI, Node client, or `batch` — and its description tells the model it is not a startup step. Legacy `initialize` gains the optional `instructions` field; no other legacy field changes.
 - New `hover <x y|@ref|selector>` command for `--platform web` (#1783). It moves the pointer over the target without pressing, so hover-gated UI — a message row's `...` toolbar, a menu that opens on pointer enter — becomes reachable through agent-device the way it already was through the underlying `agent-browser` backend (`mouse move`). It is a member of the targeted-touch family: same `@ref`/selector/coordinate targeting, occlusion and off-screen guards, and `--settle` (the settled diff carries the revealed controls with fresh refs, e.g. `+ @e4 [button] "Delete"`), but no `--verify`, since hover reveals rather than activates. `hover @ref` publishes as a portable selector line in recorded scripts, and the Node client exposes `interactions.hover`. Hover is a pointer state that touch platforms do not have, so `capabilities` advertises it on web only and iOS/Android/Linux reject it during admission with `UNSUPPORTED_OPERATION` and a hint naming `--platform web`; `longpress` remains the mobile hold-gesture verb.
 - Internal: session recording is now derived from the script-publication lifecycle instead of being stored beside it. `SessionState.recordSession` is removed; `isRecordingPublication` answers the question from the aggregate (ordinary authoring records only while ARMED, a repair transaction records for its whole lifetime). The stored flag was a second source of truth that handler surfaces set directly, which is how #1533's aborted-recording drift arose — no surface can now arm recording without moving the lifecycle that authorizes it, and the script writer's publication gate is answered entirely by the aggregate. Behavior-preserving: the derivation reproduces what the flag held at every transition.
 
@@ -224,6 +224,11 @@ task touches:
 - Presentation options: the source-of-truth iOS snapshot request policy accepted by
   `SnapshotPresentation`. During the behavior-preserving #1797 migration acquisition still reads
   these options to reproduce current backend-specific decisions.
+- Snapshot eligibility: runner-presentation membership for the regular projection. A root carrier
+  survives for viewport geometry; every other node needs an interactive accessibility type or a
+  non-empty label, identifier, or value. Hittability is not eligibility, and raw membership is
+  exempt. Removing a wrapper reparents surviving descendants and normalizes indexes and depths.
+  Daemon compaction separately owns publication membership and its declared suppressions.
 - Presented node: wire-facing iOS snapshot value constructed only by `SnapshotPresentation`; response
   payload assembly accepts this type rather than backend-owned raw values.
 - Snapshot capture plan: per-strategy ordered chain of iOS snapshot capture backends (recursive tree,
 
@@ -240,7 +240,7 @@ extension RunnerTests {
           hints: &hiddenContentHintsByNodeIndex
         )
       }
-      let include = shouldInclude(
+      let include = shouldAcquireSnapshotNode(
         snapshot: snapshot,
         label: evaluation.label,
         identifier: evaluation.identifier,
@@ -429,7 +429,7 @@ extension RunnerTests {
       if let limit = options.depth, depth > limit { return }
 
       let evaluation = evaluateSnapshot(snapshot, in: context)
-      let include = shouldInclude(
+      let include = shouldAcquireSnapshotNode(
         snapshot: snapshot,
         label: evaluation.label,
         identifier: evaluation.identifier,
@@ -870,7 +870,9 @@ extension RunnerTests {
 
   // MARK: - Snapshot Filtering
 
-  private func shouldInclude(
+  /// Conservative acquisition gate. Regular capture keeps every node its visibility policy can
+  /// supply; `SnapshotPresentation` alone decides eligibility after the backend returns.
+  private func shouldAcquireSnapshotNode(
     snapshot: XCUIElementSnapshot,
     label: String,
     identifier: String,
@@ -887,22 +889,22 @@ extension RunnerTests {
         return false
       }
     #endif
-    if options.interactiveOnly {
-      if isScrollableContainer(snapshot, visible: visible) { return true }
+    if regularSnapshot {
       #if os(macOS)
-        if !visible && type != .application {
+        if options.interactiveOnly && !visible && type != .application {
           return false
         }
       #endif
+      if type == .application || type == .window { return true }
+      return visible
+    }
+    if options.interactiveOnly {
+      if isScrollableContainer(snapshot, visible: visible) { return true }
       if interactiveTypes.contains(type) { return true }
       if hittable && type != .other { return true }
       if hasContent { return true }
       return false
     }
-    if regularSnapshot {
-      if type == .application || type == .window { return true }
-      return visible
-    }
     return true
   }
 
 
@@ -2,9 +2,8 @@ import Foundation
 
 /// Backend-owned snapshot output before it crosses the presentation seam.
 ///
-/// Step 1 deliberately carries the fields computed by today's backend-specific implementations.
-/// Later #1797 migration steps move those decisions behind `SnapshotPresentation` without changing
-/// either the acquisition interface or the wire-facing `PresentedNode` type.
+/// The incremental #1797 migration still carries derived fields that later semantic layers move
+/// behind `SnapshotPresentation`. Eligibility is no longer one of those backend-owned decisions.
 struct RawAXNode {
   let index: Int
   let type: String
@@ -57,7 +56,16 @@ struct PresentedNode: Codable {
   let actions: [String]?
 
   fileprivate init(presenting raw: RawAXNode) {
-    index = raw.index
+    self.init(
+      presenting: raw,
+      index: raw.index,
+      depth: raw.depth,
+      parentIndex: raw.parentIndex
+    )
+  }
+
+  fileprivate init(presenting raw: RawAXNode, index: Int, depth: Int, parentIndex: Int?) {
+    self.index = index
     type = raw.type
     label = raw.label
     identifier = raw.identifier
@@ -67,26 +75,49 @@ struct PresentedNode: Codable {
     focused = raw.focused
     selected = raw.selected
     hittable = raw.hittable
-    depth = raw.depth
-    parentIndex = raw.parentIndex
+    self.depth = depth
+    self.parentIndex = parentIndex
     hiddenContentAbove = raw.hiddenContentAbove
     hiddenContentBelow = raw.hiddenContentBelow
     actions = raw.actions
   }
 }
 
 enum SnapshotPresentation {
+  private static let eligibleInteractiveTypes: Set<String> = [
+    "Button",
+    "Cell",
+    "CheckBox",
+    "CollectionView",
+    "Link",
+    "MenuItem",
+    "Picker",
+    "SearchField",
+    "SecureTextField",
+    "SegmentedControl",
+    "Slider",
+    "ScrollView",
+    "Stepper",
+    "Switch",
+    "TabBar",
+    "Table",
+    "TextField",
+    "TextView",
+    "WebView",
+  ]
+
   /// The capture plan's single presentation route for every snapshot backend.
   ///
-  /// Step 2 preserves each backend's current decisions. `options` is deliberately part of the
-  /// stable interface now; later #1797 steps move those decisions behind this seam.
+  /// Eligibility is the first intentional step-3 semantic delta: regular presentation keeps a
+  /// root carrier plus nodes with an interactive type or non-empty semantic content. Raw snapshots
+  /// retain their acquired membership until the dedicated raw-projection migration lands.
   static func present(
     _ acquisition: SnapshotAcquisition,
-    options _: PresentationOptions
+    options: PresentationOptions
   ) -> SnapshotBackendCapture {
     SnapshotBackendCapture(
       payload: DataPayload(
-        nodes: acquisition.nodes.map(PresentedNode.init(presenting:)),
+        nodes: presentedNodes(from: acquisition.nodes, options: options),
         truncated: acquisition.truncated
       ),
       effectiveDepth: acquisition.effectiveDepth,
@@ -99,65 +130,54 @@ enum SnapshotPresentation {
   static func singleElementRead(_ node: RawAXNode) -> PresentedNode {
     PresentedNode(presenting: node)
   }
-}
 
-#if AGENT_DEVICE_RUNNER_UNIT_TESTS
-import XCTest
+  private static func presentedNodes(
+    from rawNodes: [RawAXNode],
+    options: PresentationOptions
+  ) -> [PresentedNode] {
+    if options.raw {
+      return rawNodes.map(PresentedNode.init(presenting:))
+    }
 
-extension RunnerTests {
-  func testSnapshotPresentationPreservesCurrentWireShape() throws {
-    // Non-vacuity: setting PresentedNode.label to nil made this test execute once and fail on the
-    // missing `"label":"Continue"` field before the production mapping was restored.
-    let raw = RawAXNode(
-      index: 3,
-      type: "Button",
-      label: "Continue",
-      identifier: "continue-button",
-      value: "Ready",
-      rect: SnapshotRect(x: 10, y: 20, width: 100, height: 44),
-      enabled: true,
-      focused: true,
-      selected: true,
-      hittable: true,
-      depth: 2,
-      parentIndex: 1,
-      hiddenContentAbove: true,
-      hiddenContentBelow: true,
-      actions: ["Open menu"]
-    )
-    let encoder = JSONEncoder()
-    encoder.outputFormatting = [.sortedKeys]
+    var nodes: [PresentedNode] = []
+    var nearestPresentedNodeByRawIndex: [Int: (index: Int, depth: Int)] = [:]
+    for raw in rawNodes {
+      let presentedParent = raw.parentIndex.flatMap {
+        nearestPresentedNodeByRawIndex[$0]
+      }
+      guard isEligibleForRegularPresentation(raw) else {
+        if let presentedParent {
+          nearestPresentedNodeByRawIndex[raw.index] = presentedParent
+        }
+        continue
+      }
 
-    let capture = SnapshotPresentation.present(
-      SnapshotAcquisition(
-        nodes: [raw],
-        truncated: true,
-        effectiveDepth: 4,
-        customActions: SnapshotCustomActionCoverage(
-          read: 1,
-          candidates: 2,
-          truncated: 0,
-          blocked: false
+      let presentedIndex = nodes.count
+      let presentedDepth = presentedParent.map { $0.depth + 1 } ?? 0
+      nearestPresentedNodeByRawIndex[raw.index] = (presentedIndex, presentedDepth)
+      nodes.append(
+        PresentedNode(
+          presenting: raw,
+          index: presentedIndex,
+          depth: presentedDepth,
+          parentIndex: presentedParent?.index
         )
-      ),
-      options: PresentationOptions(
-        interactiveOnly: true,
-        depth: nil,
-        scope: nil,
-        raw: false
       )
-    )
-    let nodes = try XCTUnwrap(capture.payload.nodes)
-    let encoded = try encoder.encode(nodes)
+    }
+    return nodes
+  }
 
-    XCTAssertEqual(
-      String(decoding: encoded, as: UTF8.self),
-      #"[{"actions":["Open menu"],"depth":2,"enabled":true,"focused":true,"hiddenContentAbove":true,"hiddenContentBelow":true,"hittable":true,"identifier":"continue-button","index":3,"label":"Continue","parentIndex":1,"rect":{"height":44,"width":100,"x":10,"y":20},"selected":true,"type":"Button","value":"Ready"}]"#
-    )
-    XCTAssertEqual(capture.payload.truncated, true)
-    XCTAssertEqual(capture.effectiveDepth, 4)
-    XCTAssertEqual(capture.customActions?.read, 1)
-    XCTAssertEqual(capture.customActions?.candidates, 2)
+  private static func isEligibleForRegularPresentation(_ node: RawAXNode) -> Bool {
+    // The top-level carrier owns viewport geometry and must survive even for query-sweep's
+    // deliberately unlabeled synthetic Application node.
+    if node.parentIndex == nil { return true }
+    return eligibleInteractiveTypes.contains(node.type) || hasSemanticContent(node)
+  }
+
+  private static func hasSemanticContent(_ node: RawAXNode) -> Bool {
+    [node.label, node.identifier, node.value].contains { value in
+      guard let value else { return false }
+      return !value.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+    }
   }
 }
-#endif