@@ -198,3 +198,16 @@ test('the canvas takes the device dimensions from the tree, with no video', asyn
   expect(size.w).toBe(Math.round(app.width));
   expect(size.h).toBe(Math.round(app.height));
 });
+
+test('a backgrounded app is announced in the root name, not hidden', async ({ page }) => {
+  const tree = await serveMirror(page, 'products');
+  // The same screen, now reported backgrounded. iOS keeps a backgrounded
+  // app's whole tree, so every control is still here — the mirror must
+  // annotate, not hide, so an agent knows the screen is not on the device.
+  await page.route('**/api/devices/*/tree*', (r) =>
+    r.fulfill({ json: { ...tree, foreground: false, appState: 'runningBackground' } }));
+  await expect(page.locator('#mirror')).toHaveAttribute('aria-label', /app not in foreground/, { timeout: 5_000 });
+  await expect(page.locator('#mirror')).toHaveAttribute('data-dd-foreground', 'false');
+  // Annotated, never hidden: the controls are all still present and clickable.
+  await expect(page.locator('#mirror [data-dd-node]').first()).toBeVisible();
+});
@@ -4,7 +4,7 @@ go 1.26
 
 require (
 	github.com/coder/websocket v1.8.15
-	github.com/devicelab-dev/maestro-runner v1.1.25-0.20260818192022-2ad25f651253
+	github.com/devicelab-dev/maestro-runner v1.1.25-0.20260821233021-5d782aa65f33
 	google.golang.org/grpc v1.83.0
 	google.golang.org/protobuf v1.36.12
 	gopkg.in/yaml.v3 v3.0.1
 
@@ -3,8 +3,8 @@ github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XL
 github.com/coder/websocket v1.8.15 h1:6B2JPeOGlpff2Uz6vOEH1Vzpi0iUz20A+lPVhPHtNUA=
 github.com/coder/websocket v1.8.15/go.mod h1:NX3SzP+inril6yawo5CQXx8+fk145lPDC6pumgx0mVg=
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
-github.com/devicelab-dev/maestro-runner v1.1.25-0.20260818192022-2ad25f651253 h1:X8NtuvyUj/HNTGn6bAeFEaXaMaRTwI3aAe4/uDwgY5Q=
-github.com/devicelab-dev/maestro-runner v1.1.25-0.20260818192022-2ad25f651253/go.mod h1:DMSQv0AMy2xs1COCdt/eIbUUmGzyLX35KmgKx/uJ0Xs=
+github.com/devicelab-dev/maestro-runner v1.1.25-0.20260821233021-5d782aa65f33 h1:sbVSlYcCp+LXd1OpeF93DjCA5VU58re1/0Q1wh2tnGY=
+github.com/devicelab-dev/maestro-runner v1.1.25-0.20260821233021-5d782aa65f33/go.mod h1:DMSQv0AMy2xs1COCdt/eIbUUmGzyLX35KmgKx/uJ0Xs=
 github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
 github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
 github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
 
@@ -155,6 +155,16 @@ func (e *AndroidEngine) Snapshot(_ context.Context, _ string) ([]Node, error) {
 	return convertAndroidElements(elems, w, h), nil
 }
 
+// SnapshotState satisfies engineAPI. Like the rest of AndroidEngine it runs
+// only against a real emulator (coverage waiver, as AndroidEngine.Snapshot).
+// Android's AccessibilityService page source carries no app-lifecycle state,
+// so AppState is empty and a caller treats "unknown" and empty alike — the
+// foreground annotation is simply absent, never a false claim.
+func (e *AndroidEngine) SnapshotState(ctx context.Context, appBundleID string) (Snapshot, error) {
+	nodes, err := e.Snapshot(ctx, appBundleID)
+	return Snapshot{Nodes: nodes}, err
+}
+
 // Stop tears the session down, gracefully first.
 func (e *AndroidEngine) Stop(context.Context) error {
 	e.mu.Lock()
 
@@ -6,10 +6,22 @@ import (
 	"time"
 )
 
+// Snapshot is a UI tree together with the app-lifecycle state that came
+// with it — the target's XCUIApplication.state on iOS, empty where the
+// platform does not report one. The state travels with the tree because
+// it is the same dump: no signal in the nodes reports foreground/
+// background reliably (per-node hittable oscillates while a screen
+// animates into the background), so a caller reads AppState, not the
+// tree, to know the app is frontmost.
+type Snapshot struct {
+	Nodes    []Node
+	AppState string
+}
+
 // Snapshotter is the one tree operation settling needs. Narrow on purpose:
 // it lets the settle logic be exercised against a scripted sequence of
 // trees, with no engine and no device.
-type Snapshotter func(ctx context.Context) ([]Node, error)
+type Snapshotter func(ctx context.Context) (Snapshot, error)
 
 // SettleOptions bounds a settle wait. Zero values take the defaults below.
 type SettleOptions struct {
@@ -64,19 +76,19 @@ func (o SettleOptions) withDefaults() SettleOptions {
 //
 // An empty `after` asks only for quiet, which is what a caller wants on
 // first contact, before it has any hash to compare against.
-func Settle(ctx context.Context, snap Snapshotter, after string, opts SettleOptions) ([]Node, error) {
+func Settle(ctx context.Context, snap Snapshotter, after string, opts SettleOptions) (Snapshot, error) {
 	opts = opts.withDefaults()
 	deadline := time.Now().Add(opts.Cap)
-	var last []Node
+	var last Snapshot
 	lastScreen, quiet := "", 0
 	for {
-		nodes, err := snap(ctx)
+		got, err := snap(ctx)
 		if err != nil {
-			return nil, err
+			return Snapshot{}, err
 		}
-		last = nodes
-		quiet, lastScreen = countQuiet(nodes, lastScreen, quiet)
-		changed := after == "" || InteractionHash(nodes) != after
+		last = got
+		quiet, lastScreen = countQuiet(got.Nodes, lastScreen, quiet)
+		changed := after == "" || InteractionHash(got.Nodes) != after
 		if changed && quiet >= opts.Quiet {
 			return last, nil
 		}
@@ -198,8 +210,8 @@ func awaitAppeared(ctx context.Context, snap Snapshotter, opts LaunchOptions) er
 	deadline := time.Now().Add(opts.Appear)
 	var lastErr error
 	for {
-		nodes, err := snap(ctx)
-		if err == nil && hasControl(nodes) {
+		got, err := snap(ctx)
+		if err == nil && hasControl(got.Nodes) {
 			return nil
 		}
 		lastErr = err
 
@@ -26,13 +26,13 @@ func focused(label string) []Node {
 // took.
 func scripted(trees ...[]Node) (Snapshotter, *int) {
 	calls := 0
-	return func(ctx context.Context) ([]Node, error) {
+	return func(ctx context.Context) (Snapshot, error) {
 		i := calls
 		calls++
 		if i >= len(trees) {
 			i = len(trees) - 1
 		}
-		return trees[i], nil
+		return Snapshot{Nodes: trees[i]}, nil
 	}, &calls
 }
 
@@ -91,8 +91,8 @@ func TestSettle(t *testing.T) {
 			if err != nil {
 				t.Fatalf("unexpected error: %v", err)
 			}
-			if got[0].Label != tc.wantLabel {
-				t.Errorf("settled on %q, want %q", got[0].Label, tc.wantLabel)
+			if got.Nodes[0].Label != tc.wantLabel {
+				t.Errorf("settled on %q, want %q", got.Nodes[0].Label, tc.wantLabel)
 			}
 			if *calls < tc.minCalls {
 				t.Errorf("took %d samples, want at least %d", *calls, tc.minCalls)
@@ -103,7 +103,7 @@ func TestSettle(t *testing.T) {
 
 func TestSettleSnapshotErrorIsReturned(t *testing.T) {
 	boom := errors.New("engine down")
-	snap := func(ctx context.Context) ([]Node, error) { return nil, boom }
+	snap := func(ctx context.Context) (Snapshot, error) { return Snapshot{}, boom }
 	if _, err := Settle(context.Background(), snap, "", fast); !errors.Is(err, boom) {
 		t.Fatalf("got %v, want %v", err, boom)
 	}
@@ -115,7 +115,7 @@ func TestSettleStopsOnCancel(t *testing.T) {
 	cancel()
 	// Cancelled before the first sleep: one sample, then out.
 	got, err := Settle(ctx, snap, InteractionHash(screen("zzz")), SettleOptions{Interval: time.Hour, Cap: 2 * time.Hour})
-	if err != nil || got == nil {
+	if err != nil || got.Nodes == nil {
 		t.Fatalf("cancel should still hand back the last tree, got %v, %v", got, err)
 	}
 	if *calls != 1 {
@@ -168,7 +168,7 @@ func TestAwaitLaunched(t *testing.T) {
 	})
 	t.Run("a snapshot error explains the timeout", func(t *testing.T) {
 		boom := errors.New("engine down")
-		snap := func(ctx context.Context) ([]Node, error) { return nil, boom }
+		snap := func(ctx context.Context) (Snapshot, error) { return Snapshot{}, boom }
 		if err := AwaitLaunched(context.Background(), snap, fastLaunch); !errors.Is(err, boom) {
 			t.Fatalf("got %v, want %v", err, boom)
 		}
 
@@ -51,21 +51,30 @@ func NewTreeClient(host string, port int) *TreeClient {
 // Snapshot returns the full UI tree for appBundleID (empty = foreground app,
 // runner-side default).
 func (t *TreeClient) Snapshot(ctx context.Context, appBundleID string) ([]Node, error) {
+	snap, err := t.SnapshotState(ctx, appBundleID)
+	return snap.Nodes, err
+}
+
+// SnapshotState is Snapshot plus the app's lifecycle state, read from the
+// same dump. A snapshot is not an interaction command, so the runner does
+// not activate the app first: AppState is its true frontmost/background
+// state, which the node tree cannot report reliably.
+func (t *TreeClient) SnapshotState(ctx context.Context, appBundleID string) (Snapshot, error) {
 	data, err := t.client.Call(ctx, dlios.Command{
 		Command:     dlios.CmdSnapshot,
 		AppBundleID: appBundleID,
 	})
 	if err != nil {
-		return nil, fmt.Errorf("runner snapshot: %w", err)
+		return Snapshot{}, fmt.Errorf("runner snapshot: %w", err)
 	}
 	if data == nil {
-		return nil, fmt.Errorf("runner snapshot: empty response")
+		return Snapshot{}, fmt.Errorf("runner snapshot: empty response")
 	}
 	// Culled here rather than in the browser: the console, the device
 	// page and Flow Capture all read this tree, and a flow recorded
 	// against a screen nobody can see is the failure that survives to
 	// real hardware.
-	return OnScreen(convertNodes(data.Nodes)), nil
+	return Snapshot{Nodes: OnScreen(convertNodes(data.Nodes)), AppState: data.AppState}, nil
 }
 
 func convertNodes(in []dlios.SnapshotNode) []Node {
@@ -102,9 +111,10 @@ type Engine struct {
 
 // StartEngine builds (first run only) and launches the runner on udid.
 //
-// Coverage waiver: StartEngine, Engine.Snapshot, and Engine.Stop wrap the
-// xcodebuild-driven runner lifecycle and only execute against a real booted
-// simulator; they are exercised by end-to-end runs, not unit tests.
+// Coverage waiver: StartEngine, Engine.Snapshot, Engine.SnapshotState, and
+// Engine.Stop wrap the xcodebuild-driven runner lifecycle and only execute
+// against a real booted simulator; they are exercised by end-to-end runs,
+// not unit tests.
 func StartEngine(ctx context.Context, udid string) (*Engine, error) {
 	// Embedded, not installed: the runner source ships inside the pinned
 	// maestro-runner module, so the runner DeviceDeck builds always
@@ -129,6 +139,11 @@ func (e *Engine) Snapshot(ctx context.Context, appBundleID string) ([]Node, erro
 	return e.tree.Snapshot(ctx, appBundleID)
 }
 
+// SnapshotState fetches the UI tree and the app's lifecycle state.
+func (e *Engine) SnapshotState(ctx context.Context, appBundleID string) (Snapshot, error) {
+	return e.tree.SnapshotState(ctx, appBundleID)
+}
+
 // Stop shuts the runner down, gracefully first.
 func (e *Engine) Stop(ctx context.Context) error {
 	return dlios.GracefulShutdown(ctx, e.client, e.handle)
@@ -138,6 +153,7 @@ func (e *Engine) Stop(ctx context.Context) error {
 // by test fakes so cache behavior is testable without xcodebuild.
 type engineAPI interface {
 	Snapshot(ctx context.Context, appBundleID string) ([]Node, error)
+	SnapshotState(ctx context.Context, appBundleID string) (Snapshot, error)
 	Stop(ctx context.Context) error
 }
 
@@ -172,21 +188,28 @@ func NewEngines() *Engines {
 // alive; restarting a live engine over an app-level error (APP_NOT_RUNNING,
 // a caught in-runner exception) just burns the startup cost for nothing.
 func (s *Engines) Snapshot(ctx context.Context, udid, appBundleID string) ([]Node, error) {
+	snap, err := s.SnapshotState(ctx, udid, appBundleID)
+	return snap.Nodes, err
+}
+
+// SnapshotState is Snapshot carrying the app's lifecycle state, with the
+// same evict-and-retry behavior.
+func (s *Engines) SnapshotState(ctx context.Context, udid, appBundleID string) (Snapshot, error) {
 	e, err := s.engine(ctx, udid)
 	if err != nil {
-		return nil, err
+		return Snapshot{}, err
 	}
-	nodes, err := e.Snapshot(ctx, appBundleID)
+	snap, err := e.SnapshotState(ctx, appBundleID)
 	var runnerErr *dlios.RunnerError
 	if err == nil || ctx.Err() != nil || errors.As(err, &runnerErr) {
-		return nodes, err
+		return snap, err
 	}
 	slog.Warn("tree snapshot failed, restarting engine", "udid", udid, "error", err)
 	s.evict(ctx, udid, e)
 	if e, err = s.engine(ctx, udid); err != nil {
-		return nil, fmt.Errorf("restart tree engine: %w", err)
+		return Snapshot{}, fmt.Errorf("restart tree engine: %w", err)
 	}
-	return e.Snapshot(ctx, appBundleID)
+	return e.SnapshotState(ctx, appBundleID)
 }
 
 // evict drops failed from the cache and stops it — unless a concurrent
 
@@ -107,7 +107,10 @@ type fakeEngine struct {
 }
 
 func (f *fakeEngine) Snapshot(context.Context, string) ([]Node, error) { return f.nodes, f.err }
-func (f *fakeEngine) Stop(context.Context) error                       { f.stopped = true; return nil }
+func (f *fakeEngine) SnapshotState(context.Context, string) (Snapshot, error) {
+	return Snapshot{Nodes: f.nodes}, f.err
+}
+func (f *fakeEngine) Stop(context.Context) error { f.stopped = true; return nil }
 
 func TestEnginesCachesPerUDID(t *testing.T) {
 	started := map[string]int{}
 
@@ -53,6 +53,7 @@ type FrameSender interface {
 // TreeSource fetches the UI tree for a device.
 type TreeSource interface {
 	Snapshot(ctx context.Context, udid, appBundleID string) ([]runner.Node, error)
+	SnapshotState(ctx context.Context, udid, appBundleID string) (runner.Snapshot, error)
 }
 
 // CaptureService records manual sessions as flows.
@@ -210,8 +211,8 @@ func (s *Server) handleLaunchApp(w http.ResponseWriter, r *http.Request) {
 // snapshotter binds the tree source to one device and app, which is the
 // shape the settle logic wants.
 func (s *Server) snapshotter(udid, app string) runner.Snapshotter {
-	return func(ctx context.Context) ([]runner.Node, error) {
-		return s.trees.Snapshot(ctx, udid, app)
+	return func(ctx context.Context) (runner.Snapshot, error) {
+		return s.trees.SnapshotState(ctx, udid, app)
 	}
 }
 
@@ -228,7 +229,7 @@ func (s *Server) handleScreenshot(w http.ResponseWriter, r *http.Request) {
 func (s *Server) handleTree(w http.ResponseWriter, r *http.Request) {
 	udid := r.PathValue("udid")
 	snap := s.snapshotter(udid, r.URL.Query().Get("app"))
-	var nodes []runner.Node
+	var got runner.Snapshot
 	var err error
 	// ?after=<interaction hash> turns the poll into a barrier: the
 	// response is held until the screen has moved on from that hash and
@@ -237,9 +238,9 @@ func (s *Server) handleTree(w http.ResponseWriter, r *http.Request) {
 	// that waits on the page's own requests — playwright-mcp does —
 	// waits for the device without knowing it.
 	if after, held := r.URL.Query()["after"]; held {
-		nodes, err = runner.Settle(r.Context(), snap, after[0], s.settle)
+		got, err = runner.Settle(r.Context(), snap, after[0], s.settle)
 	} else {
-		nodes, err = snap(r.Context())
+		got, err = snap(r.Context())
 	}
 	if err != nil {
 		// Logged, not just returned: a failed snapshot reaches the page
@@ -251,7 +252,7 @@ func (s *Server) handleTree(w http.ResponseWriter, r *http.Request) {
 		httpError(w, http.StatusBadGateway, err)
 		return
 	}
-	writeJSON(w, treePayload(nodes))
+	writeJSON(w, treePayload(got))
 }
 
 // treePayload is the tree as every consumer receives it. The hashes
@@ -260,26 +261,33 @@ func (s *Server) handleTree(w http.ResponseWriter, r *http.Request) {
 // "hash" is the screen, for settledness and the fingerprint;
 // "interaction" adds focus, and is what a client hands back as ?after=
 // so that moving between fields counts as a change.
-func treePayload(nodes []runner.Node) map[string]any {
+func treePayload(snap runner.Snapshot) map[string]any {
+	nodes := snap.Nodes
 	if nodes == nil {
 		nodes = []runner.Node{}
 	}
 	return map[string]any{
 		"nodes":       nodes,
 		"hash":        runner.ScreenHash(nodes),
 		"interaction": runner.InteractionHash(nodes),
+		// foreground is false only when the app reports a background or
+		// not-running state. An empty state — Android, or a runner that
+		// did not send one — is treated as foreground: absence of the
+		// signal must not read as "backgrounded" and block nothing.
+		"foreground": snap.AppState == "" || snap.AppState == "runningForeground",
+		"appState":   snap.AppState,
 	}
 }
 
 // FirstTree is the settled tree for a device page, ready to inline. It
 // waits for quiet alone — there is no earlier screen to have moved on
 // from — under the same cap as any other held tree.
 func (s *Server) FirstTree(ctx context.Context, udid, app string) ([]byte, error) {
-	nodes, err := runner.Settle(ctx, s.snapshotter(udid, app), "", s.settle)
+	got, err := runner.Settle(ctx, s.snapshotter(udid, app), "", s.settle)
 	if err != nil {
 		return nil, err
 	}
-	return json.Marshal(treePayload(nodes))
+	return json.Marshal(treePayload(got))
 }
 
 type tapRequest struct {