zeno-mobile-runner 0.1.3 → 0.2.0

package/src/mcp_trace.zig

@@ -1,6 +1,10 @@
 const std = @import("std");
 const bundle = @import("bundle.zig");
+const cli_discover = @import("cli_discover.zig");
+const cli_explore = @import("cli_explore.zig");
 const mcp_protocol = @import("mcp_protocol.zig");
+const report = @import("report.zig");
+const runner_events = @import("runner_events.zig");
 const trace = @import("trace.zig");
 
 pub fn writeEventsToolResult(
@@ -12,7 +16,10 @@ pub fn writeEventsToolResult(
     limit: u64,
 ) !void {
     const tw = live_trace orelse {
-        try mcp_protocol.writeToolTextResult(writer, id, "{\"traceDir\":null,\"events\":[]}");
+        var no_trace_payload = std.ArrayList(u8).empty;
+        defer no_trace_payload.deinit(allocator);
+        try no_trace_payload.writer(allocator).print("{{\"traceDir\":null,\"afterSeq\":{d},\"nextSeq\":{d},\"latestSeq\":0,\"events\":[]}}", .{ after_seq, after_seq });
+        try mcp_protocol.writeToolTextResult(writer, id, no_trace_payload.items);
         return;
     };
 
@@ -29,7 +36,11 @@ pub fn writeEventsToolResult(
     const payload_writer = payload.writer(allocator);
     try payload_writer.writeAll("{\"traceDir\":");
     try trace.writeJsonString(payload_writer, tw.root_dir);
-    try payload_writer.print(",\"afterSeq\":{d},\"events\":[", .{after_seq});
+    try payload_writer.print(",\"afterSeq\":{d},\"nextSeq\":", .{after_seq});
+    var events_json = std.ArrayList(u8).empty;
+    defer events_json.deinit(allocator);
+    const events_writer = events_json.writer(allocator);
+    var next_seq = after_seq;
     var emitted: u64 = 0;
     var lines = std.mem.splitScalar(u8, content, '\n');
     while (lines.next()) |raw_line| {
@@ -43,10 +54,13 @@ pub fn writeEventsToolResult(
         if (seq_value != .integer or seq_value.integer <= 0) continue;
         const seq = @as(u64, @intCast(seq_value.integer));
         if (seq <= after_seq) continue;
-        if (emitted > 0) try payload_writer.writeAll(",");
-        try payload_writer.writeAll(line);
+        if (emitted > 0) try events_writer.writeAll(",");
+        try events_writer.writeAll(line);
+        next_seq = seq;
         emitted += 1;
     }
+    try payload_writer.print("{d},\"latestSeq\":{d},\"events\":[", .{ next_seq, tw.event_count });
+    try payload_writer.writeAll(events_json.items);
     try payload_writer.writeAll("]}");
     try mcp_protocol.writeToolTextResult(writer, id, payload.items);
 }
@@ -81,3 +95,111 @@ pub fn writeExportToolResult(
     try payload_writer.print(",\"redacted\":{},\"omitScreenshots\":{}}}", .{ redact, omit_screenshots });
     try mcp_protocol.writeToolTextResult(writer, id, payload.items);
 }
+
+pub fn writeExplainToolResult(
+    allocator: std.mem.Allocator,
+    writer: anytype,
+    id: ?std.json.Value,
+    live_trace: ?*trace.TraceWriter,
+) !void {
+    const tw = live_trace orelse {
+        try mcp_protocol.writeToolTextResult(writer, id, "{\"traceDir\":null,\"message\":\"start zmr mcp with --trace-dir to enable live trace explanation\"}");
+        return;
+    };
+
+    try tw.flushManifest();
+    var payload = std.ArrayList(u8).empty;
+    defer payload.deinit(allocator);
+    try report.writeTraceExplanationJson(allocator, tw.root_dir, payload.writer(allocator));
+    try mcp_protocol.writeToolTextResult(writer, id, std.mem.trimRight(u8, payload.items, " \t\r\n"));
+    try tw.recordEvent("trace.explain", "{\"status\":\"ok\"}");
+}
+
+pub fn writeDiscoverToolResult(
+    allocator: std.mem.Allocator,
+    writer: anytype,
+    id: ?std.json.Value,
+    live_trace: ?*trace.TraceWriter,
+    out_path: []const u8,
+    include_actions: bool,
+    validate: bool,
+    force: bool,
+    name: ?[]const u8,
+    app_id: ?[]const u8,
+) !void {
+    const tw = live_trace orelse {
+        try mcp_protocol.writeToolTextResult(writer, id, "{\"ok\":false,\"mode\":\"discover\",\"traceDir\":null,\"message\":\"start zmr mcp with --trace-dir to enable live trace discovery\"}");
+        return;
+    };
+
+    try tw.flushManifest();
+    var discovered = try cli_discover.discoverFromTrace(allocator, .{
+        .from_trace = tw.root_dir,
+        .out_path = out_path,
+        .name = name,
+        .app_id = app_id,
+        .include_actions = include_actions,
+        .validate = validate,
+        .force = force,
+        .json = true,
+    });
+    defer discovered.deinit(allocator);
+    try runner_events.recordTraceDiscover(
+        tw,
+        if (discovered.summary.ok) "ok" else "failed",
+        discovered.summary.draft.out_path,
+        include_actions,
+        discovered.summary.validated,
+    );
+
+    var payload = std.ArrayList(u8).empty;
+    defer payload.deinit(allocator);
+    try cli_discover.writeJson(payload.writer(allocator), discovered.summary, discovered.validation);
+    try mcp_protocol.writeToolTextResult(writer, id, std.mem.trimRight(u8, payload.items, " \t\r\n"));
+}
+
+pub fn writeExploreToolResult(
+    allocator: std.mem.Allocator,
+    writer: anytype,
+    id: ?std.json.Value,
+    live_trace: ?*trace.TraceWriter,
+    out_path: []const u8,
+    goal: []const u8,
+    include_actions: bool,
+    validate: bool,
+    force: bool,
+    name: ?[]const u8,
+    app_id: ?[]const u8,
+) !void {
+    const tw = live_trace orelse {
+        try mcp_protocol.writeToolTextResult(writer, id, "{\"ok\":false,\"mode\":\"explore\",\"traceDir\":null,\"message\":\"start zmr mcp with --trace-dir to enable live trace exploration\"}");
+        return;
+    };
+
+    try tw.flushManifest();
+    var explored = try cli_explore.exploreFromTrace(allocator, .{
+        .from_trace = tw.root_dir,
+        .out_path = out_path,
+        .goal = goal,
+        .name = name,
+        .app_id = app_id,
+        .include_actions = include_actions,
+        .validate = validate,
+        .force = force,
+        .json = true,
+    });
+    defer explored.deinit(allocator);
+    try runner_events.recordTraceExplore(
+        tw,
+        if (explored.summary.ok) "ok" else "failed",
+        explored.discovered.summary.draft.out_path,
+        goal,
+        include_actions,
+        explored.discovered.summary.validated,
+    );
+
+    var payload = std.ArrayList(u8).empty;
+    defer payload.deinit(allocator);
+    try cli_explore.writeJson(payload.writer(allocator), explored.summary, explored.discovered.summary, explored.discovered.validation);
+    try mcp_protocol.writeToolTextResult(writer, id, std.mem.trimRight(u8, payload.items, " \t\r\n"));
+}

package/src/report.zig

@@ -22,6 +22,23 @@ pub fn writeHtmlReport(
     }
 }
 
+pub fn writeJUnitReport(
+    allocator: std.mem.Allocator,
+    input_path: []const u8,
+    out_path: []const u8,
+) !void {
+    const results_path = try std.fs.path.join(allocator, &.{ input_path, "results.jsonl" });
+    defer allocator.free(results_path);
+
+    if (std.fs.cwd().openFile(results_path, .{})) |file| {
+        file.close();
+        return try writeBenchmarkJUnitReport(allocator, input_path, results_path, out_path);
+    } else |err| switch (err) {
+        error.FileNotFound => return try writeTraceJUnitReport(allocator, input_path, out_path),
+        else => return err,
+    }
+}
+
 pub fn writeTraceExplanation(
     allocator: std.mem.Allocator,
     trace_dir: []const u8,
@@ -151,6 +168,8 @@ fn writeTraceExplanationNextCommandsJson(writer: anytype, trace_dir: []const u8)
     try cli_output.writeShellArgJsonContent(writer, trace_dir);
     try writer.writeAll(" --out ");
     try cli_output.writeJoinedPathShellArgJsonContent(writer, trace_dir, "report.html");
+    try writer.writeAll(" --junit ");
+    try cli_output.writeJoinedPathShellArgJsonContent(writer, trace_dir, "junit.xml");
     try writer.writeAll("\",\"zmr export ");
     try cli_output.writeShellArgJsonContent(writer, trace_dir);
     try writer.writeAll(" --out ");
@@ -260,6 +279,89 @@ fn writeBenchmarkReport(
     try report_html.writeFile(out_path, html.items);
 }
 
+fn writeBenchmarkJUnitReport(
+    allocator: std.mem.Allocator,
+    input_path: []const u8,
+    results_path: []const u8,
+    out_path: []const u8,
+) !void {
+    const content = try std.fs.cwd().readFileAlloc(allocator, results_path, 64 * 1024 * 1024);
+    defer allocator.free(content);
+
+    var cases_xml = std.ArrayList(u8).empty;
+    defer cases_xml.deinit(allocator);
+
+    var total: usize = 0;
+    var failed: usize = 0;
+    var total_duration_ms: i64 = 0;
+
+    var lines = std.mem.splitScalar(u8, content, '\n');
+    while (lines.next()) |raw_line| {
+        const line = std.mem.trim(u8, raw_line, " \t\r\n");
+        if (line.len == 0) continue;
+
+        const parsed = try std.json.parseFromSlice(std.json.Value, allocator, line, .{});
+        defer parsed.deinit();
+        if (parsed.value != .object) continue;
+        const object = parsed.value.object;
+
+        const tool = report_values.stringField(object, "tool") orelse "zmr";
+        const status = report_values.stringField(object, "status") orelse "";
+        const trace_status = report_values.stringField(object, "traceStatus") orelse "";
+        const trace_error = report_values.stringField(object, "traceError") orelse "";
+        const trace_dir = report_values.stringField(object, "traceDir") orelse "";
+        const run = report_values.intField(object, "run") orelse @as(i64, @intCast(total + 1));
+        const duration_ms = report_values.intField(object, "durationMs") orelse 0;
+        const failed_step = report_values.intField(object, "failedStepIndex");
+        const row_passed = std.mem.eql(u8, status, "ok") and (trace_status.len == 0 or std.mem.eql(u8, trace_status, "passed"));
+
+        total += 1;
+        if (!row_passed) failed += 1;
+        if (duration_ms > 0) total_duration_ms += duration_ms;
+
+        const writer = cases_xml.writer(allocator);
+        try writer.writeAll("  <testcase classname=\"");
+        try report_html.escape(writer, tool);
+        try writer.writeAll("\" name=\"run ");
+        try writer.print("{d}", .{run});
+        try writer.writeAll("\" time=\"");
+        try writeSeconds(writer, duration_ms);
+        try writer.writeAll("\">");
+        if (!row_passed) {
+            const message = if (trace_error.len > 0) trace_error else if (trace_status.len > 0) trace_status else status;
+            try writer.writeAll("<failure message=\"");
+            try report_html.escape(writer, message);
+            try writer.writeAll("\" type=\"ZMRFailure\">");
+            if (failed_step) |index| try writer.print("failedStepIndex={d}", .{index});
+            if (trace_dir.len > 0) {
+                if (failed_step != null) try writer.writeAll(" ");
+                try writer.writeAll("traceDir=");
+                try report_html.escape(writer, trace_dir);
+            }
+            try writer.writeAll("</failure>");
+        }
+        try writer.writeAll("</testcase>\n");
+    }
+
+    var xml = std.ArrayList(u8).empty;
+    defer xml.deinit(allocator);
+    const writer = xml.writer(allocator);
+    try writeJUnitHeader(writer);
+    try writer.writeAll("<testsuite name=\"ZMR Benchmark\" tests=\"");
+    try writer.print("{d}", .{total});
+    try writer.writeAll("\" failures=\"");
+    try writer.print("{d}", .{failed});
+    try writer.writeAll("\" errors=\"0\" skipped=\"0\" time=\"");
+    try writeSeconds(writer, total_duration_ms);
+    try writer.writeAll("\">\n");
+    try writer.writeAll("  <properties>\n");
+    try writeJUnitProperty(writer, "source", input_path);
+    try writer.writeAll("  </properties>\n");
+    try writer.writeAll(cases_xml.items);
+    try writer.writeAll("</testsuite>\n");
+    try report_html.writeFile(out_path, xml.items);
+}
+
 fn writeTraceReport(
     allocator: std.mem.Allocator,
     input_path: []const u8,
@@ -344,3 +446,87 @@ fn writeTraceReport(
     defer allocator.free(relative_report_path);
     try trace.attachReportPath(allocator, input_path, relative_report_path);
 }
+
+fn writeTraceJUnitReport(
+    allocator: std.mem.Allocator,
+    input_path: []const u8,
+    out_path: []const u8,
+) !void {
+    var summary = try trace_summary.read(allocator, input_path);
+    defer summary.deinit(allocator);
+
+    const failed = !isPassedStatus(summary.status);
+    var xml = std.ArrayList(u8).empty;
+    defer xml.deinit(allocator);
+    const writer = xml.writer(allocator);
+
+    try writeJUnitHeader(writer);
+    try writer.writeAll("<testsuite name=\"ZMR\" tests=\"1\" failures=\"");
+    try writer.writeAll(if (failed) "1" else "0");
+    try writer.writeAll("\" errors=\"0\" skipped=\"0\" time=\"");
+    try writeSeconds(writer, summary.duration_ms orelse 0);
+    try writer.writeAll("\">\n");
+    try writer.writeAll("  <properties>\n");
+    try writeJUnitProperty(writer, "traceDir", input_path);
+    try writeJUnitProperty(writer, "status", summary.status);
+    if (summary.event_count) |value| try writeJUnitIntProperty(writer, "eventCount", value);
+    if (summary.snapshot_count) |value| try writeJUnitIntProperty(writer, "snapshotCount", value);
+    if (summary.failed_step_index) |value| try writeJUnitIntProperty(writer, "failedStepIndex", value);
+    try writer.writeAll("  </properties>\n");
+
+    try writer.writeAll("  <testcase classname=\"");
+    try report_html.escape(writer, summary.app_id orelse "zmr");
+    try writer.writeAll("\" name=\"");
+    try report_html.escape(writer, summary.scenario_name);
+    try writer.writeAll("\" time=\"");
+    try writeSeconds(writer, summary.duration_ms orelse 0);
+    try writer.writeAll("\">");
+    if (failed) {
+        const message = summary.error_name orelse summary.status;
+        const failure_type = summary.error_name orelse "ZMRFailure";
+        try writer.writeAll("<failure message=\"");
+        try report_html.escape(writer, message);
+        try writer.writeAll("\" type=\"");
+        try report_html.escape(writer, failure_type);
+        try writer.writeAll("\">");
+        if (summary.failed_step_index) |index| {
+            try writer.print("failedStepIndex={d}", .{index});
+        } else {
+            try writer.writeAll("status=");
+            try report_html.escape(writer, summary.status);
+        }
+        try writer.writeAll("</failure>");
+    }
+    try writer.writeAll("</testcase>\n");
+    try writer.writeAll("</testsuite>\n");
+    try report_html.writeFile(out_path, xml.items);
+}
+
+fn isPassedStatus(status: []const u8) bool {
+    return std.mem.eql(u8, status, "passed");
+}
+
+fn writeJUnitHeader(writer: anytype) !void {
+    try writer.writeAll("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
+}
+
+fn writeJUnitProperty(writer: anytype, name: []const u8, value: []const u8) !void {
+    try writer.writeAll("    <property name=\"");
+    try report_html.escape(writer, name);
+    try writer.writeAll("\" value=\"");
+    try report_html.escape(writer, value);
+    try writer.writeAll("\"/>\n");
+}
+
+fn writeJUnitIntProperty(writer: anytype, name: []const u8, value: i64) !void {
+    try writer.writeAll("    <property name=\"");
+    try report_html.escape(writer, name);
+    try writer.writeAll("\" value=\"");
+    try writer.print("{d}", .{value});
+    try writer.writeAll("\"/>\n");
+}
+
+fn writeSeconds(writer: anytype, duration_ms: i64) !void {
+    const safe_ms = @max(duration_ms, 0);
+    try writer.print("{d}.{d:0>3}", .{ @divTrunc(safe_ms, 1000), @mod(safe_ms, 1000) });
+}

package/src/runner.zig

@@ -102,6 +102,7 @@ pub fn executeStep(
         },
         .press_back => {
             try device.pressBack();
+            if (writer) |tw| try tw.recordEvent("ui.pressBack", "{\"status\":\"ok\"}");
             try settleDevice(device, options);
         },
         .hide_keyboard => {
@@ -111,6 +112,7 @@ pub fn executeStep(
         },
         .swipe => |swipe| {
             try device.swipe(swipe.x1, swipe.y1, swipe.x2, swipe.y2, swipe.duration_ms);
+            if (writer) |tw| try runner_events.recordSwipe(tw, swipe.x1, swipe.y1, swipe.x2, swipe.y2, swipe.duration_ms);
             try settleDevice(device, options);
         },
         .wait_visible => |wait| {
@@ -122,11 +124,11 @@ pub fn executeStep(
         .wait_any => |wait| {
             if (try waitUntilAnyVisible(device, wait.selectors, wait.timeout_ms, writer, options) == null) return error.WaitTimeout;
         },
-        .assert_visible => |wanted| {
-            if (!try waitUntilVisible(device, wanted, options.default_timeout_ms, writer, options)) return error.AssertionFailed;
+        .assert_visible => |assertion| {
+            if (!try assertVisible(device, assertion.selector, assertion.timeout_ms orelse options.default_timeout_ms, writer, options)) return error.AssertionFailed;
         },
-        .assert_not_visible => |wanted| {
-            if (!try waitUntilNotVisible(device, wanted, options.default_timeout_ms, writer, options)) return error.AssertionFailed;
+        .assert_not_visible => |assertion| {
+            if (!try assertNotVisible(device, assertion.selector, assertion.timeout_ms orelse options.default_timeout_ms, writer, options)) return error.AssertionFailed;
         },
         .assert_none_visible => |assertion| {
             if (!try assertNoneVisible(device, assertion.selectors, assertion.timeout_ms, writer, options)) return error.AssertionFailed;
@@ -231,6 +233,26 @@ pub fn waitUntilAnyVisible(
     return try runner_waits.waitUntilAnyVisible(device, selectors, timeout_ms, writer, options);
 }
 
+pub fn assertVisible(
+    device: anytype,
+    wanted: selector.Selector,
+    timeout_ms: u64,
+    writer: ?*trace.TraceWriter,
+    options: RunOptions,
+) !bool {
+    return try runner_waits.assertVisible(device, wanted, timeout_ms, writer, options);
+}
+
+pub fn assertNotVisible(
+    device: anytype,
+    wanted: selector.Selector,
+    timeout_ms: u64,
+    writer: ?*trace.TraceWriter,
+    options: RunOptions,
+) !bool {
+    return try runner_waits.assertNotVisible(device, wanted, timeout_ms, writer, options);
+}
+
 pub fn assertNoneVisible(
     device: anytype,
     selectors: []const selector.Selector,

package/src/runner_actions.zig

@@ -61,6 +61,16 @@ pub fn typeTextSelector(
     if (try runner_native.tryTypeTextSelector(device, wanted, text, writer, options.settle_ms)) return;
     try tapSelector(device, wanted, writer, options);
     try device.typeText(text);
+    if (writer) |tw| {
+        var payload = std.ArrayList(u8).empty;
+        defer payload.deinit(tw.allocator);
+        try payload.writer(tw.allocator).writeAll("{\"status\":\"ok\",\"selector\":");
+        try trace.writeSelectorJson(payload.writer(tw.allocator), wanted);
+        try payload.writer(tw.allocator).writeAll(",\"text\":");
+        try trace.writeJsonString(payload.writer(tw.allocator), text);
+        try payload.writer(tw.allocator).writeAll("}");
+        try tw.recordEvent("ui.type", payload.items);
+    }
     try settleDevice(device, options);
 }
 

package/src/runner_diagnostics.zig

@@ -10,10 +10,26 @@ pub fn record(
     strategy: ?[]const u8,
     selectors: []const selector.Selector,
     snap: types.ObservationSnapshot,
+) !void {
+    try recordWithOptions(tw, kind, status, strategy, selectors, snap, .{});
+}
+
+pub const DiagnosticOptions = struct {
+    timeout_ms: ?u64 = null,
+};
+
+pub fn recordWithOptions(
+    tw: *trace.TraceWriter,
+    kind: []const u8,
+    status: []const u8,
+    strategy: ?[]const u8,
+    selectors: []const selector.Selector,
+    snap: types.ObservationSnapshot,
+    options: DiagnosticOptions,
 ) !void {
     var payload = std.ArrayList(u8).empty;
     defer payload.deinit(tw.allocator);
-    try writeSelectorDiagnosticJson(payload.writer(tw.allocator), status, strategy, selectors, snap);
+    try writeSelectorDiagnosticJsonWithOptions(payload.writer(tw.allocator), status, strategy, selectors, snap, options);
     try tw.recordEvent(kind, payload.items);
 }
 
@@ -23,12 +39,26 @@ pub fn writeSelectorDiagnosticJson(
     strategy: ?[]const u8,
     selectors: []const selector.Selector,
     snap: types.ObservationSnapshot,
+) !void {
+    try writeSelectorDiagnosticJsonWithOptions(writer, status, strategy, selectors, snap, .{});
+}
+
+pub fn writeSelectorDiagnosticJsonWithOptions(
+    writer: anytype,
+    status: []const u8,
+    strategy: ?[]const u8,
+    selectors: []const selector.Selector,
+    snap: types.ObservationSnapshot,
+    options: DiagnosticOptions,
 ) !void {
     try writer.print("{{\"status\":\"{s}\"", .{status});
     if (strategy) |value| {
         try writer.writeAll(",\"strategy\":");
         try trace.writeJsonString(writer, value);
     }
+    if (options.timeout_ms) |timeout_ms| {
+        try writer.print(",\"timeoutMs\":{d}", .{timeout_ms});
+    }
     try writer.print(",\"snapshotId\":\"{s}\",\"selectors\":[", .{snap.id});
     for (selectors, 0..) |wanted, index| {
         if (index > 0) try writer.writeAll(",");

package/src/runner_events.zig

@@ -13,21 +13,21 @@ pub fn eventString(allocator: std.mem.Allocator, value: []const u8) ![]const u8
     return try buffer.toOwnedSlice(allocator);
 }
 
-pub fn recordNativeWait(tw: *trace.TraceWriter, kind: []const u8, wanted: selector.Selector, matched_index: ?usize) !void {
+pub fn recordNativeWait(tw: *trace.TraceWriter, kind: []const u8, wanted: selector.Selector, matched_index: ?usize, timeout_ms: u64) !void {
     var payload = std.ArrayList(u8).empty;
     defer payload.deinit(tw.allocator);
     try payload.writer(tw.allocator).writeAll("{\"status\":\"ok\",\"strategy\":\"nativeSelector\"");
     if (matched_index) |index| try payload.writer(tw.allocator).print(",\"matchedIndex\":{d}", .{index});
     try payload.writer(tw.allocator).writeAll(",\"selector\":");
     try trace.writeSelectorJson(payload.writer(tw.allocator), wanted);
-    try payload.writer(tw.allocator).writeAll("}");
+    try payload.writer(tw.allocator).print(",\"timeoutMs\":{d}}}", .{timeout_ms});
     try tw.recordEvent(kind, payload.items);
 }
 
-pub fn recordNativeWaitTimeout(tw: *trace.TraceWriter, kind: []const u8, selectors: []const selector.Selector) !void {
+pub fn recordNativeWaitTimeout(tw: *trace.TraceWriter, kind: []const u8, selectors: []const selector.Selector, timeout_ms: u64) !void {
     var payload = std.ArrayList(u8).empty;
     defer payload.deinit(tw.allocator);
-    try payload.writer(tw.allocator).writeAll("{\"status\":\"timeout\",\"strategy\":\"nativeSelector\",\"selectors\":[");
+    try payload.writer(tw.allocator).print("{{\"status\":\"timeout\",\"strategy\":\"nativeSelector\",\"timeoutMs\":{d},\"selectors\":[", .{timeout_ms});
     for (selectors, 0..) |wanted, index| {
         if (index > 0) try payload.writer(tw.allocator).writeAll(",");
         try trace.writeSelectorJson(payload.writer(tw.allocator), wanted);
@@ -36,13 +36,28 @@ pub fn recordNativeWaitTimeout(tw: *trace.TraceWriter, kind: []const u8, selecto
     try tw.recordEvent(kind, payload.items);
 }
 
-pub fn recordNativeWaitTimeoutWithDiagnostics(device: anytype, tw: *trace.TraceWriter, kind: []const u8, selectors: []const selector.Selector) !void {
+pub fn recordNativeWaitTimeoutWithDiagnostics(device: anytype, tw: *trace.TraceWriter, kind: []const u8, selectors: []const selector.Selector, timeout_ms: u64) !void {
     var snap = device.snapshot(tw) catch {
-        try recordNativeWaitTimeout(tw, kind, selectors);
+        try recordNativeWaitTimeout(tw, kind, selectors, timeout_ms);
         return;
     };
     defer snap.deinit(device.allocator);
-    try recordDiagnosticWithStrategy(tw, kind, "timeout", "nativeSelector", selectors, snap);
+    try recordDiagnosticWithStrategyAndTimeout(tw, kind, "timeout", "nativeSelector", selectors, snap, timeout_ms);
+}
+
+pub fn recordSelectorArrayStatus(tw: *trace.TraceWriter, kind: []const u8, status: []const u8, selectors: []const selector.Selector, timeout_ms: u64) !void {
+    var payload = std.ArrayList(u8).empty;
+    defer payload.deinit(tw.allocator);
+    const out = payload.writer(tw.allocator);
+    try out.writeAll("{\"status\":");
+    try trace.writeJsonString(out, status);
+    try out.writeAll(",\"selectors\":[");
+    for (selectors, 0..) |wanted, index| {
+        if (index > 0) try out.writeAll(",");
+        try trace.writeSelectorJson(out, wanted);
+    }
+    try out.print("],\"timeoutMs\":{d}}}", .{timeout_ms});
+    try tw.recordEvent(kind, payload.items);
 }
 
 pub fn recordSelectorEvent(tw: *trace.TraceWriter, kind: []const u8, wanted: selector.Selector) !void {
@@ -72,6 +87,42 @@ pub fn recordActionStatus(tw: *trace.TraceWriter, kind: []const u8, status: []co
     try tw.recordEvent(kind, payload.items);
 }
 
+pub fn recordSwipe(tw: *trace.TraceWriter, x1: i32, y1: i32, x2: i32, y2: i32, duration_ms: u32) !void {
+    const payload = try std.fmt.allocPrint(
+        tw.allocator,
+        "{{\"status\":\"ok\",\"x1\":{d},\"y1\":{d},\"x2\":{d},\"y2\":{d},\"durationMs\":{d}}}",
+        .{ x1, y1, x2, y2, duration_ms },
+    );
+    defer tw.allocator.free(payload);
+    try tw.recordEvent("ui.swipe", payload);
+}
+
+pub fn recordTraceDiscover(tw: *trace.TraceWriter, status: []const u8, out_path: []const u8, include_actions: bool, validated: bool) !void {
+    var payload = std.ArrayList(u8).empty;
+    defer payload.deinit(tw.allocator);
+    const out = payload.writer(tw.allocator);
+    try out.writeAll("{\"status\":");
+    try trace.writeJsonString(out, status);
+    try out.writeAll(",\"out\":");
+    try trace.writeJsonString(out, out_path);
+    try out.print(",\"includeActions\":{},\"validated\":{}}}", .{ include_actions, validated });
+    try tw.recordEvent("trace.discover", payload.items);
+}
+
+pub fn recordTraceExplore(tw: *trace.TraceWriter, status: []const u8, out_path: []const u8, goal: []const u8, include_actions: bool, validated: bool) !void {
+    var payload = std.ArrayList(u8).empty;
+    defer payload.deinit(tw.allocator);
+    const out = payload.writer(tw.allocator);
+    try out.writeAll("{\"status\":");
+    try trace.writeJsonString(out, status);
+    try out.writeAll(",\"out\":");
+    try trace.writeJsonString(out, out_path);
+    try out.writeAll(",\"goal\":");
+    try trace.writeJsonString(out, goal);
+    try out.print(",\"includeActions\":{},\"validated\":{}}}", .{ include_actions, validated });
+    try tw.recordEvent("trace.explore", payload.items);
+}
+
 pub fn recordStepError(tw: *trace.TraceWriter, index: usize, err: anyerror) !void {
     const payload = try std.fmt.allocPrint(
         tw.allocator,
@@ -159,6 +210,18 @@ pub fn recordDiagnosticWithStrategy(
     try runner_diagnostics.record(tw, kind, status, strategy, selectors, snap);
 }
 
+pub fn recordDiagnosticWithStrategyAndTimeout(
+    tw: *trace.TraceWriter,
+    kind: []const u8,
+    status: []const u8,
+    strategy: ?[]const u8,
+    selectors: []const selector.Selector,
+    snap: types.ObservationSnapshot,
+    timeout_ms: u64,
+) !void {
+    try runner_diagnostics.recordWithOptions(tw, kind, status, strategy, selectors, snap, .{ .timeout_ms = timeout_ms });
+}
+
 pub fn writeSelectorDiagnosticJson(
     writer: anytype,
     status: []const u8,

package/src/runner_native.zig

@@ -32,7 +32,7 @@ pub fn tryTypeTextSelector(
         return err;
     };
     if (!typed) return false;
-    if (writer) |tw| try recordSelectorAction(tw, "ui.type", wanted, null);
+    if (writer) |tw| try recordSelectorTextAction(tw, "ui.type", wanted, text);
     try device.settle(settle_ms);
     return true;
 }
@@ -70,6 +70,22 @@ fn recordSelectorAction(
     try tw.recordEvent(kind, payload.items);
 }
 
+fn recordSelectorTextAction(
+    tw: *trace.TraceWriter,
+    kind: []const u8,
+    wanted: selector.Selector,
+    text: []const u8,
+) !void {
+    var payload = std.ArrayList(u8).empty;
+    defer payload.deinit(tw.allocator);
+    try payload.writer(tw.allocator).writeAll("{\"status\":\"ok\",\"strategy\":\"nativeSelector\",\"selector\":");
+    try trace.writeSelectorJson(payload.writer(tw.allocator), wanted);
+    try payload.writer(tw.allocator).writeAll(",\"text\":");
+    try trace.writeJsonString(payload.writer(tw.allocator), text);
+    try payload.writer(tw.allocator).writeAll("}");
+    try tw.recordEvent(kind, payload.items);
+}
+
 fn recordSelectorActionFailure(
     tw: *trace.TraceWriter,
     kind: []const u8,