@aarwitz/tapp 0.17.17 → 0.17.18

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "tapp",
   "description": "Give Claude hands and eyes on iOS, Android, and web apps, with exploration, replayable flows, evidence, and deterministic CI gates.",
-  "version": "0.17.17",
+  "version": "0.17.18",
   "author": {
     "name": "Aaron Horowitz",
     "url": "https://github.com/aarwitz"
@@ -24,7 +24,7 @@
       "command": "npx",
       "args": [
         "-y",
-        "@aarwitz/tapp@0.17.17",
+        "@aarwitz/tapp@0.17.18",
         "mcp"
       ],
       "cwd": "${CLAUDE_PROJECT_DIR}"

package/Harness/OCQAHarnessUITests/ExplorerTests.swift

@@ -377,6 +377,7 @@ class ExplorerTests: XCTestCase {
             let action = (cmd["action"] as? String ?? "").lowercased()
             var status = "ok"
             var loginDetail = ""
+            noteNavigationTitle() // navigation history, so `back` can recognise its control
 
             switch action {
             case "login":
@@ -429,7 +430,7 @@ class ExplorerTests: XCTestCase {
                 }
             case "back":
                 status = sessionBack()
-                if status == "no_effect" { loginDetail = "the screen did not change — there may be no back destination here, or the Back control belongs to a different navigation stack (try tap {id: \"Back\"})" }
+                if status == "no_effect" { loginDetail = "no back control on this screen, or tapping it did not change the screen — this is a root screen, or its Back belongs to a different navigation stack (try tap {id: \"Back\"}, or `swipe` for a gesture)" }
             case "wait":
                 let target = (cmd["id"] as? String).flatMap { $0.isEmpty ? nil : $0 } ?? (cmd["text"] as? String ?? "")
                 let waitMs = (cmd["timeoutMs"] as? Int) ?? 5000
@@ -484,6 +485,8 @@ class ExplorerTests: XCTestCase {
         return false
     }
 
+    private var backTitleHistory: [String] = []
+
     private func sessionTapById(_ identifier: String) -> String {
         var existedButNotHittable = false
         var existedButDisabled = false
@@ -799,6 +802,17 @@ class ExplorerTests: XCTestCase {
         return nil
     }
 
+    /// iOS labels a pushed screen's back button with the PARENT screen's title ("Todo List"),
+    /// not "Back", so a back control cannot be recognised by its own label alone. Remember the
+    /// titles we have actually been on; a leading navigation-bar button named after one of them
+    /// is a genuine back control, while a custom leading action (Share, Delete) is not.
+    private func noteNavigationTitle() {
+        let title = app.navigationBars.firstMatch.identifier
+        guard !title.isEmpty, backTitleHistory.last != title else { return }
+        backTitleHistory.append(title)
+        if backTitleHistory.count > 20 { backTitleHistory.removeFirst() }
+    }
+
     /// Leave a system-owned surface. A share sheet is a presented sheet, not a pushed screen:
     /// `back` does nothing and a mid-screen swipe scrolls its content instead of dismissing it.
     /// Try its real affordances in order, and say honestly whether we actually got out.
@@ -855,24 +869,74 @@ class ExplorerTests: XCTestCase {
         let beforeTitle = detectTitle(beforeElements) ?? "Unknown"
         let beforeHash = computeHash(beforeElements)
 
-        // A NavigationStack inside a sheet has its own navigation bar; `navigationBars.firstMatch`
-        // can resolve the wrong one, so prefer an explicitly labelled, hittable Back control.
-        let labelled = app.buttons.matching(NSPredicate(format: "label ==[c] %@", "Back")).allElementsBoundByIndex
-        if let back = labelled.first(where: { $0.exists && $0.isHittable }) {
-            back.tap()
-        } else {
-            let backButton = app.navigationBars.buttons.firstMatch
-            if backButton.exists && backButton.isHittable {
-                backButton.tap()
-            } else {
-                app.coordinate(withNormalizedOffset: CGVector(dx: 0, dy: 0.5))
-                    .press(forDuration: 0.05, thenDragTo: app.coordinate(withNormalizedOffset: CGVector(dx: 0.8, dy: 0.5)))
-            }
-        }
+        // ONLY a real back affordance counts. Tapping `navigationBars.buttons.firstMatch` meant
+        // that on a screen with no back button, `back` fired whatever toolbar action happened to
+        // come first — observed live: it tapped Share, opened the share sheet, saw the screen
+        // change and reported "ok". A back that performs an unrelated (possibly destructive)
+        // action is worse than one that does nothing.
+        let isBackAffordance = NSPredicate(format:
+            "label ==[c] 'Back' OR label BEGINSWITH[c] 'Back to' OR identifier ==[c] 'BackButton' OR identifier CONTAINS[c] 'back-button'")
+        var backControls = app.buttons.matching(isBackAffordance).allElementsBoundByIndex
+        if backControls.first(where: { $0.exists && $0.isHittable }) == nil {
+            // The standard iOS back button: the navigation bar's leading control, labelled with
+            // a screen we have already been on. A leading button named anything else (Share,
+            // Delete) is an app action, not a back, and must never be tapped by `back`.
+            // The navigation bar's leading control. Recognising it cannot depend on the nav-bar
+            // identifier being readable (that varies by iOS version), so accept three shapes of
+            // the standard back button — named after a screen we have been on, named after the
+            // current screen (a detail view that inherits its parent's title), or a bare chevron
+            // with no label — while never accepting a named app action.
+            let appActionLabels: Set<String> = ["share", "delete", "remove", "add", "edit", "save",
+                                                "done", "cancel", "close", "more", "sign out",
+                                                "log out", "settings", "search", "filter", "menu"]
+            let leading = app.navigationBars.buttons.allElementsBoundByIndex.first
+            if let leading, leading.exists, leading.isHittable,
+               !appActionLabels.contains(leading.label.lowercased()),
+               backTitleHistory.contains(leading.label) || leading.label == beforeTitle || leading.label.isEmpty {
+                backControls = [leading]
+            }
+        }
+        guard let back = backControls.first(where: { $0.exists && $0.isHittable }) else {
+            // No back affordance: say so, and do nothing. The edge-swipe fallback used to run
+            // here and it was not a back — on a screen whose content scrolls sideways the drag
+            // landed in the content and navigated FORWARD ("Dashboard" → "What's New"), which
+            // `back` then reported as a successful pop. A caller who wants the gesture can ask
+            // for it explicitly with `swipe`.
+            print("OCQA_STATE:back_check before=\(beforeTitle) control=none")
+            return "no_effect"
+        }
+        let backLabel = back.label
+        // The CONTROLS on screen are the evidence a pop happened. Re-reading the tapped element
+        // does not work: XCUIElement is a lazy query, so `back.exists` after the tap re-resolves
+        // "the navigation bar's first button" against the NEW screen and finds whatever leads it
+        // there — so a successful pop looked like the control was still present. Titles do not
+        // work either: a detail view that inherits its parent's title reads the same on both
+        // sides. A pop replaces the screen's controls, and that is what we compare.
+        let controlLabels = { (elements: [SimpleElement]) -> Set<String> in
+            Set(elements.filter { self.isInteractable($0.type) && $0.isEnabled }
+                .map { self.normalizeVisibleText($0.label) }
+                .filter { !$0.isEmpty })
+        }
+        let beforeControls = controlLabels(beforeElements)
+        back.tap()
         waitForUIStability(timeout: 1.5)
         let afterElements = readUITree(app)
         let afterTitle = detectTitle(afterElements) ?? "Unknown"
-        if afterTitle != beforeTitle || computeHash(afterElements) != beforeHash { return "ok" }
+        let afterControls = controlLabels(afterElements)
+        // Two or more controls differing is a screen change; one is ordinary content churn.
+        let changedControls = beforeControls.symmetricDifference(afterControls).count
+        print("OCQA_STATE:back_check before=\(beforeTitle) after=\(afterTitle) control=\(backLabel) changedControls=\(changedControls)")
+        if changedControls >= 2 { return "ok" }
+        // Navigation is a change of SCREEN, and the screen's identity is its title. A raw tree
+        // hash is too sensitive to be evidence of it: a dashboard with delayed content or a
+        // relative timestamp changes hash on its own, which made a no-op back at a root screen
+        // look like a successful pop (observed on the corpus app). Fall back to the hash only
+        // when neither read produced a title to compare.
+        // Observability: a back that reports the wrong thing is invisible without this.
+        if afterTitle != beforeTitle { return "ok" }
+        if beforeTitle == "Unknown" && afterTitle == "Unknown" {
+            return computeHash(afterElements) != beforeHash ? "ok" : "no_effect"
+        }
         return "no_effect"
     }
 
@@ -964,6 +1028,7 @@ class ExplorerTests: XCTestCase {
             let taskName = (raw["__tappTask"] as? [String: Any])?["name"] as? String ?? ""
             // A step is either {action: value} sugar or {action:..., target/value/...}. Normalize.
             let (action, step) = normalizeFlowStep(raw)
+            noteNavigationTitle() // navigation history, so `back` can recognise its control
             let target = subst((step["target"] as? String) ?? "")
             let value = subst((step["value"] as? String) ?? "")
             let timeoutMs = (step["timeoutMs"] as? Int) ?? (step["timeout"] as? Int) ?? flowDefaultTimeoutMs
@@ -1004,7 +1069,11 @@ class ExplorerTests: XCTestCase {
             case "swipe":
                 switch target.lowercased() { case "down": app.swipeDown(); case "left": app.swipeLeft(); case "right": app.swipeRight(); default: app.swipeUp() }
             case "back":
-                _ = tryGoBack()
+                // Same rule as the session (#10): a back that did not navigate is a failed step,
+                // not a silent pass — the rest of the Flow would otherwise run against the wrong
+                // screen and fail somewhere unrelated.
+                status = sessionBack() == "ok" ? "pass" : "fail"
+                if status == "fail" { detail = "back did not navigate: no back control on this screen, or tapping it did not change the screen\(visibleLabelsHint())" }
             case "wait":
                 Thread.sleep(forTimeInterval: Double(timeoutMs) / 1000.0)
             case "wait_for":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aarwitz/tapp",
-  "version": "0.17.17",
+  "version": "0.17.18",
   "mcpName": "io.github.aarwitz/tapp",
   "description": "Let coding agents verify UI changes on real iOS, Android, and web surfaces, then enforce reviewed proof in deterministic CI.",
   "license": "MIT",