zeno-mobile-runner 0.1.2 → 0.1.8

package/src/cli_explore.zig

@@ -0,0 +1,136 @@
+const std = @import("std");
+
+const cli_discover = @import("cli_discover.zig");
+const cli_output = @import("cli_output.zig");
+const validation = @import("validation.zig");
+
+const explore_guardrails = [_][]const u8{
+    "writes from existing trace evidence only",
+    "does not crawl the app",
+    "does not discover credentials or secrets",
+    "requires human review before commit",
+};
+
+pub const ParsedArgs = struct {
+    from_trace: ?[]const u8 = null,
+    out_path: ?[]const u8 = null,
+    goal: ?[]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 ExploreSummary = struct {
+    ok: bool,
+    goal: ?[]const u8,
+};
+
+pub const OwnedExplore = struct {
+    discovered: cli_discover.OwnedDiscover,
+    summary: ExploreSummary,
+
+    pub fn deinit(self: *OwnedExplore, allocator: std.mem.Allocator) void {
+        self.discovered.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, "--goal")) {
+            index += 1;
+            parsed.goal = if (index < args.len) args[index] else return error.MissingParam;
+        } 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 explored = try exploreFromTrace(allocator, parsed);
+    defer explored.deinit(allocator);
+
+    const stdout = std.fs.File.stdout().deprecatedWriter();
+    if (parsed.json) {
+        try writeJson(stdout, explored.summary, explored.discovered.summary, explored.discovered.validation);
+    } else {
+        try stdout.print("wrote {s}\n", .{explored.discovered.summary.draft.out_path});
+        if (explored.summary.goal) |goal| try stdout.print("goal: {s}\n", .{goal});
+        try stdout.writeAll("review required: true\n");
+        try stdout.writeAll("next: zmr validate --json ");
+        try cli_output.writeShellArg(stdout, explored.discovered.summary.draft.out_path);
+        try stdout.writeAll("\n");
+    }
+    if (!explored.summary.ok) std.process.exit(1);
+}
+
+pub fn exploreFromTrace(allocator: std.mem.Allocator, parsed: ParsedArgs) !OwnedExplore {
+    var discovered = try cli_discover.discoverFromTrace(allocator, .{
+        .from_trace = parsed.from_trace,
+        .out_path = parsed.out_path,
+        .name = parsed.name,
+        .app_id = parsed.app_id,
+        .include_actions = parsed.include_actions,
+        .validate = parsed.validate,
+        .force = parsed.force,
+        .json = parsed.json,
+    });
+    errdefer discovered.deinit(allocator);
+
+    return .{
+        .discovered = discovered,
+        .summary = .{
+            .ok = discovered.summary.ok,
+            .goal = parsed.goal,
+        },
+    };
+}
+
+pub fn writeJson(
+    writer: anytype,
+    summary: ExploreSummary,
+    discover_summary: cli_discover.DiscoverSummary,
+    validation_result: ?validation.Result,
+) !void {
+    try cli_discover.writeJsonWithOptions(writer, discover_summary, validation_result, .{
+        .mode = "explore",
+        .goal = summary.goal,
+        .autonomous = false,
+        .review_required = true,
+        .guardrails = explore_guardrails[0..],
+    });
+}

package/src/cli_inspect.zig

@@ -0,0 +1,310 @@
+const std = @import("std");
+
+const config = @import("config.zig");
+const scaffold = @import("scaffold.zig");
+const trace = @import("trace.zig");
+const version = @import("version.zig");
+
+pub const ParsedArgs = struct {
+    json: bool = false,
+    dir: []const u8 = ".",
+    config_path: ?[]const u8 = null,
+};
+
+pub const PlatformInspection = struct {
+    name: []const u8,
+    enabled: bool,
+    default_device: ?[]const u8 = null,
+    smoke_scenario: ?[]const u8 = null,
+    smoke_scenario_exists: bool = false,
+    trace_dir: ?[]const u8 = null,
+};
+
+pub const Inspection = struct {
+    ok: bool,
+    status: []const u8 = "ready",
+    dir: []const u8,
+    config_path: []const u8,
+    config_exists: bool,
+    agent_instructions_path: []const u8,
+    agent_instructions_exists: bool,
+    platforms: []const PlatformInspection = &.{},
+};
+
+const OwnedInspection = struct {
+    inspection: Inspection,
+    owned_strings: std.ArrayList([]const u8),
+    platforms: std.ArrayList(PlatformInspection),
+    parsed_config: ?config.Config = null,
+
+    fn deinit(self: *OwnedInspection, allocator: std.mem.Allocator) void {
+        if (self.parsed_config) |*cfg| cfg.deinit(allocator);
+        for (self.owned_strings.items) |value| allocator.free(value);
+        self.owned_strings.deinit(allocator);
+        self.platforms.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, "--json")) {
+            parsed.json = true;
+        } else if (std.mem.eql(u8, arg, "--dir")) {
+            index += 1;
+            parsed.dir = if (index < args.len) args[index] else return error.MissingParam;
+        } else if (std.mem.eql(u8, arg, "--config")) {
+            index += 1;
+            parsed.config_path = if (index < args.len) args[index] else return error.MissingParam;
+        } else {
+            return error.UnknownFlag;
+        }
+    }
+    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 owned = try inspect(allocator, parsed);
+    defer owned.deinit(allocator);
+
+    const stdout = std.fs.File.stdout().deprecatedWriter();
+    if (parsed.json) {
+        try writeJson(stdout, owned.inspection);
+    } else {
+        try writeText(stdout, owned.inspection);
+    }
+}
+
+fn inspect(allocator: std.mem.Allocator, parsed: ParsedArgs) !OwnedInspection {
+    var owned = OwnedInspection{
+        .inspection = .{
+            .ok = false,
+            .status = "needs-setup",
+            .dir = undefined,
+            .config_path = undefined,
+            .config_exists = false,
+            .agent_instructions_path = undefined,
+            .agent_instructions_exists = false,
+        },
+        .owned_strings = .empty,
+        .platforms = .empty,
+    };
+    errdefer owned.deinit(allocator);
+
+    owned.inspection.dir = try ownString(allocator, &owned.owned_strings, parsed.dir);
+    owned.inspection.config_path = if (parsed.config_path) |explicit|
+        try ownString(allocator, &owned.owned_strings, explicit)
+    else
+        try ownJoinedPath(allocator, &owned.owned_strings, parsed.dir, scaffold.app_config_file);
+    owned.inspection.agent_instructions_path = try ownJoinedPath(allocator, &owned.owned_strings, parsed.dir, scaffold.app_agents_file);
+
+    owned.inspection.config_exists = pathExists(owned.inspection.config_path);
+    owned.inspection.agent_instructions_exists = pathExists(owned.inspection.agent_instructions_path);
+    if (!owned.inspection.config_exists) return owned;
+
+    owned.parsed_config = try config.parseFile(allocator, owned.inspection.config_path);
+    const cfg = &owned.parsed_config.?;
+    try appendPlatform(allocator, &owned, "android", cfg.android);
+    try appendPlatform(allocator, &owned, "ios", cfg.ios);
+    owned.inspection.platforms = owned.platforms.items;
+    owned.inspection.ok = true;
+    owned.inspection.status = "ready";
+    return owned;
+}
+
+fn appendPlatform(
+    allocator: std.mem.Allocator,
+    owned: *OwnedInspection,
+    name: []const u8,
+    platform: config.PlatformConfig,
+) !void {
+    const smoke_scenario = if (platform.smoke_scenario) |path|
+        try ownResolvedPath(allocator, &owned.owned_strings, owned.inspection.dir, path)
+    else
+        null;
+    try owned.platforms.append(allocator, .{
+        .name = name,
+        .enabled = platform.enabled,
+        .default_device = platform.default_device,
+        .smoke_scenario = smoke_scenario,
+        .smoke_scenario_exists = if (smoke_scenario) |path| pathExists(path) else false,
+        .trace_dir = platform.trace_dir,
+    });
+}
+
+fn pathExists(path: []const u8) bool {
+    std.fs.cwd().access(path, .{}) catch return false;
+    return true;
+}
+
+fn ownString(allocator: std.mem.Allocator, owned_strings: *std.ArrayList([]const u8), value: []const u8) ![]const u8 {
+    const owned = try allocator.dupe(u8, value);
+    try owned_strings.append(allocator, owned);
+    return owned;
+}
+
+fn ownJoinedPath(
+    allocator: std.mem.Allocator,
+    owned_strings: *std.ArrayList([]const u8),
+    root: []const u8,
+    path: []const u8,
+) ![]const u8 {
+    const joined = try std.fs.path.join(allocator, &.{ root, path });
+    try owned_strings.append(allocator, joined);
+    return joined;
+}
+
+fn ownResolvedPath(
+    allocator: std.mem.Allocator,
+    owned_strings: *std.ArrayList([]const u8),
+    root: []const u8,
+    path: []const u8,
+) ![]const u8 {
+    if (std.fs.path.isAbsolute(path)) return try ownString(allocator, owned_strings, path);
+    return try ownJoinedPath(allocator, owned_strings, root, path);
+}
+
+pub fn writeJson(writer: anytype, inspection: Inspection) !void {
+    try writer.writeAll("{\"ok\":");
+    try writer.writeAll(if (inspection.ok) "true" else "false");
+    try writer.writeAll(",\"status\":");
+    try trace.writeJsonString(writer, inspection.status);
+    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);
+    try writer.writeAll(",\"dir\":");
+    try trace.writeJsonString(writer, inspection.dir);
+    try writer.writeAll(",\"configPath\":");
+    try trace.writeJsonString(writer, inspection.config_path);
+    try writer.writeAll(",\"configExists\":");
+    try writer.writeAll(if (inspection.config_exists) "true" else "false");
+    try writer.writeAll(",\"agentInstructionsPath\":");
+    try trace.writeJsonString(writer, inspection.agent_instructions_path);
+    try writer.writeAll(",\"agentInstructionsExists\":");
+    try writer.writeAll(if (inspection.agent_instructions_exists) "true" else "false");
+    try writer.writeAll(",\"platforms\":[");
+    for (inspection.platforms, 0..) |platform, index| {
+        if (index > 0) try writer.writeAll(",");
+        try writePlatformJson(writer, platform);
+    }
+    try writer.writeAll("],\"recommendedCommands\":[");
+    try writeRecommendedCommandsJson(writer, inspection);
+    try writer.writeAll("]");
+    try writer.writeAll(",\"claimsPolicy\":[\"verify runs with trace evidence before making readiness claims\",\"do not claim Flutter widget-tree inspection\"]");
+    try writer.writeAll(",\"limitations\":[\"inspect is read-only and does not launch devices\",\"autonomous crawling is not shipped; generate or edit scenarios for human review\"]");
+    try writer.writeAll("}\n");
+}
+
+fn writePlatformJson(writer: anytype, platform: PlatformInspection) !void {
+    try writer.writeAll("{\"name\":");
+    try trace.writeJsonString(writer, platform.name);
+    try writer.writeAll(",\"enabled\":");
+    try writer.writeAll(if (platform.enabled) "true" else "false");
+    try writer.writeAll(",\"defaultDevice\":");
+    try writeOptionalJsonString(writer, platform.default_device);
+    try writer.writeAll(",\"smokeScenario\":");
+    try writeOptionalJsonString(writer, platform.smoke_scenario);
+    try writer.writeAll(",\"smokeScenarioExists\":");
+    try writer.writeAll(if (platform.smoke_scenario_exists) "true" else "false");
+    try writer.writeAll(",\"traceDir\":");
+    try writeOptionalJsonString(writer, platform.trace_dir);
+    try writer.writeAll("}");
+}
+
+fn writeOptionalJsonString(writer: anytype, value: ?[]const u8) !void {
+    if (value) |actual| {
+        try trace.writeJsonString(writer, actual);
+    } else {
+        try writer.writeAll("null");
+    }
+}
+
+fn writeRecommendedCommandsJson(writer: anytype, inspection: Inspection) !void {
+    if (!inspection.config_exists) {
+        try writer.writeAll("\"zmr init --app --dir ");
+        try writeShellArgJsonContent(writer, inspection.dir);
+        try writer.writeAll("\"");
+        return;
+    }
+
+    try writer.writeAll("\"zmr doctor --strict --json --config ");
+    try writeShellArgJsonContent(writer, inspection.config_path);
+    try writer.writeAll("\",");
+    try trace.writeJsonString(writer, "zmr schemas --json");
+    for (inspection.platforms) |platform| {
+        if (!platform.enabled) continue;
+        if (platform.smoke_scenario) |path| {
+            try writer.writeAll(",\"zmr validate --json ");
+            try writeShellArgJsonContent(writer, path);
+            try writer.writeAll("\"");
+        }
+    }
+    try writer.writeAll(",\"zmr serve --transport stdio --config ");
+    try writeShellArgJsonContent(writer, inspection.config_path);
+    try writer.writeAll(" --trace-dir traces/zmr-agent\"");
+    try writer.writeAll(",\"zmr mcp --config ");
+    try writeShellArgJsonContent(writer, inspection.config_path);
+    try writer.writeAll(" --trace-dir traces/zmr-agent\"");
+}
+
+fn writeShellArgJsonContent(writer: anytype, value: []const u8) !void {
+    if (value.len == 0) {
+        try writer.writeAll("''");
+        return;
+    }
+    var safe = true;
+    for (value) |byte| {
+        if (!std.ascii.isAlphanumeric(byte) and byte != '/' and byte != '.' and byte != '_' and byte != '-' and byte != ':' and byte != '=') {
+            safe = false;
+            break;
+        }
+    }
+    if (safe) {
+        try writeJsonStringContent(writer, value);
+        return;
+    }
+    try writer.writeAll("'");
+    for (value) |byte| {
+        if (byte == '\'') {
+            try writer.writeAll("'\"'\"'");
+        } else {
+            try writeJsonEscapedByte(writer, byte);
+        }
+    }
+    try writer.writeAll("'");
+}
+
+fn writeJsonStringContent(writer: anytype, value: []const u8) !void {
+    for (value) |byte| try writeJsonEscapedByte(writer, byte);
+}
+
+fn writeJsonEscapedByte(writer: anytype, byte: u8) !void {
+    switch (byte) {
+        '\\' => try writer.writeAll("\\\\"),
+        '"' => try writer.writeAll("\\\""),
+        '\n' => try writer.writeAll("\\n"),
+        '\r' => try writer.writeAll("\\r"),
+        '\t' => try writer.writeAll("\\t"),
+        else => try writer.writeByte(byte),
+    }
+}
+
+fn writeText(writer: anytype, inspection: Inspection) !void {
+    try writer.print("status\t{s}\n", .{inspection.status});
+    try writer.print("config\t{s}\t{s}\n", .{ if (inspection.config_exists) "ok" else "missing", inspection.config_path });
+    try writer.print("agentInstructions\t{s}\t{s}\n", .{ if (inspection.agent_instructions_exists) "ok" else "missing", inspection.agent_instructions_path });
+    for (inspection.platforms) |platform| {
+        try writer.print("{s}\t{s}", .{ platform.name, if (platform.enabled) "enabled" else "disabled" });
+        if (platform.smoke_scenario) |path| try writer.print("\t{s}", .{path});
+        try writer.writeAll("\n");
+    }
+}

package/src/cli_output.zig

@@ -6,6 +6,11 @@ const trace = @import("trace.zig");
 const trace_summary = @import("trace_summary.zig");
 const validation = @import("validation.zig");
 
+pub const RunDiscovery = struct {
+    json: ?[]const u8 = null,
+    error_name: ?[]const u8 = null,
+};
+
 pub fn writeImportJson(writer: anytype, format: []const u8, source_path: []const u8, result: importer.ImportResult) !void {
     try writer.writeAll("{\"ok\":true,\"format\":");
     try trace.writeJsonString(writer, format);
@@ -131,12 +136,13 @@ pub fn writeRunSummaryJson(
     fallback_scenario: []const u8,
     fallback_app_id: []const u8,
     run_error: ?anyerror,
+    discovery: RunDiscovery,
 ) !void {
     if (trace_dir) |dir| {
         if (trace_summary.read(allocator, dir)) |summary_value| {
             var summary = summary_value;
             defer summary.deinit(allocator);
-            return try writeRunSummaryFromTraceSummary(writer, dir, summary, run_error);
+            return try writeRunSummaryFromTraceSummary(writer, dir, summary, run_error, discovery);
         } else |_| {}
     }
 
@@ -153,6 +159,7 @@ pub fn writeRunSummaryJson(
         try writer.writeAll(",\"error\":");
         try trace.writeJsonString(writer, @errorName(err));
     }
+    try writeRunDiscoveryJson(writer, discovery);
     try writer.writeAll("}\n");
 }
 
@@ -258,6 +265,7 @@ fn writeRunSummaryFromTraceSummary(
     trace_dir: []const u8,
     summary: trace_summary.Summary,
     run_error: ?anyerror,
+    discovery: RunDiscovery,
 ) !void {
     try writer.writeAll("{\"ok\":");
     try writer.writeAll(if (std.mem.eql(u8, summary.status, "passed")) "true" else "false");
@@ -295,18 +303,34 @@ fn writeRunSummaryFromTraceSummary(
         try writer.writeAll(",\"reportPath\":");
         try trace.writeJsonString(writer, value);
     }
+    try writeRunDiscoveryJson(writer, discovery);
     try writeRunNextCommandsJson(writer, trace_dir);
     try writer.writeAll("}\n");
 }
 
+fn writeRunDiscoveryJson(writer: anytype, discovery: RunDiscovery) !void {
+    if (discovery.json) |json| {
+        try writer.writeAll(",\"discovery\":");
+        try writer.writeAll(json);
+    }
+    if (discovery.error_name) |error_name| {
+        try writer.writeAll(",\"discoveryError\":");
+        try trace.writeJsonString(writer, error_name);
+    }
+}
+
 fn writeRunNextCommandsJson(writer: anytype, trace_dir: []const u8) !void {
     try writer.writeAll(",\"nextCommands\":[\"zmr report ");
     try writeShellArgJsonContent(writer, trace_dir);
     try writer.writeAll(" --out ");
     try writeJoinedPathShellArgJsonContent(writer, trace_dir, "report.html");
+    try writer.writeAll(" --junit ");
+    try writeJoinedPathShellArgJsonContent(writer, trace_dir, "junit.xml");
     try writer.writeAll("\",\"zmr explain ");
     try writeShellArgJsonContent(writer, trace_dir);
-    try writer.writeAll(" --json\",\"zmr export ");
+    try writer.writeAll(" --json\",\"zmr discover --from-trace ");
+    try writeShellArgJsonContent(writer, trace_dir);
+    try writer.writeAll(" --out .zmr/discovered/replay-smoke.json --include-actions --validate --force --json\",\"zmr export ");
     try writeShellArgJsonContent(writer, trace_dir);
     try writer.writeAll(" --out ");
     try writePathWithSuffixShellArgJsonContent(writer, trace_dir, ".zmrtrace");

package/src/cli_run.zig

@@ -2,6 +2,7 @@ const std = @import("std");
 
 const android = @import("android.zig");
 const android_emulator = @import("android_emulator.zig");
+const cli_discover = @import("cli_discover.zig");
 const cli_output = @import("cli_output.zig");
 const config_paths = @import("config_paths.zig");
 const ios = @import("ios.zig");
@@ -21,6 +22,7 @@ pub const ParsedArgs = struct {
     avdmanager_path_set: bool = false,
     xcrun_path_set: bool = false,
     config_path: ?[]const u8 = null,
+    discover_out: ?[]const u8 = null,
     json: bool = false,
 };
 
@@ -69,6 +71,9 @@ pub fn parseArgs(args: []const []const u8) !ParsedArgs {
         } else if (std.mem.eql(u8, arg, "--config")) {
             index += 1;
             parsed.config_path = if (index < args.len) args[index] else return error.MissingConfigPath;
+        } else if (std.mem.eql(u8, arg, "--discover-out")) {
+            index += 1;
+            parsed.discover_out = if (index < args.len) args[index] else return error.MissingDiscoverOut;
         } else if (std.mem.eql(u8, arg, "--screen-record")) {
             parsed.raw.screen_recording = true;
         } else if (std.mem.eql(u8, arg, "--no-screen-record")) {
@@ -153,6 +158,7 @@ pub fn run(allocator: std.mem.Allocator, args: *std.process.ArgIterator) !void {
         try config_paths.ownFilePath(allocator, &owned_config_paths, config_root.?, resolved.trace_dir.?)
     else
         resolved.trace_dir;
+    if (parsed.discover_out != null and trace_dir == null) return error.MissingTraceDir;
     const android_shim_path = if (raw.android_shim_path == null and config_root != null and resolved.android_shim_path != null)
         try config_paths.ownFilePath(allocator, &owned_config_paths, config_root.?, resolved.android_shim_path.?)
     else
@@ -185,6 +191,27 @@ pub fn run(allocator: std.mem.Allocator, args: *std.process.ArgIterator) !void {
         break :blk null;
     };
 
+    var discovery_payload = std.ArrayList(u8).empty;
+    defer discovery_payload.deinit(allocator);
+    var run_discovery = cli_output.RunDiscovery{};
+    if (parsed.discover_out) |out_path| {
+        if (cli_discover.discoverFromTrace(allocator, .{
+            .from_trace = trace_dir,
+            .out_path = out_path,
+            .include_actions = true,
+            .validate = true,
+            .force = true,
+            .json = true,
+        })) |discovered_value| {
+            var discovered = discovered_value;
+            defer discovered.deinit(allocator);
+            try cli_discover.writeJson(discovery_payload.writer(allocator), discovered.summary, discovered.validation);
+            run_discovery = .{ .json = std.mem.trimRight(u8, discovery_payload.items, " \t\r\n") };
+        } else |err| {
+            run_discovery = .{ .error_name = @errorName(err) };
+        }
+    }
+
     if (parsed.json) try cli_output.writeRunSummaryJson(
         allocator,
         std.fs.File.stdout().deprecatedWriter(),
@@ -192,6 +219,7 @@ pub fn run(allocator: std.mem.Allocator, args: *std.process.ArgIterator) !void {
         script.name,
         app_id,
         run_error,
+        run_discovery,
     );
     if (run_error) |err| return err;
 }

package/src/cli_trace.zig

@@ -6,6 +6,7 @@ const report = @import("report.zig");
 pub const ReportArgs = struct {
     input_path: []const u8,
     out_path: ?[]const u8 = null,
+    junit_path: ?[]const u8 = null,
 };
 
 pub const ExplainArgs = struct {
@@ -30,6 +31,9 @@ pub fn parseReportArgs(args: []const []const u8) !ReportArgs {
         if (std.mem.eql(u8, arg, "--out")) {
             index += 1;
             parsed.out_path = if (index < args.len) args[index] else return error.MissingReportOutput;
+        } else if (std.mem.eql(u8, arg, "--junit")) {
+            index += 1;
+            parsed.junit_path = if (index < args.len) args[index] else return error.MissingJUnitOutput;
         } else {
             return error.UnknownFlag;
         }
@@ -84,6 +88,10 @@ pub fn runReport(allocator: std.mem.Allocator, args: *std.process.ArgIterator) !
     const parsed = try parseReportArgs(raw_args.items);
     try report.writeHtmlReport(allocator, parsed.input_path, parsed.out_path.?);
     try std.fs.File.stdout().deprecatedWriter().print("wrote {s}\n", .{parsed.out_path.?});
+    if (parsed.junit_path) |junit_path| {
+        try report.writeJUnitReport(allocator, parsed.input_path, junit_path);
+        try std.fs.File.stdout().deprecatedWriter().print("wrote {s}\n", .{junit_path});
+    }
 }
 
 pub fn runExplain(allocator: std.mem.Allocator, args: *std.process.ArgIterator) !void {

package/src/errors.zig

@@ -10,6 +10,12 @@ pub fn classify(err: anyerror) PublicError {
         error.MissingScenarioPath => .{ .code = "cli.missing_scenario", .message = "missing scenario path" },
         error.MissingDeviceSerial => .{ .code = "cli.missing_device", .message = "missing device serial" },
         error.MissingTraceDir => .{ .code = "cli.missing_trace_dir", .message = "missing trace directory" },
+        error.MissingReportInput => .{ .code = "cli.missing_report_input", .message = "missing report input path" },
+        error.MissingReportOutput => .{ .code = "cli.missing_report_output", .message = "missing report output path" },
+        error.MissingDraftOut => .{ .code = "cli.missing_draft_out", .message = "missing draft output path" },
+        error.MissingDiscoverOut => .{ .code = "cli.missing_discover_out", .message = "missing discover output path" },
+        error.MissingJUnitOutput => .{ .code = "cli.missing_junit_output", .message = "missing JUnit output path" },
+        error.MissingTraceBundleOutput => .{ .code = "cli.missing_trace_bundle_output", .message = "missing trace bundle output path" },
         error.MissingAppId => .{ .code = "cli.missing_app_id", .message = "missing app id" },
         error.MissingAdbPath => .{ .code = "cli.missing_adb_path", .message = "missing adb path" },
         error.MissingXcrunPath => .{ .code = "cli.missing_xcrun_path", .message = "missing xcrun path" },
@@ -19,6 +25,9 @@ pub fn classify(err: anyerror) PublicError {
         error.UnknownFlag => .{ .code = "cli.unknown_flag", .message = "unknown flag" },
         error.MissingParam => .{ .code = "cli.missing_param", .message = "missing parameter" },
         error.FileNotFound => .{ .code = "scenario.file_not_found", .message = "scenario file was not found" },
+        error.SemanticSnapshotMissing => .{ .code = "draft.no_snapshot", .message = "no semantic snapshot was found in the trace" },
+        error.InvalidTraceManifest => .{ .code = "trace.invalid_manifest", .message = "trace manifest is invalid" },
+        error.InvalidSemanticSnapshot => .{ .code = "trace.invalid_semantic_snapshot", .message = "semantic snapshot is invalid" },
         error.UnsupportedPlatform => .{ .code = "cli.unsupported_platform", .message = "unsupported platform" },
         error.UnsupportedTransport => .{ .code = "cli.unsupported_transport", .message = "unsupported transport" },
         error.ScenarioMustBeObject,

package/src/ios.zig

@@ -9,7 +9,9 @@ const trace = @import("trace.zig");
 const types = @import("types.zig");
 
 const default_max_output = 32 * 1024 * 1024;
-const shim_timeout_ms = 600_000;
+// Clean iOS prebuilds can force the XCTest shim script through a full native
+// dependency build before it can answer the first selector query.
+const shim_timeout_ms = 5_400_000;
 const shim_best_effort_timeout_ms = 10_000;
 const shim_command_attempts = 2;
 const shim_bootstrap_retry_delay_ms = 500;
@@ -107,6 +109,7 @@ pub const IosDevice = struct {
         if (self.target_kind == .physical) return try self.stopPhysicalBestEffort();
         const result = try self.runSimctl(&.{ "terminate", self.target(), self.app_id }, default_max_output);
         defer result.deinit(self.allocator);
+        if (ios_lifecycle.isAppNotRunning(result)) return;
         try result.ensureSuccess();
     }
 
@@ -307,8 +310,12 @@ pub const IosDevice = struct {
 
         var command_with_selector = shim_command;
         command_with_selector.selector = shim_selector;
-        try self.runShimAction(command_with_selector);
-        return true;
+        const response = try self.runShim(command_with_selector);
+        defer self.allocator.free(response);
+        return switch (try ios_shim.parseSelectorActionResponse(response)) {
+            .ok => true,
+            .selector_unavailable => false,
+        };
     }
 
     fn runShim(self: *IosDevice, shim_command: ios_shim.Command) ![]u8 {
@@ -394,6 +401,6 @@ pub fn parsePhysicalDevicesJson(allocator: std.mem.Allocator, content: []const u
 }
 
 test "ios xctest shim timeout allows cold xcodebuild startup" {
-    try std.testing.expect(shim_timeout_ms >= 300_000);
+    try std.testing.expect(shim_timeout_ms >= 5_400_000);
     try std.testing.expect(shim_best_effort_timeout_ms <= 15_000);
 }