zeno-mobile-runner 0.1.3 → 0.2.0

package/scripts/demo.sh

@@ -37,9 +37,12 @@ echo "== Validate demo scenarios =="
 ./zig-out/bin/zmr validate examples/android-app-referral-deep-link.json
 ./zig-out/bin/zmr validate examples/android-app-error-state.json
 ./zig-out/bin/zmr validate examples/android-shim-smoke.json
+./zig-out/bin/zmr validate examples/android-workflow.json
+./zig-out/bin/zmr validate examples/react-native-expo-workflow.json
 ./zig-out/bin/zmr validate examples/ios-smoke.json
 ./zig-out/bin/zmr validate examples/ios-dev-client-open-link.json
 ./zig-out/bin/zmr validate examples/ios-shim-smoke.json
+./zig-out/bin/zmr validate examples/ios-shim-workflow.json
 
 echo
 echo "== Validate diagnostics: field and line location =="

package/scripts/install-ios-shim.sh

@@ -342,14 +342,14 @@ is_server_running() {
     return 1
   fi
   command="\$(ps -p "\$pid" -o command= 2>/dev/null || true)"
-  [[ "\$command" == *xcodebuild* && "\$command" == *ZMRShimUITests* ]]
+  [[ "\$command" == *xcodebuild* && "\$command" == *"$TEST_TARGET"* ]]
 }
 
 run_oneshot() {
   local request_file response_file oneshot_log destination_id
   request_file="\$(mktemp "\$STATE_DIR/request.XXXXXX")"
   response_file="\$(mktemp "\$STATE_DIR/response.XXXXXX")"
-  oneshot_log="\$(mktemp "\$STATE_DIR/xcodebuild.oneshot.XXXXXX.log")"
+  oneshot_log="\$(mktemp "\$STATE_DIR/xcodebuild.oneshot.log.XXXXXX")"
   cp "\$STDIN_FILE" "\$request_file"
   destination_id="\$(destination_spec)"
 

package/scripts/release-readiness.py

@@ -423,6 +423,38 @@ def benchmark_threshold_reason(row):
     return "requires " + ", ".join(reasons)
 
 
+agent_workflow_fields = (
+    "agentWorkflow",
+    "mcp",
+    "jsonRpc",
+    "semanticSnapshot",
+    "typedActions",
+    "traceEvents",
+    "traceExplain",
+    "traceExplore",
+    "traceDiscover",
+    "scenarioValidation",
+    "redactedExport",
+)
+
+
+def agent_workflow_pass(row):
+    command = row.get("command")
+    if row.get("name") == "local release gate" and isinstance(command, str) and "release-gate.sh" in command:
+        return True
+    return all(row.get(field) is True for field in agent_workflow_fields)
+
+
+def agent_workflow_reason(row):
+    command = row.get("command")
+    if row.get("name") == "local release gate" and (not isinstance(command, str) or "release-gate.sh" not in command):
+        return "requires release-gate.sh or structured agentWorkflow evidence"
+    missing = [field for field in agent_workflow_fields if row.get(field) is not True]
+    if missing:
+        return "requires release-gate.sh or structured agentWorkflow evidence: " + ", ".join(missing)
+    return "requires release-gate.sh or structured agentWorkflow evidence"
+
+
 def row_satisfies(label, row):
     if row.get("status") != "passed":
         return False
@@ -436,6 +468,8 @@ def row_satisfies(label, row):
         return physical_ios_device_value(row) is not None
     if label == "competitive benchmark comparison":
         return benchmark_thresholds_pass(row)
+    if label == "agent workflow smoke":
+        return agent_workflow_pass(row)
     return True
 
 
@@ -485,6 +519,8 @@ def requirement_status(label, names):
                 reason = "requires concrete physical device identifier evidence"
             elif label == "competitive benchmark comparison":
                 reason = benchmark_threshold_reason(row)
+            elif label == "agent workflow smoke":
+                reason = agent_workflow_reason(row)
             return {
                 "name": label,
                 "status": "insufficient",
@@ -508,6 +544,7 @@ requirements = [
 
 if target in ("production", "market-claim"):
     requirements.extend([
+        ("agent workflow smoke", ("agent workflow smoke", "local release gate")),
         ("physical iOS readiness", "physical iOS readiness"),
         ("Android hardware pilot", "Android hardware pilot"),
         ("iOS simulator hardware pilot", "iOS simulator hardware pilot"),
@@ -582,6 +619,7 @@ next_step_commands = {
     "local release gate": ["./scripts/release-candidate.sh --mode local"],
     "public Android demo": ["zmr-demo-android --runs 5"],
     "public iOS simulator demo": ["zmr-demo-ios --runs 5"],
+    "agent workflow smoke": ["./scripts/release-gate.sh"],
     "physical iOS readiness": [physical_ios_pilot_command(default_pilot_evidence)],
     "Android hardware pilot": [grouped_simulator_pilot_command(default_pilot_evidence)],
     "iOS simulator hardware pilot": [grouped_simulator_pilot_command(default_pilot_evidence)],
@@ -690,6 +728,11 @@ def append_grouped_next_steps(blocked_items):
             append_next_step(next_steps, label, commands, present)
             handled.update(present)
 
+    maybe_group(
+        ["local release gate", "agent workflow smoke"],
+        "local release gate + agent workflow smoke",
+        ["./scripts/release-candidate.sh --mode local"],
+    )
     maybe_group(
         ["Android hardware pilot", "iOS simulator hardware pilot"],
         "Android hardware pilot + iOS simulator hardware pilot",

package/scripts/run-android-pilot.sh

@@ -171,6 +171,11 @@ run() {
   fi
 }
 
+run_zmr_report() {
+  local trace_dir="$1"
+  run "$ZMR_BIN" report "$trace_dir" --out "$trace_dir/report.html" --junit "$trace_dir/junit.xml"
+}
+
 capture() {
   if [[ "$DRY_RUN" -eq 1 ]]; then
     echo ""
@@ -505,7 +510,7 @@ if [[ "$RUNS" -eq 1 ]]; then
     SINGLE_TRACE="$TRACE_ROOT/scenario"
     run rm -rf "$SINGLE_TRACE"
     run_zmr_android_scenario "$SCENARIO" --device "$DEVICE" --app-id "$APP_ID" --trace-dir "$SINGLE_TRACE"
-    run "$ZMR_BIN" report "$SINGLE_TRACE" --out "$SINGLE_TRACE/report.html"
+    run_zmr_report "$SINGLE_TRACE"
     run "$ZMR_BIN" export "$SINGLE_TRACE" --out "$TRACE_ROOT/scenario.zmrtrace"
     run "$ZMR_BIN" export "$SINGLE_TRACE" --out "$TRACE_ROOT/scenario-redacted.zmrtrace" --redact
   else
@@ -513,11 +518,11 @@ if [[ "$RUNS" -eq 1 ]]; then
     LOGIN_TRACE="$TRACE_ROOT/login-smoke"
     run rm -rf "$AUTH_TRACE" "$LOGIN_TRACE"
     run_zmr_android_scenario examples/android-app-auth-probe.json --device "$DEVICE" --app-id "$APP_ID" --trace-dir "$AUTH_TRACE"
-    run "$ZMR_BIN" report "$AUTH_TRACE" --out "$AUTH_TRACE/report.html"
+    run_zmr_report "$AUTH_TRACE"
     run "$ZMR_BIN" export "$AUTH_TRACE" --out "$TRACE_ROOT/auth.zmrtrace"
     run "$ZMR_BIN" export "$AUTH_TRACE" --out "$TRACE_ROOT/auth-redacted.zmrtrace" --redact
     run_zmr_android_scenario examples/android-app-login-smoke.json --device "$DEVICE" --app-id "$APP_ID" --trace-dir "$LOGIN_TRACE"
-    run "$ZMR_BIN" report "$LOGIN_TRACE" --out "$LOGIN_TRACE/report.html"
+    run_zmr_report "$LOGIN_TRACE"
     run "$ZMR_BIN" export "$LOGIN_TRACE" --out "$TRACE_ROOT/login-smoke.zmrtrace"
     run "$ZMR_BIN" export "$LOGIN_TRACE" --out "$TRACE_ROOT/login-smoke-redacted.zmrtrace" --redact
   fi
@@ -531,12 +536,12 @@ else
   fi
   if [[ -n "$SCENARIO" ]]; then
     run_android_benchmark --zmr "$SCENARIO" --device "$DEVICE" --app-id "$APP_ID" --runs "$RUNS" --trace-root "$TRACE_ROOT/bench-scenario" "${benchmark_gate_args[@]}"
-    run "$ZMR_BIN" report "$TRACE_ROOT/bench-scenario" --out "$TRACE_ROOT/bench-scenario/report.html"
+    run_zmr_report "$TRACE_ROOT/bench-scenario"
   else
     run_android_benchmark --zmr examples/android-app-auth-probe.json --device "$DEVICE" --app-id "$APP_ID" --runs "$RUNS" --trace-root "$TRACE_ROOT/bench-auth" "${benchmark_gate_args[@]}"
-    run "$ZMR_BIN" report "$TRACE_ROOT/bench-auth" --out "$TRACE_ROOT/bench-auth/report.html"
+    run_zmr_report "$TRACE_ROOT/bench-auth"
     run_android_benchmark --zmr examples/android-app-login-smoke.json --device "$DEVICE" --app-id "$APP_ID" --runs "$RUNS" --trace-root "$TRACE_ROOT/bench-login-smoke" "${benchmark_gate_args[@]}"
-    run "$ZMR_BIN" report "$TRACE_ROOT/bench-login-smoke" --out "$TRACE_ROOT/bench-login-smoke/report.html"
+    run_zmr_report "$TRACE_ROOT/bench-login-smoke"
   fi
 fi
 
@@ -546,9 +551,30 @@ cat <<EOF
 
 Android pilot complete.
 Output directory: $TRACE_ROOT
-Shareable bundles:
-  $TRACE_ROOT/auth-redacted.zmrtrace
-  $TRACE_ROOT/login-smoke-redacted.zmrtrace
+EOF
+
+if [[ "$RUNS" -eq 1 ]]; then
+  echo "Shareable bundles:"
+  if [[ -n "$SCENARIO" ]]; then
+    echo "  $TRACE_ROOT/scenario-redacted.zmrtrace"
+  else
+    echo "  $TRACE_ROOT/auth-redacted.zmrtrace"
+    echo "  $TRACE_ROOT/login-smoke-redacted.zmrtrace"
+  fi
+else
+  echo "Benchmark reports:"
+  if [[ -n "$SCENARIO" ]]; then
+    echo "  $TRACE_ROOT/bench-scenario/report.html"
+    echo "  $TRACE_ROOT/bench-scenario/junit.xml"
+  else
+    echo "  $TRACE_ROOT/bench-auth/report.html"
+    echo "  $TRACE_ROOT/bench-auth/junit.xml"
+    echo "  $TRACE_ROOT/bench-login-smoke/report.html"
+    echo "  $TRACE_ROOT/bench-login-smoke/junit.xml"
+  fi
+fi
+
+cat <<EOF
 Viewer:
   $ROOT/viewer/index.html
 EOF

package/scripts/run-ios-pilot.sh

@@ -156,6 +156,11 @@ run() {
   fi
 }
 
+run_zmr_report() {
+  local trace_dir="$1"
+  run "$ZMR_BIN" report "$trace_dir" --out "$trace_dir/report.html" --junit "$trace_dir/junit.xml"
+}
+
 is_retryable_simctl_text() {
   local text="$1"
   [[ "$text" == *"CoreSimulatorService connection became invalid"* ]] ||
@@ -455,7 +460,7 @@ if [[ "$RUNS" -eq 1 ]]; then
   else
     run "$ZMR_BIN" run examples/ios-smoke.json --platform ios --ios-device-type "$IOS_DEVICE_TYPE" --device "$DEVICE" --app-id "$APP_ID" --xcrun "$XCRUN" --trace-dir "$TRACE_DIR"
   fi
-  run "$ZMR_BIN" report "$TRACE_DIR" --out "$TRACE_DIR/report.html"
+  run_zmr_report "$TRACE_DIR"
   run "$ZMR_BIN" export "$TRACE_DIR" --out "$TRACE_ROOT/ios-smoke.zmrtrace"
   run "$ZMR_BIN" export "$TRACE_DIR" --out "$TRACE_ROOT/ios-smoke-redacted.zmrtrace" --redact
 
@@ -463,7 +468,7 @@ if [[ "$RUNS" -eq 1 ]]; then
     SHIM_TRACE_DIR="$TRACE_ROOT/ios-shim-smoke"
     run rm -rf "$SHIM_TRACE_DIR"
     run "$ZMR_BIN" run examples/ios-shim-smoke.json --platform ios --ios-device-type "$IOS_DEVICE_TYPE" --device "$DEVICE" --app-id "$APP_ID" --xcrun "$XCRUN" --ios-shim "$IOS_SHIM" --trace-dir "$SHIM_TRACE_DIR"
-    run "$ZMR_BIN" report "$SHIM_TRACE_DIR" --out "$SHIM_TRACE_DIR/report.html"
+    run_zmr_report "$SHIM_TRACE_DIR"
     run "$ZMR_BIN" export "$SHIM_TRACE_DIR" --out "$TRACE_ROOT/ios-shim-smoke.zmrtrace"
     run "$ZMR_BIN" export "$SHIM_TRACE_DIR" --out "$TRACE_ROOT/ios-shim-smoke-redacted.zmrtrace" --redact
   fi
@@ -481,11 +486,11 @@ else
   else
     ZMR_BIN="$ZMR_BIN" run "$ROOT/scripts/benchmark.sh" --zmr examples/ios-smoke.json --device "$DEVICE" --platform ios --ios-device-type "$IOS_DEVICE_TYPE" --app-id "$APP_ID" --xcrun "$XCRUN" --runs "$RUNS" --trace-root "$TRACE_ROOT/ios-smoke-benchmark" "${benchmark_gate_args[@]}"
   fi
-  run "$ZMR_BIN" report "$TRACE_ROOT/ios-smoke-benchmark" --out "$TRACE_ROOT/ios-smoke-benchmark/report.html"
+  run_zmr_report "$TRACE_ROOT/ios-smoke-benchmark"
 
   if [[ -n "$IOS_SHIM" ]]; then
     ZMR_BIN="$ZMR_BIN" run "$ROOT/scripts/benchmark.sh" --zmr examples/ios-shim-smoke.json --device "$DEVICE" --platform ios --ios-device-type "$IOS_DEVICE_TYPE" --app-id "$APP_ID" --xcrun "$XCRUN" --ios-shim "$IOS_SHIM" --runs "$RUNS" --trace-root "$TRACE_ROOT/ios-shim-smoke-benchmark" "${benchmark_gate_args[@]}"
-    run "$ZMR_BIN" report "$TRACE_ROOT/ios-shim-smoke-benchmark" --out "$TRACE_ROOT/ios-shim-smoke-benchmark/report.html"
+    run_zmr_report "$TRACE_ROOT/ios-shim-smoke-benchmark"
   fi
 fi
 
@@ -501,8 +506,10 @@ if [[ "$RUNS" -eq 1 ]]; then
 else
   echo "Benchmark reports:"
   echo "  $TRACE_ROOT/ios-smoke-benchmark/report.html"
+  echo "  $TRACE_ROOT/ios-smoke-benchmark/junit.xml"
   if [[ -n "$IOS_SHIM" ]]; then
     echo "  $TRACE_ROOT/ios-shim-smoke-benchmark/report.html"
+    echo "  $TRACE_ROOT/ios-shim-smoke-benchmark/junit.xml"
   fi
 fi
 echo "Viewer:"

package/shims/ios/ZMRShim.swift

@@ -22,6 +22,11 @@ struct ZMRShimBounds: Encodable {
     let height: Int
 }
 
+struct ZMRShimViewport: Encodable {
+    let width: Int
+    let height: Int
+}
+
 struct ZMRShimNode: Encodable {
     let id: String
     let type: String
@@ -35,6 +40,11 @@ struct ZMRShimNode: Encodable {
 }
 
 enum ZMRShim {
+    static func viewport(app: XCUIApplication) -> ZMRShimViewport {
+        let frame = app.frame
+        return ZMRShimViewport(width: Int(frame.size.width), height: Int(frame.size.height))
+    }
+
     static func snapshot(app: XCUIApplication) -> [ZMRShimNode] {
         let queries: [(XCUIElement.ElementType, XCUIElementQuery)] = [
             (.button, app.buttons),

package/shims/ios/ZMRShimUITestCase.swift

@@ -105,10 +105,15 @@ final class ZMRShimUITestCase: XCTestCase {
     }
 
     private func run(command: ZMRShimCommand, app: XCUIApplication) -> [String: Any] {
+        if commandRequiresForeground(command), let foregroundError = ensureAppForeground(app: app) {
+            return foregroundError
+        }
+
         switch command.cmd {
         case "snapshot":
             return [
                 "status": "ok",
+                "viewport": ZMRShim.viewport(app: app).json,
                 "nodes": ZMRShim.snapshot(app: app).map { $0.json }
             ]
         case "screenshot":
@@ -188,6 +193,34 @@ final class ZMRShimUITestCase: XCTestCase {
         }
     }
 
+    private func commandRequiresForeground(_ command: ZMRShimCommand) -> Bool {
+        switch command.cmd {
+        case "snapshot", "query", "tap", "type", "eraseText", "hideKeyboard", "swipe", "settle":
+            return true
+        default:
+            return false
+        }
+    }
+
+    private func ensureAppForeground(app: XCUIApplication) -> [String: Any]? {
+        if app.state != .runningForeground {
+            app.activate()
+        }
+
+        let deadline = Date().addingTimeInterval(5)
+        while Date() < deadline {
+            if app.state == .runningForeground {
+                return nil
+            }
+            Thread.sleep(forTimeInterval: 0.1)
+        }
+
+        return error(
+            "app.not_foreground",
+            "target app did not become foreground; state=\(app.state.rawValue)"
+        )
+    }
+
     private func ok() -> [String: Any] {
         ["status": "ok"]
     }
@@ -532,6 +565,15 @@ private extension ZMRShimBounds {
     }
 }
 
+private extension ZMRShimViewport {
+    var json: [String: Any] {
+        [
+            "width": width,
+            "height": height
+        ]
+    }
+}
+
 private extension ZMRShimNode {
     var json: [String: Any] {
         [

package/shims/ios/protocol.md

@@ -51,6 +51,7 @@ turn every snapshot into a full hierarchy crawl:
 ```json
 {
   "status": "ok",
+  "viewport": { "width": 390, "height": 844 },
   "nodes": [
     {
       "id": "button-continue",

package/skills/zmr-mobile-testing/SKILL.md

@@ -57,9 +57,34 @@ zmr mcp --config .zmr/config.json --trace-dir traces/zmr-agent
 ```
 
 Use the `semantic_snapshot`, `tap`, `type`, `wait_visible`, `trace_events`, and
-`trace_export` tools. Prefer `semantic_snapshot` because it normalizes Android
-and iOS hierarchy classes into roles, selectors, bounds, and recommended
-actions.
+`trace_explore`, `trace_discover`, and `trace_export` tools. Prefer
+`semantic_snapshot` because it normalizes Android and iOS hierarchy classes
+into roles, selectors, bounds, and recommended actions.
+
+After a session has produced trace artifacts, prefer the review-first
+exploration handoff when a goal should travel with the generated scenario
+candidate:
+
+```json
+{"method":"trace.explore","params":{"out":".zmr/discovered/login-smoke.json","goal":"find a stable login smoke","includeActions":true,"validate":true,"force":true}}
+```
+
+For MCP agents, call `trace_explore` with the same `out`, `goal`,
+`includeActions`, `validate`, and `force` arguments. The offline CLI equivalent
+is:
+
+```bash
+zmr explore --from-trace traces/zmr-agent \
+  --out .zmr/discovered/login-smoke.json \
+  --goal "find a stable login smoke" \
+  --include-actions \
+  --validate \
+  --json
+```
+
+Treat the output as a starting point. Its JSON includes `autonomous:false`,
+`reviewRequired:true`, `guardrails`, replay coverage, validation, and next
+commands; it does not crawl, discover credentials, or commit tests.
 
 ## Scenario Pattern
 

package/src/cli_discover.zig

@@ -0,0 +1,239 @@
+const std = @import("std");
+
+const cli_draft = @import("cli_draft.zig");
+const cli_output = @import("cli_output.zig");
+const trace = @import("trace.zig");
+const validation = @import("validation.zig");
+const version = @import("version.zig");
+
+pub const ParsedArgs = struct {
+    from_trace: ?[]const u8 = null,
+    out_path: ?[]const u8 = null,
+    name: ?[]const u8 = null,
+    app_id: ?[]const u8 = null,
+    include_actions: bool = false,
+    validate: bool = false,
+    force: bool = false,
+    json: bool = false,
+};
+
+pub const DiscoverSummary = struct {
+    ok: bool,
+    draft: cli_draft.DraftSummary,
+    validated: bool,
+};
+
+pub const JsonOptions = struct {
+    mode: []const u8 = "discover",
+    goal: ?[]const u8 = null,
+    autonomous: ?bool = null,
+    review_required: ?bool = null,
+    guardrails: []const []const u8 = &.{},
+};
+
+pub const OwnedDiscover = struct {
+    draft: cli_draft.OwnedDraft,
+    validation: ?validation.Result = null,
+    summary: DiscoverSummary,
+
+    pub fn deinit(self: *OwnedDiscover, allocator: std.mem.Allocator) void {
+        if (self.validation) |result| result.deinit(allocator);
+        self.draft.deinit(allocator);
+    }
+};
+
+pub fn parseArgs(args: []const []const u8) !ParsedArgs {
+    var parsed = ParsedArgs{};
+    var index: usize = 0;
+    while (index < args.len) : (index += 1) {
+        const arg = args[index];
+        if (std.mem.eql(u8, arg, "--from-trace")) {
+            index += 1;
+            parsed.from_trace = if (index < args.len) args[index] else return error.MissingTraceDir;
+        } else if (std.mem.eql(u8, arg, "--out")) {
+            index += 1;
+            parsed.out_path = if (index < args.len) args[index] else return error.MissingDraftOut;
+        } else if (std.mem.eql(u8, arg, "--name")) {
+            index += 1;
+            parsed.name = if (index < args.len) args[index] else return error.MissingParam;
+        } else if (std.mem.eql(u8, arg, "--app-id")) {
+            index += 1;
+            parsed.app_id = if (index < args.len) args[index] else return error.MissingAppId;
+        } else if (std.mem.eql(u8, arg, "--include-actions")) {
+            parsed.include_actions = true;
+        } else if (std.mem.eql(u8, arg, "--validate")) {
+            parsed.validate = true;
+        } else if (std.mem.eql(u8, arg, "--force")) {
+            parsed.force = true;
+        } else if (std.mem.eql(u8, arg, "--json")) {
+            parsed.json = true;
+        } else {
+            return error.UnknownFlag;
+        }
+    }
+
+    if (parsed.from_trace == null) return error.MissingTraceDir;
+    if (parsed.out_path == null) return error.MissingDraftOut;
+    return parsed;
+}
+
+pub fn run(allocator: std.mem.Allocator, args: *std.process.ArgIterator) !void {
+    var raw_args = std.ArrayList([]const u8).empty;
+    defer raw_args.deinit(allocator);
+    while (args.next()) |arg| try raw_args.append(allocator, arg);
+
+    const parsed = try parseArgs(raw_args.items);
+    var discovered = try discoverFromTrace(allocator, parsed);
+    defer discovered.deinit(allocator);
+
+    const stdout = std.fs.File.stdout().deprecatedWriter();
+    if (parsed.json) {
+        try writeJson(stdout, discovered.summary, discovered.validation);
+    } else {
+        try stdout.print("wrote {s}\n", .{discovered.summary.draft.out_path});
+        if (discovered.validation) |result| {
+            if (result.ok) {
+                try stdout.print("validated {s}\n", .{discovered.summary.draft.out_path});
+            } else {
+                try stdout.print("validation failed {s}\n", .{discovered.summary.draft.out_path});
+            }
+        }
+        try stdout.writeAll("next: zmr validate --json ");
+        try cli_output.writeShellArg(stdout, discovered.summary.draft.out_path);
+        try stdout.writeAll("\n");
+    }
+    if (!discovered.summary.ok) std.process.exit(1);
+}
+
+pub fn discoverFromTrace(allocator: std.mem.Allocator, parsed: ParsedArgs) !OwnedDiscover {
+    var draft = try cli_draft.draftFromTrace(allocator, .{
+        .from_trace = parsed.from_trace,
+        .out_path = parsed.out_path,
+        .name = parsed.name,
+        .app_id = parsed.app_id,
+        .include_actions = parsed.include_actions,
+        .force = parsed.force,
+        .json = parsed.json,
+    });
+    errdefer draft.deinit(allocator);
+
+    var validation_result: ?validation.Result = null;
+    errdefer if (validation_result) |result| result.deinit(allocator);
+    if (parsed.validate) {
+        validation_result = try validation.validateFile(allocator, draft.summary.out_path);
+    }
+
+    const ok = draft.summary.ok and (validation_result == null or validation_result.?.ok);
+    return .{
+        .draft = draft,
+        .validation = validation_result,
+        .summary = .{
+            .ok = ok,
+            .draft = draft.summary,
+            .validated = parsed.validate,
+        },
+    };
+}
+
+pub fn writeJson(writer: anytype, summary: DiscoverSummary, validation_result: ?validation.Result) !void {
+    try writeJsonWithOptions(writer, summary, validation_result, .{});
+}
+
+pub fn writeJsonWithOptions(writer: anytype, summary: DiscoverSummary, validation_result: ?validation.Result, options: JsonOptions) !void {
+    const draft = summary.draft;
+    try writer.writeAll("{\"ok\":");
+    try writer.writeAll(if (summary.ok) "true" else "false");
+    try writer.writeAll(",\"mode\":");
+    try trace.writeJsonString(writer, options.mode);
+    try writer.writeAll(",\"schemaVersion\":1");
+    try writer.writeAll(",\"runnerVersion\":");
+    try trace.writeJsonString(writer, version.runner_version);
+    try writer.writeAll(",\"protocolVersion\":");
+    try trace.writeJsonString(writer, version.protocol_version);
+    if (options.goal) |goal| {
+        try writer.writeAll(",\"goal\":");
+        try trace.writeJsonString(writer, goal);
+    }
+    if (options.autonomous) |autonomous| {
+        try writer.writeAll(",\"autonomous\":");
+        try writer.writeAll(if (autonomous) "true" else "false");
+    }
+    if (options.review_required) |review_required| {
+        try writer.writeAll(",\"reviewRequired\":");
+        try writer.writeAll(if (review_required) "true" else "false");
+    }
+    if (options.guardrails.len > 0) {
+        try writer.writeAll(",\"guardrails\":[");
+        for (options.guardrails, 0..) |guardrail, index| {
+            if (index > 0) try writer.writeAll(",");
+            try trace.writeJsonString(writer, guardrail);
+        }
+        try writer.writeAll("]");
+    }
+    try writer.writeAll(",\"out\":");
+    try trace.writeJsonString(writer, draft.out_path);
+    try writer.writeAll(",\"traceDir\":");
+    try trace.writeJsonString(writer, draft.trace_dir);
+    try writer.writeAll(",\"sourceSnapshot\":");
+    try trace.writeJsonString(writer, draft.source_snapshot);
+    try writer.writeAll(",\"name\":");
+    try trace.writeJsonString(writer, draft.name);
+    try writer.writeAll(",\"appId\":");
+    if (draft.app_id) |actual| {
+        try trace.writeJsonString(writer, actual);
+    } else {
+        try writer.writeAll("null");
+    }
+    try writer.print(",\"selectorCount\":{d},\"stepCount\":{d}", .{ draft.selector_count, draft.step_count });
+    try cli_draft.writeReplayJson(writer, draft.replay);
+    try writer.writeAll(",\"warnings\":[");
+    for (draft.warnings, 0..) |warning, index| {
+        if (index > 0) try writer.writeAll(",");
+        try trace.writeJsonString(writer, warning);
+    }
+    try writer.writeAll("],\"validated\":");
+    try writer.writeAll(if (summary.validated) "true" else "false");
+    try writer.writeAll(",\"validation\":");
+    if (validation_result) |result| {
+        try writeValidationObject(writer, draft.out_path, result);
+    } else {
+        try writer.writeAll("null");
+    }
+    try writer.writeAll(",\"nextCommands\":[\"zmr validate --json ");
+    try cli_output.writeShellArgJsonContent(writer, draft.out_path);
+    try writer.writeAll("\",\"zmr run ");
+    try cli_output.writeShellArgJsonContent(writer, draft.out_path);
+    try writer.writeAll(" --json --trace-dir ");
+    try cli_output.writeShellArgJsonContent(writer, draft.trace_dir);
+    try writer.writeAll("\"]}\n");
+}
+
+fn writeValidationObject(writer: anytype, path: []const u8, result: validation.Result) !void {
+    try writer.writeAll("{\"ok\":");
+    try writer.writeAll(if (result.ok) "true" else "false");
+    try writer.writeAll(",\"path\":");
+    try trace.writeJsonString(writer, path);
+    if (result.ok) {
+        try writer.writeAll(",\"name\":");
+        try trace.writeJsonString(writer, result.name.?);
+        try writer.writeAll(",\"appId\":");
+        if (result.app_id) |app_id| {
+            try trace.writeJsonString(writer, app_id);
+        } else {
+            try writer.writeAll("null");
+        }
+        try writer.print(",\"stepCount\":{d}", .{result.step_count});
+    } else {
+        try writer.writeAll(",\"errorCode\":");
+        try trace.writeJsonString(writer, result.error_code.?);
+        try writer.writeAll(",\"message\":");
+        try trace.writeJsonString(writer, result.message.?);
+        if (result.path) |field_path| {
+            try writer.writeAll(",\"fieldPath\":");
+            try trace.writeJsonString(writer, field_path);
+        }
+        if (result.line) |line| try writer.print(",\"line\":{d}", .{line});
+        if (result.column) |column| try writer.print(",\"column\":{d}", .{column});
+    }
+    try writer.writeAll("}");
+}