merge origin/master into llm-recording-and-analysis

both sides independently fixed the same three bugs, so each one had to pick a
winner rather than keep both implementations.

extractor encoding: master's recordableValue in worker.go wins over ours in
marshal.go, since master's is pinned by extractor_encoding_test.go and ours had
no tests. our error semantics stay: encodeExtractorValue still returns an error
instead of nil, so an extractor cannot vanish from the trace silently.

apply errors: only the residual generic branch takes master's unconfirmed copy,
where the device may have committed the action before the call failed. the
finer branches that know nothing was dispatched keep lastAction = nil, and our
actionSkipReason taxonomy stays alongside master's held/skippedVerification.

selector matching: our matchAttr with matchSelectorKind wins over master's
match, since ours also handles idPrefix. matchSelector now calls it, which git
did not flag as a conflict and left calling a function our side had deleted.

the ltl doc comment takes master's correction: an unbounded eventually that
never fires IS violated at run end.

internal/hierarchy/hierarchy_test.go

@@ -1471,3 +1471,83 @@ func TestParseUnreadableFlagKeepsTheRestOfTheTree(t *testing.T) {
 		t.Errorf("stored UnreadableFlags = %d, want 1: the trace has to carry it", decoded.UnreadableFlags)
 	}
 }
+
+// selectorFormsDump carries one node per id shape a real dump produces, plus
+// nodes carrying a description in the ", " form the desc rule knows about and a
+// text the text rule matches on a substring.
+const selectorFormsDump = `{
+  "attributes": {"resource-id": "root", "bounds": "[0,0,400,800]"},
+  "children": [
+    {"attributes": {"resource-id": "BareThing", "bounds": "[0,0,100,50]"}, "children": []},
+    {"attributes": {"resource-id": "com.example.app:id/AndroidThing", "bounds": "[0,50,100,100]"},
+     "children": []},
+    {"attributes": {"accessibilityIdentifier": "IosThing", "bounds": "[0,100,100,150]"},
+     "children": []},
+    {"attributes": {"resource-id": "Described", "content-desc": "Save, button", "bounds": "[0,150,100,200]"},
+     "children": []},
+    {"attributes": {"resource-id": "Labelled", "text": "Total balance", "bounds": "[0,200,100,250]"},
+     "children": []}
+  ]
+}`
+
+// TestSelectorFormsResolveTheSameElement holds the two selector forms a spec can
+// write to ONE rule per key. A spec reaches these through state.ax.find: a
+// string goes to FindNode, an object to FindBySelector, and the two ran
+// different matchers. `id` has a kind arm that knows an Android resource id is
+// package-qualified (com.example.app:id/Thing) and that a spec names the bare
+// tail; the object form had no such arm and looked for a literal `id` attribute
+// no producer writes, so {id: "Thing"} silently matched nothing on every
+// platform while "id:Thing" matched. `desc` and `descPrefix` had the same
+// split. A selector that resolves nothing makes every property over it
+// vacuously true, which is the failure that reports a green run while checking
+// nothing.
+func TestSelectorFormsResolveTheSameElement(t *testing.T) {
+	tree, err := Parse(selectorFormsDump)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, test := range []struct {
+		key   string
+		value string
+		want  string
+	}{
+		{"id", "BareThing", "BareThing"},
+		// A spec names the tail; an Android dump carries the package prefix.
+		{"id", "AndroidThing", "com.example.app:id/AndroidThing"},
+		{"id", "com.example.app:id/AndroidThing", "com.example.app:id/AndroidThing"},
+		{"id", "IosThing", "IosThing"},
+		{"desc", "Save, button", "Described"},
+		// The ", " form an accessibility label takes when a role is appended.
+		{"desc", "Save", "Described"},
+		{"descPrefix", "Sav", "Described"},
+		{"text", "Total", "Labelled"},
+		{"resource-id", "BareThing", "BareThing"},
+		{"testTag", "IosThing", "IosThing"},
+	} {
+		t.Run(test.key+":"+test.value, func(t *testing.T) {
+			stringForm := test.key + ":" + test.value
+			fromString := tree.FindNode(stringForm)
+			if fromString == nil {
+				t.Fatalf("the string form %q resolved nothing", stringForm)
+			}
+			if fromString.ResourceID != test.want {
+				t.Fatalf("the string form resolved %q, want %q", fromString.ResourceID, test.want)
+			}
+			fromObject := tree.Root.FindBySelector(
+				Selector{Filters: []AttrFilter{{Attr: test.key, Value: test.value}}},
+			)
+			if fromObject == nil {
+				t.Fatalf(
+					"the object form {%s: %q} resolved nothing while %q resolved %q",
+					test.key, test.value, stringForm, fromString.ResourceID,
+				)
+			}
+			if fromObject != fromString {
+				t.Errorf(
+					"one selector, two answers: {%s: %q} resolved %q and %q resolved %q",
+					test.key, test.value, fromObject.ResourceID, stringForm, fromString.ResourceID,
+				)
+			}
+		})
+	}
+}