zeno-mobile-runner 0.1.2 → 0.1.8

package/clients/swift/Sources/ZMRClient/ZMRClient.swift

@@ -6,6 +6,28 @@ public enum ZMRError: Error {
     case rpcError([String: Any])
 }
 
+public struct TraceDiscoverOptions {
+    public var includeActions: Bool
+    public var validate: Bool
+    public var force: Bool
+    public var name: String?
+    public var appId: String?
+
+    public init(
+        includeActions: Bool = false,
+        validate: Bool = false,
+        force: Bool = false,
+        name: String? = nil,
+        appId: String? = nil
+    ) {
+        self.includeActions = includeActions
+        self.validate = validate
+        self.force = force
+        self.name = name
+        self.appId = appId
+    }
+}
+
 public final class ZMRClient {
     private let process: Process
     private let input: FileHandle
@@ -98,6 +120,66 @@ public final class ZMRClient {
         return result
     }
 
+    public func validateScenario(path: String) throws -> [String: Any] {
+        guard let result = try call("scenario.validate", params: ["path": path]) as? [String: Any] else {
+            throw ZMRError.invalidResponse
+        }
+        return result
+    }
+
+    public func discoverTrace(out: String, options: TraceDiscoverOptions = TraceDiscoverOptions()) throws -> [String: Any] {
+        var params: [String: Any] = ["out": out]
+        if options.includeActions {
+            params["includeActions"] = true
+        }
+        if options.validate {
+            params["validate"] = true
+        }
+        if options.force {
+            params["force"] = true
+        }
+        if let name = options.name {
+            params["name"] = name
+        }
+        if let appId = options.appId {
+            params["appId"] = appId
+        }
+        guard let result = try call("trace.discover", params: params) as? [String: Any] else {
+            throw ZMRError.invalidResponse
+        }
+        return result
+    }
+
+    public func exploreTrace(out: String, goal: String, options: TraceDiscoverOptions = TraceDiscoverOptions()) throws -> [String: Any] {
+        var params: [String: Any] = ["out": out, "goal": goal]
+        if options.includeActions {
+            params["includeActions"] = true
+        }
+        if options.validate {
+            params["validate"] = true
+        }
+        if options.force {
+            params["force"] = true
+        }
+        if let name = options.name {
+            params["name"] = name
+        }
+        if let appId = options.appId {
+            params["appId"] = appId
+        }
+        guard let result = try call("trace.explore", params: params) as? [String: Any] else {
+            throw ZMRError.invalidResponse
+        }
+        return result
+    }
+
+    public func explainTrace() throws -> [String: Any] {
+        guard let result = try call("trace.explain", params: [:]) as? [String: Any] else {
+            throw ZMRError.invalidResponse
+        }
+        return result
+    }
+
     private func readLineData() throws -> Data {
         var data = Data()
         while true {

package/clients/typescript/README.md

@@ -22,8 +22,24 @@ try {
   await zmr.waitUntil({ text: "E2E auth probe" }, { timeoutMs: 30000 });
   const snapshot = await zmr.snapshot();
   const events = await zmr.traceEvents(0, { limit: 100 });
+  const explanation = await zmr.explainTrace();
+  const discovered = await zmr.discoverTrace(".zmr/discovered/agent-session.json", {
+    includeActions: true,
+    validate: true,
+    force: true,
+  });
+  const explored = await zmr.exploreTrace(".zmr/discovered/agent-goal.json", "find a stable login smoke", {
+    includeActions: true,
+    validate: true,
+    force: true,
+  });
+  const validation = await zmr.validateScenario(discovered.out);
   console.log(snapshot.nodes);
   console.log(events.events.length);
+  console.log(explanation.status);
+  console.log(discovered.out);
+  console.log(explored.reviewRequired);
+  console.log(validation.ok);
   await zmr.exportTrace("traces/agent-session-redacted.zmrtrace", { redact: true, omitScreenshots: true });
 } finally {
   await zmr.close();

package/clients/typescript/index.d.ts

@@ -99,6 +99,14 @@ export interface Capabilities {
   methods: string[];
 }
 
+export interface TraceDiscoverOptions {
+  includeActions?: boolean;
+  validate?: boolean;
+  force?: boolean;
+  name?: string;
+  appId?: string;
+}
+
 export interface DeviceInfo {
   serial: string;
   state: string;
@@ -130,8 +138,12 @@ export interface ZmrClient {
   assertVisible(selector: Selector, options?: { timeoutMs?: number }): Promise<boolean>;
   assertNotVisible(selector: Selector, options?: { timeoutMs?: number }): Promise<boolean>;
   assertHealthy(options?: { timeoutMs?: number }): Promise<boolean>;
+  validateScenario(path: string): Promise<Record<string, unknown>>;
   exportTrace(out: string, options?: { redact?: boolean; omitScreenshots?: boolean }): Promise<Record<string, unknown>>;
   traceEvents(afterSeq?: number, options?: { limit?: number }): Promise<Record<string, unknown>>;
+  explainTrace(): Promise<Record<string, unknown>>;
+  discoverTrace(out: string, options?: TraceDiscoverOptions): Promise<Record<string, unknown>>;
+  exploreTrace(out: string, goal: string, options?: TraceDiscoverOptions): Promise<Record<string, unknown>>;
   close(): Promise<void>;
 }
 

package/clients/typescript/index.mjs

@@ -146,6 +146,10 @@ export class ZmrClient {
     return this.request("assert.healthy", options);
   }
 
+  validateScenario(path) {
+    return this.request("scenario.validate", { path });
+  }
+
   exportTrace(out, options = {}) {
     return this.request("trace.export", { out, ...options });
   }
@@ -154,6 +158,18 @@ export class ZmrClient {
     return this.request("trace.events", { afterSeq, ...options });
   }
 
+  explainTrace() {
+    return this.request("trace.explain", {});
+  }
+
+  discoverTrace(out, options = {}) {
+    return this.request("trace.discover", { out, ...options });
+  }
+
+  exploreTrace(out, goal, options = {}) {
+    return this.request("trace.explore", { out, goal, ...options });
+  }
+
   async close() {
     if (this.#closed) return;
     this.#closed = true;

package/clients/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zmr/client",
-  "version": "0.1.2",
+  "version": "0.1.8",
   "type": "module",
   "main": "index.mjs",
   "types": "index.d.ts",

package/docs/agent-discovery.md

@@ -0,0 +1,202 @@
+# Agent Discovery
+
+ZMR supports agent-led discovery today through its JSON-RPC and MCP interfaces,
+trace events, semantic snapshot artifacts, guarded trace exploration, in-band
+trace discovery, and offline scenario drafting. An external agent can observe
+the app, choose typed actions, inspect trace events, ask ZMR to write a small
+repeatable scenario from the trace, and then edit it as it learns a flow.
+
+`zmr explore` is the built-in review-first exploration command. It is
+trace-backed, not an unbounded crawler: it does not launch devices, invent
+missing actions, discover credentials, or commit files. Keep autonomous
+planning in the agent, and keep ZMR as the deterministic mobile control plane.
+
+## Recommended Loop
+
+1. Validate local setup:
+
+   ```bash
+   zmr inspect --json --dir .
+   zmr doctor --json --config .zmr/config.json
+   zmr validate --json .zmr/ios-smoke.json
+   ```
+
+2. Start a live session:
+
+   ```bash
+   zmr serve --transport stdio --config .zmr/config.json --trace-dir traces/zmr-agent
+   ```
+
+   Agents that speak MCP can use:
+
+   ```bash
+   zmr mcp --config .zmr/config.json --trace-dir traces/zmr-agent
+   ```
+
+3. Call `runner.capabilities`, then `session.create`.
+4. Call `observe.semanticSnapshot` before choosing an action.
+5. Choose one typed action, such as `ui.tap`, `ui.type`, `app.openLink`, or
+   `wait.until`.
+6. Observe again and inspect `trace.events`.
+7. If you used `zmr run --json --trace-dir`, read `nextCommands`; traced run
+   summaries include HTML/JUnit report output and the matching
+   `zmr discover --from-trace` command.
+8. If you want the CLI run itself to write the candidate, use:
+
+   ```bash
+   zmr run .zmr/login-smoke.json \
+     --trace-dir traces/zmr-agent \
+     --discover-out .zmr/discovered/replay-smoke.json \
+     --json
+   ```
+
+   The run response embeds `discovery`, the same JSON payload returned by
+   `zmr discover --json`, including `replay` coverage metadata for converted
+   and skipped trace actions.
+9. Generate a reviewable scenario candidate from the trace. For CLI-driven
+   agent loops, prefer `zmr explore` so the goal and guardrails travel with the
+   machine-readable result:
+
+   ```bash
+   zmr explore --from-trace traces/zmr-agent \
+     --out .zmr/discovered/login-smoke.json \
+     --goal "find a stable login smoke" \
+     --include-actions \
+     --validate \
+     --json
+   ```
+
+   The output is covered by `schemas/explore-output.schema.json` and includes
+   `autonomous:false`, `reviewRequired:true`, `guardrails`, replay coverage,
+   validation, and deterministic next commands.
+
+10. Use live trace exploration when the agent should keep the goal attached to
+    the generated draft. JSON-RPC agents can call `trace.explore`:
+
+   ```json
+   {"jsonrpc":"2.0","id":7,"method":"trace.explore","params":{"out":".zmr/discovered/login-smoke.json","goal":"find a stable login smoke","includeActions":true,"validate":true,"force":true}}
+   ```
+
+   MCP agents can call `trace_explore` with `out`, `goal`,
+   `includeActions`, `validate`, and `force`. The response includes
+   `autonomous:false`, `reviewRequired:true`, and `guardrails`.
+
+11. Use the lower-level trace discovery primitive when the agent already owns
+    goal tracking. JSON-RPC agents can
+    call `trace.discover`:
+
+   ```json
+   {"jsonrpc":"2.0","id":7,"method":"trace.discover","params":{"out":".zmr/discovered/replay-smoke.json","includeActions":true,"validate":true,"force":true}}
+   ```
+
+   MCP agents can call `trace_discover` with the same `out`,
+   `includeActions`, `validate`, and `force` arguments. The offline CLI
+   equivalent is:
+
+   ```bash
+   zmr discover --from-trace traces/zmr-agent \
+     --out .zmr/discovered/replay-smoke.json \
+     --include-actions \
+     --validate \
+     --json
+   ```
+
+   `zmr discover` writes a scenario from trace evidence and, with
+   `--validate`, immediately proves that the generated file is syntactically
+   runnable by ZMR. It is still review-first: it does not crawl, invent missing
+   actions, discover credentials, or commit the scenario.
+   Read the `replay` object before trusting coverage: `eventCount` is the
+   trace action event count considered for replay, `stepCount` is the number of
+   generated replay steps, and `skippedEventCount` is the number of events left
+   out.
+
+11. After editing a generated scenario, validate it in-band with JSON-RPC:
+
+   ```json
+   {"jsonrpc":"2.0","id":8,"method":"scenario.validate","params":{"path":".zmr/discovered/replay-smoke.json"}}
+   ```
+
+   MCP agents can call `scenario_validate` with the same `path` argument. The
+   result matches `zmr validate --json`, including field paths and source
+   locations for invalid files.
+
+12. Use the lower-level draft primitive when you want separate surface and
+   replay files. For a conservative surface-smoke scenario:
+
+   ```bash
+   zmr draft --from-trace traces/zmr-agent \
+     --out .zmr/discovered/surface-smoke.json \
+     --json
+   ```
+
+   The draft contains `launch`, `snapshot`, and `assertVisible` steps from
+   stable visible selectors. It does not tap, type, crawl, or commit anything.
+   If the trace contains successful typed actions and you want a replayable
+   starting point, include those supported events explicitly:
+
+   ```bash
+   zmr draft --from-trace traces/zmr-agent \
+     --out .zmr/discovered/replay-smoke.json \
+     --include-actions \
+     --json
+   ```
+
+   Replay drafts include only supported events with stable replay data, such as
+   launch, deep links, selector taps, selector text entry, back, keyboard hiding,
+   coordinate-complete swipes, selector/timeout-preserving waits, and
+   direction/timeout-preserving selector scrolls, selector/timeout-preserving
+   `assertVisible` and `assertNotVisible`, `assertNoneVisible` selector arrays,
+   and timed `assertHealthy` checks. Native selector wait traces also retain
+   timeout context for successful waits and timeout diagnostics.
+   Unsupported events stay out of the scenario and are reported as warnings.
+
+13. Edit the draft, discovery, or exploration output into a candidate flow, for example
+   `.zmr/discovered/login-smoke.json`, by copying only steps that were observed
+   and understood.
+14. Validate the candidate scenario:
+
+   ```bash
+   zmr validate --json .zmr/discovered/login-smoke.json
+   ```
+
+15. Re-run it deterministically:
+
+   ```bash
+   zmr run .zmr/discovered/login-smoke.json \
+     --platform ios \
+     --device booted \
+     --trace-dir traces/zmr-login-smoke \
+     --json
+   ```
+
+16. Export a redacted bundle before sharing artifacts:
+
+    ```bash
+    zmr export traces/zmr-login-smoke \
+      --out traces/zmr-login-smoke-redacted.zmrtrace \
+      --redact
+    ```
+
+## Guardrails
+
+- Set a step budget and a time budget before discovery starts.
+- Restrict discovery to known app ids, deep-link schemes, and test accounts.
+- Do not ask an agent to discover credentials or secrets.
+- Prefer accessibility identifiers, resource ids, stable labels, and exact text
+  over coordinates.
+- Require human review before committing generated tests.
+- Treat `zmr explore` output as a starting point, not as a production-ready
+  flow.
+- Treat `zmr discover` output as a starting point, not as a production-ready
+  flow.
+- Treat `zmr draft` output as a starting point, not as a production-ready flow.
+- Use `--include-actions` only after reviewing the trace events that produced
+  the replay draft.
+- Redact traces before sharing them outside the local team.
+
+## Current Shape
+
+`zmr explore` is the first shipped goal-carrying command in this loop. It still
+requires an existing trace because the current product direction is to keep
+scenario generation explicit, reviewable, and trace-backed before any future
+goal-driven crawler can safely act inside an app.

package/docs/ai-agents.md

@@ -1,13 +1,15 @@
 # AI Agent Guide
 
 ZMR is built for external agents. The runner provides device state, typed
-actions, waits, assertions, and trace export; the agent decides the next step.
+actions, waits, assertions, trace explanation, and trace export; the agent
+decides the next step.
 
 ## Agent Setup Loop
 
 Start inside the app checkout:
 
 ```bash
+zmr inspect --json --dir .
 zmr doctor --json --config .zmr/config.json
 zmr validate --json .zmr/android-smoke.json
 zmr validate --json .zmr/ios-smoke.json
@@ -18,6 +20,10 @@ Use `zmr doctor --strict --json` in CI or setup flows that should fail on any
 warning. Prefer JSON output for automation because it includes stable error
 codes, field paths, and remediation hints.
 
+Use `zmr inspect --json --dir .` first when an agent enters a repo. It is a
+read-only handoff with config status, generated agent instruction status,
+platform smoke scenario paths, safe next commands, and explicit claim limits.
+
 ## Live JSON-RPC Session
 
 Agents should prefer `zmr serve` for interactive work:
@@ -35,8 +41,15 @@ Recommended flow:
 4. Choose one typed action or assertion.
 5. Let ZMR settle, then observe again.
 6. Poll `trace.events` during long runs.
-7. Call `trace.export` with `redact: true` before sharing artifacts.
-8. Call `session.close`.
+7. Call `trace.explain` when you need the active trace status, failure
+   diagnostic, or next commands.
+8. Call `trace.explore` when you want a review-required scenario candidate for
+   a stated goal from the active trace.
+9. Call `trace.discover` when you want a lower-level reviewable scenario
+   candidate from the active trace and the agent already owns goal tracking.
+10. Call `scenario.validate` after editing generated scenario files.
+11. Call `trace.export` with `redact: true` before sharing artifacts.
+12. Call `session.close`.
 
 Do not parse screenshots or terminal text when the same fact is available from
 snapshot nodes, action results, CLI JSON, or trace events.
@@ -47,6 +60,14 @@ For iOS visual captures, `artifactStatus: "captured"` with
 XCTest hierarchy extraction failed. Use `zmr explain --json <trace-dir>` for
 the same diagnostic shape after the run.
 
+For traced CLI runs, `zmr run --json` also returns `nextCommands` with the
+HTML/JUnit report, explain, `zmr discover --from-trace`, and redacted export
+handoffs.
+Agents should prefer those commands over reconstructing trace paths from text.
+When an agent should create the reviewable scenario in the same process, pass
+`--discover-out .zmr/discovered/<name>.json`; the run JSON will include a
+`discovery` object with validation results and `replay` coverage metadata.
+
 ## MCP Session
 
 Agents that support the Model Context Protocol can use ZMR directly as a local
@@ -61,13 +82,73 @@ The MCP server exposes mobile-specific tools:
 - `snapshot`: raw ZMR observation JSON
 - `semantic_snapshot`: normalized roles, names, selectors, bounds, and
   recommended actions
-- `tap`, `type`, `press_back`, and `open_link`
-- `wait_visible`
-- `trace_events` and `trace_export`
+- `install_app`, `launch_app`, `stop_app`, and `clear_state`
+- `tap`, `type`, `erase_text`, `hide_keyboard`, `swipe`, `press_back`,
+  `open_link`, and `scroll_until_visible`
+- `wait_visible`, `wait_not_visible`, and `wait_any`
+- `assert_visible`, `assert_not_visible`, and `assert_healthy`
+- `scenario_validate`
+- `trace_events`, `trace_explain`, `trace_explore`, `trace_discover`, and
+  `trace_export`
 
 Prefer `semantic_snapshot` for action planning. It avoids forcing an agent to
 infer intent from platform-specific Android/UI Automator or XCTest class names.
 
+## Agent-Led Discovery
+
+Agents can use ZMR to discover flows and draft scenarios by looping over
+`observe.semanticSnapshot`, one typed action, trace events, and scenario
+validation. After a session has produced trace artifacts, call JSON-RPC
+`trace.explain` or MCP `trace_explain` for in-band triage, then call JSON-RPC
+`trace.explore` or MCP `trace_explore` when the generated draft should carry a
+stated goal and guardrails. Use JSON-RPC `trace.discover` or MCP
+`trace_discover` for the lower-level trace-backed draft when the agent already
+owns goal tracking. Use JSON-RPC `scenario.validate` or MCP
+`scenario_validate` after edits. The CLI command is the offline equivalent:
+
+```bash
+zmr discover --from-trace traces/zmr-agent \
+  --out .zmr/discovered/replay-smoke.json \
+  --include-actions \
+  --validate \
+  --json
+```
+
+`zmr discover` is review-first. It writes from trace evidence, validates the
+generated scenario when asked, and returns next commands for deterministic
+reruns. It does not crawl, discover credentials, or commit tests. The JSON
+`replay` object lets agents compare trace action events considered for replay,
+generated replay steps, and skipped events before making coverage claims.
+
+Use `zmr draft` when you want the lower-level split workflow. It writes
+`launch`, `snapshot`, and conservative `assertVisible` checks by default. For
+traces produced by an agent session with successful typed actions, add
+`--include-actions` to generate a replay draft from supported events before the
+final snapshot assertions:
+
+```bash
+zmr draft --from-trace traces/zmr-agent \
+  --out .zmr/discovered/replay-smoke.json \
+  --include-actions \
+  --json
+zmr validate --json .zmr/discovered/replay-smoke.json
+```
+
+Unsupported or underspecified events are skipped with warnings instead of being
+guessed. Supported replay steps preserve selector and timeout data for waits,
+selector and timeout data for `assertVisible` and `assertNotVisible`, selector
+arrays for `assertNoneVisible`, and timeouts for `assertHealthy` when the trace
+records them. See [Agent Discovery](agent-discovery.md) for the
+recommended reviewable loop.
+
+CLI agents can use `zmr explore --from-trace <trace-dir> --out <scenario.json>
+--goal <goal> --include-actions --validate --json` when the goal should travel
+with the generated scenario candidate. The result includes `autonomous:false`,
+`reviewRequired:true`, `guardrails`, replay coverage, validation, and next
+commands. ZMR still does not ship an unbounded autonomous crawler or test
+writer in this developer preview. Keep autonomous planning outside the runner,
+then commit only reviewed scenario JSON.
+
 ## Scenario File Workflow
 
 For repeatable tests, generate or edit `.zmr/*.json` scenarios:

package/docs/benchmarking.md

@@ -1,6 +1,8 @@
 # Benchmarking
 
-ZMR benchmark output is intentionally simple: each run appends one JSON object to `results.jsonl`, and `zmr report` turns that directory into a local HTML report.
+ZMR benchmark output is intentionally simple: each run appends one JSON object
+to `results.jsonl`, and `zmr report` turns that directory into local HTML and
+optional JUnit XML artifacts.
 
 ## Single Tool Benchmark
 
@@ -29,7 +31,9 @@ or p95 duration misses the configured threshold.
 Generate a report:
 
 ```bash
-zmr report traces/bench-<timestamp> --out traces/bench-<timestamp>/report.html
+zmr report traces/bench-<timestamp> \
+  --out traces/bench-<timestamp>/report.html \
+  --junit traces/bench-<timestamp>/junit.xml
 ```
 
 ## Pilot Wrapper
@@ -62,7 +66,9 @@ Use `--screen-record` when investigating visual flakes:
   --max-failures 0
 ```
 
-For `--runs 1`, the script exports normal and redacted `.zmrtrace` bundles. For `--runs > 1`, it writes benchmark directories and HTML reports.
+For `--runs 1`, the script exports normal and redacted `.zmrtrace` bundles.
+For `--runs > 1`, the pilot wrappers and generated app reliability scripts
+write benchmark directories with HTML and JUnit reports.
 
 The iOS pilot wrapper supports the same repeated-run gates:
 
@@ -128,6 +134,7 @@ Benchmark reports include:
 - terminal trace status
 - failed step index and error when available
 - links to each run's `events.jsonl`
+- optional JUnit XML with one testcase per benchmark row for CI test reports
 
 Before making public performance claims, run the same scenario repeatedly on a clean emulator image and include the raw `results.jsonl` plus the redacted trace bundle for any failure.
 

package/docs/clients.md

@@ -21,7 +21,11 @@ Then it sends JSON-RPC methods such as:
 - `wait.until`
 - `assert.visible`
 - `assert.healthy`
+- `scenario.validate`
 - `trace.events`
+- `trace.explain`
+- `trace.explore`
+- `trace.discover`
 - `trace.export`
 
 Use clients when an AI agent, service, or test harness wants to drive ZMR
@@ -37,12 +41,12 @@ even when normal page text is also present.
 
 | Language | Files | Why it looks this way |
 | --- | --- | --- |
-| TypeScript | `clients/typescript/index.mjs`, `index.d.ts` | ESM runtime plus type declarations, no build step required |
-| Python | `clients/python/zmr_client.py`, `pyproject.toml` | Standard-library importable module that can be vendored or pip-installed from source |
-| Go | `clients/go/zmr/client.go` | Normal Go package inside a module |
-| Rust | `clients/rust/src/lib.rs` | Cargo library crate convention |
-| Swift | `clients/swift/Sources/ZMRClient/ZMRClient.swift` | SwiftPM package for macOS host-side tools |
-| Kotlin | `clients/kotlin/src/main/kotlin/dev/zmr/ZmrClient.kt` | Gradle/Kotlin source package for JVM host-side tools |
+| TypeScript | `clients/typescript/index.mjs`, `index.d.ts` | ESM runtime plus type declarations, including `explainTrace`, `exploreTrace`, `discoverTrace`, and `validateScenario` helpers |
+| Python | `clients/python/zmr_client.py`, `pyproject.toml` | Standard-library importable module with `explain_trace`, `explore_trace`, `discover_trace`, and `validate_scenario` helpers |
+| Go | `clients/go/zmr/client.go` | Normal Go package inside a module, including `ExplainTrace`, `ExploreTrace`, `DiscoverTrace`, and `ValidateScenario` helpers |
+| Rust | `clients/rust/src/lib.rs` | Cargo library crate convention, including `explain_trace`, `explore_trace`, `discover_trace`, and `validate_scenario` helpers |
+| Swift | `clients/swift/Sources/ZMRClient/ZMRClient.swift` | SwiftPM package for macOS host-side tools, including `explainTrace`, `exploreTrace`, `discoverTrace`, and `validateScenario` helpers |
+| Kotlin | `clients/kotlin/src/main/kotlin/dev/zmr/ZmrClient.kt` | Gradle/Kotlin source package for JVM host-side tools, including `explainTrace`, `exploreTrace`, `discoverTrace`, and `validateScenario` helpers |
 
 Rust has `src/lib.rs` because Cargo expects a library crate there. The other
 clients do have equivalent entry points; they are just idiomatic for their

package/docs/demo.md

@@ -124,7 +124,9 @@ The script builds `zmr` when needed, validates both sample scenarios, installs t
 For each single run it writes:
 
 - `auth/report.html`
+- `auth/junit.xml`
 - `login-smoke/report.html`
+- `login-smoke/junit.xml`
 - `auth.zmrtrace`
 - `auth-redacted.zmrtrace`
 - `login-smoke.zmrtrace`
@@ -233,9 +235,11 @@ Build the app for an iOS simulator, boot a simulator, then run:
 For each run it writes:
 
 - `ios-smoke/report.html`
+- `ios-smoke/junit.xml`
 - `ios-smoke.zmrtrace`
 - `ios-smoke-redacted.zmrtrace`
 - `ios-shim-smoke/report.html` when `--ios-shim` is set
+- `ios-shim-smoke/junit.xml` when `--ios-shim` is set
 - `ios-shim-smoke.zmrtrace` when `--ios-shim` is set
 - `ios-shim-smoke-redacted.zmrtrace` when `--ios-shim` is set