@mmerterden/multi-agent-pipeline 20.27.1 → 20.28.0

package/pipeline/scripts/_worktree-snapshot.mjs

@@ -0,0 +1,113 @@
+/**
+ * @file _worktree-snapshot.mjs  -  the working tree as a git tree, and diffs between snapshots.
+ *
+ * A stage that may edit the repository is judged by what IT changed, not by
+ * everything that differs from HEAD: the person's own uncommitted work was
+ * there before the stage started, and an audit that reads it as the stage's
+ * change would tell the agent to revert it. `snapshotTree` records the whole
+ * working tree (tracked and untracked files, ignored files excluded) as a git
+ * tree object through a throwaway index, so neither the working tree nor the
+ * real index is touched. `treeDiff` diffs two such trees, or a commit and a
+ * tree.
+ *
+ * Every ref a caller passes is checked with `rev-parse --verify` and placed
+ * after `--end-of-options`, so a value starting with `-` is never read as an
+ * option. Every diff carries explicit `a/` `b/` prefixes, so a user's
+ * `diff.noprefix` or `diff.mnemonicPrefix` setting cannot change the paths the
+ * parser reads.
+ *
+ * @module pipeline/scripts/_worktree-snapshot
+ */
+
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+export class GitError extends Error {}
+
+/** Run git in `repo`; throws GitError with git's first stderr line on failure. */
+export function git(repo, args, env = {}) {
+  const r = spawnSync("git", ["-C", repo, ...args], {
+    encoding: "utf8",
+    maxBuffer: 256 * 1024 * 1024,
+    timeout: 120000,
+    env: { ...process.env, ...env },
+  });
+  if (r.status !== 0) {
+    const why = (r.stderr || r.error?.message || `exit ${r.status}`).trim().split("\n")[0];
+    throw new GitError(`git ${args.find((a) => !a.startsWith("-")) || ""} failed: ${why}`);
+  }
+  return r.stdout;
+}
+
+/** A value an option was given, refused when it is missing or looks like another option. */
+export function optionValue(name, value) {
+  if (typeof value !== "string" || value === "" || value.startsWith("-")) {
+    throw new GitError(`${name} needs a value that does not start with "-"`);
+  }
+  return value;
+}
+
+/** The commit `ref` names, as a full sha. */
+export function verifyCommit(repo, ref) {
+  optionValue("ref", ref);
+  return git(repo, [
+    "rev-parse",
+    "--verify",
+    "--quiet",
+    "--end-of-options",
+    `${ref}^{commit}`,
+  ]).trim();
+}
+
+/** The working tree, tracked and untracked, as a tree object sha. */
+export function snapshotTree(repo) {
+  const dir = mkdtempSync(join(tmpdir(), "ma-snapshot-"));
+  const env = { GIT_INDEX_FILE: join(dir, "index") };
+  try {
+    let hasHead = true;
+    try {
+      git(repo, ["rev-parse", "--verify", "--quiet", "HEAD"]);
+    } catch {
+      hasHead = false;
+    }
+    if (hasHead) git(repo, ["read-tree", "HEAD"], env);
+    git(repo, ["add", "-A", "--", "."], env);
+    return git(repo, ["write-tree"], env).trim();
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+/** Unified diff (-U0) from one tree-ish to another, renames off so moves read as delete + add. */
+export function treeDiff(repo, from, to) {
+  return git(repo, [
+    "diff-tree",
+    "-p",
+    "-r",
+    "-U0",
+    "--no-color",
+    "--no-ext-diff",
+    "--no-renames",
+    "--src-prefix=a/",
+    "--dst-prefix=b/",
+    "--end-of-options",
+    from,
+    to,
+  ]);
+}
+
+/** What changed in the working tree since the snapshot `fromTree` was taken. */
+export function diffSince(repo, fromTree) {
+  optionValue("snapshot", fromTree);
+  git(repo, ["cat-file", "-e", "--end-of-options", `${fromTree}^{tree}`]);
+  return treeDiff(repo, fromTree, snapshotTree(repo));
+}
+
+/** The working tree (untracked files included) against the merge base of HEAD and `base`. */
+export function diffFromMergeBase(repo, base) {
+  const baseSha = verifyCommit(repo, base);
+  const mb = git(repo, ["merge-base", "--end-of-options", baseSha, "HEAD"]).trim();
+  return treeDiff(repo, mb, snapshotTree(repo));
+}

package/pipeline/scripts/doctor.mjs

@@ -104,6 +104,7 @@ const CHECK_IDS = [
   "disk-space",
   "worktree-residue",
   "usage-report",
+  "usage-register",
   "free-models",
   "xcode-skills",
 ];
@@ -936,6 +937,55 @@ function checkUsageReport() {
   );
 }
 
+// usage-register.mjs runs quietly from setup, update and Phase 0, so the record
+// of its last attempt, and of the failure report it may have sent, is where a
+// machine that never registers shows why.
+const REGISTER_FINE = new Set(["registered", "registered-feedback-only", "enabled"]);
+const REGISTER_QUIET = new Set([
+  "token in environment",
+  "token in prefs",
+  "token already onboarded",
+]);
+
+function beaconSummary(beacon) {
+  const last = beacon?.last;
+  if (!last || typeof last.outcome !== "string") return "no failure report was sent";
+  const when = last.t ? ` at ${last.t}` : "";
+  return last.outcome === "sent"
+    ? `the failure report (${last.reason}) reached the site${when}`
+    : `the failure report (${last.reason}) could not be delivered${when}`;
+}
+
+function checkUsageRegister() {
+  const prefs = readJson(join(CLAUDE, "multi-agent-preferences.json"));
+  if (prefs?.global?.usageLog?.optOut === true) {
+    skip("usage-register", "usage reporting is opted out");
+    return;
+  }
+  const logs = join(CLAUDE, "logs", "multi-agent");
+  const last = readJson(join(logs, "usage-last-register.json"));
+  if (!last || typeof last.status !== "string") {
+    skip("usage-register", "no registration has been attempted on this machine yet");
+    return;
+  }
+  if (
+    REGISTER_FINE.has(last.status) ||
+    (last.status === "skipped" && REGISTER_QUIET.has(last.detail))
+  ) {
+    ok("usage-register");
+    return;
+  }
+  const beacon = beaconSummary(readJson(join(logs, "usage-register-beacon.json")));
+  const when = last.t ? ` at ${last.t}` : "";
+  const detail = last.detail ? ` (${last.detail})` : "";
+  report(
+    "usage-register",
+    "WARN",
+    `the last usage registration${when} was ${last.status}${detail}; ${beacon}`,
+    `run node ${join(HERE, "usage-register.mjs")} --refresh`,
+  );
+}
+
 // route-on --free promises that simple tasks leave Claude. With no usable
 // provider every one of them silently escalates back, which costs nothing but
 // saves nothing either - the user believes a control is working that is not.
@@ -1362,6 +1412,7 @@ function main() {
   checkDiskSpace();
   checkWorktreeResidue();
   checkUsageReport();
+  checkUsageRegister();
   checkFreeModels();
   checkXcodeSkills();
   if (PROFILE === "server") checkServerProfile(resolved);

package/pipeline/scripts/evidence-gate.mjs

@@ -12,11 +12,23 @@
 //   node pipeline/scripts/evidence-gate.mjs --claim test  --status passed --evidence test.log \
 //        --success-pattern 'All tests passed' --failure-pattern 'FAILED'
 //   node pipeline/scripts/evidence-gate.mjs --claim manual --status passed --evidence manual-test.json
+//   node pipeline/scripts/evidence-gate.mjs --claim artefact --status passed --evidence gaps.json \
+//        --stage-start 2026-10-23T09:00:00Z
 //
 // Flags:
-//   --claim            build | test | review | manual
+//   --claim            build | test | review | manual | artefact
 //                      build/test/review select default success/failure markers;
-//                      manual is JSON-based (Phase 5 manual-test.json, see below)
+//                      manual is JSON-based (Phase 5 manual-test.json, see below);
+//                      artefact is a stage's own output file, judged only by
+//                      --stage-start (required with it)
+//   --stage-start <t>  ISO time or epoch (ms, or seconds) the stage started.
+//                      The evidence must be this stage's own file, written
+//                      during it and whole: an mtime earlier than the start
+//                      less 2s of clock slack is another stage's (or an old
+//                      run's) file. A .json file is whole when it parses; any
+//                      other file under 400 bytes, or ending in a letter or
+//                      digit with no trailing newline, is partial, cut off
+//                      mid-write. Applies to every claim when given.
 //   --status           the claimed status (only "passed" is gated; others pass through)
 //   --evidence <path>  the log / artifact that must substantiate a "passed" claim
 //   --require-screenshot  manual claim only: every "pass" criterion must name a
@@ -93,7 +105,54 @@ const DEFAULT_MARKERS = {
 };
 
 const JSON_CLAIMS = new Set(["manual"]);
-const CLAIMS = [...Object.keys(DEFAULT_MARKERS), ...JSON_CLAIMS];
+const ARTEFACT_CLAIM = "artefact";
+const CLAIMS = [...Object.keys(DEFAULT_MARKERS), ...JSON_CLAIMS, ARTEFACT_CLAIM];
+
+const STAGE_SLACK_MS = 2000;
+const PARTIAL_UNDER_BYTES = 400;
+
+/** --stage-start as epoch ms: ISO, epoch ms, or epoch seconds. */
+function stageStartMs(value) {
+  if (value === undefined) return null;
+  const s = String(value).trim();
+  if (/^\d+(\.\d+)?$/.test(s)) {
+    const n = Number(s);
+    return n < 1e12 ? n * 1000 : n;
+  }
+  const t = Date.parse(s);
+  if (value === true || Number.isNaN(t)) usage(`--stage-start is not a time: ${value}`);
+  return t;
+}
+
+/**
+ * Is this the stage's own, whole file? Returns the reason it is not, or null.
+ *
+ * @param {string} path
+ * @param {Buffer} raw
+ * @param {number} startMs
+ */
+function stageArtefactProblem(path, raw, startMs) {
+  const mtime = statSync(path).mtimeMs;
+  if (mtime < startMs - STAGE_SLACK_MS) {
+    return `written ${new Date(mtime).toISOString()}, before the stage started (${new Date(startMs).toISOString()}); not this stage's output`;
+  }
+  if (/\.json$/i.test(path)) {
+    try {
+      JSON.parse(raw.toString("utf8"));
+      return null;
+    } catch (err) {
+      return `partial: not valid JSON (${err.message})`;
+    }
+  }
+  if (raw.length < PARTIAL_UNDER_BYTES) {
+    return `partial: ${raw.length} bytes, under ${PARTIAL_UNDER_BYTES}`;
+  }
+  const last = raw.toString("utf8").slice(-1);
+  if (/[A-Za-z0-9]/.test(last)) {
+    return "partial: ends mid-token, with no trailing newline";
+  }
+  return null;
+}
 const MANUAL_VERDICTS = new Set(["pass", "fail", "not-tested"]);
 
 const MAX_PATTERN_LEN = 200;
@@ -291,6 +350,10 @@ if (typeof status !== "string") {
 }
 ledgerClaim = claim;
 ledgerState = typeof args.state === "string" ? args.state : null;
+const stageStart = stageStartMs(args["stage-start"]);
+if (claim === ARTEFACT_CLAIM && stageStart === null) {
+  usage("--claim artefact needs --stage-start");
+}
 
 // Only a "passed" claim needs proof. failed / pending / anything else is honest
 // about not succeeding, so it passes through untouched.
@@ -336,6 +399,14 @@ if (body.trim().length === 0) {
   fail(`${claim} claims passed but evidence file is blank: ${evidence} (default-FAIL)`);
 }
 
+if (stageStart !== null) {
+  const problem = stageArtefactProblem(evidence, readFileSync(evidence), stageStart);
+  if (problem) fail(`${claim} evidence ${evidence}: ${problem} (default-FAIL)`);
+  if (claim === ARTEFACT_CLAIM) {
+    ok(`${claim} ${evidence} is this stage's own output and whole`);
+  }
+}
+
 if (JSON_CLAIMS.has(claim)) {
   gateManual(claim, evidence, body, args["require-screenshot"] === true);
 }

package/pipeline/scripts/handle-diff-audit.mjs

@@ -0,0 +1,188 @@
+#!/usr/bin/env node
+/**
+ * @file handle-diff-audit.mjs  -  did the handle stage add only handles?
+ *
+ * The test-gen handle stage may change product code for one purpose: adding
+ * the automation handles a UI test finds elements by (iOS
+ * accessibilityIdentifier, Compose testTag / semantics, web data-testid). A
+ * prompt that says "only add attributes" is a wish; this measures it.
+ *
+ * Per changed file, the removed lines and the added lines with their handle
+ * constructs stripped are read as ordered code tokens (_handle-patterns.mjs
+ * codeTokens: operators and punctuation kept, whitespace dropped), hunk by
+ * hunk in order. The two sequences must be equal. Re-wrapping a tag over
+ * several lines or moving a modifier onto its own line keeps them equal; a
+ * flipped comparison, a dropped `!`, swapped arguments or a deleted modifier
+ * does not. A difference is reported as:
+ *
+ *   lost       tokens the removed lines had that the added lines lack
+ *   extra      tokens the added lines carry beyond the removed ones
+ *   reordered  the same tokens in another order
+ *   new-file   a file appeared that is not a handle-constants file (string
+ *              constants, the enums or objects grouping them, imports,
+ *              comments, nothing else)
+ *   deleted-file / binary
+ *
+ * Snapshot files are listed apart: a new attribute changes a rendered
+ * snapshot, and its owners should know, but it is not a violation.
+ *
+ * What is read:
+ *   --since <tree> / --baseline <json>  only what changed after the stage-start
+ *                     snapshot (test-gen-gate.mjs baseline records its tree),
+ *                     so uncommitted work the person had before the stage is
+ *                     never read as the stage's change
+ *   --base <ref>      the working tree, untracked files included, against a
+ *                     commit (default HEAD)
+ *   --diff-file <p>   a saved unified diff
+ *
+ * Usage:
+ *   node handle-diff-audit.mjs [--repo <path>] [--since <tree> | --baseline <json> | --base <ref>]
+ *   node handle-diff-audit.mjs --diff-file <unified.diff>
+ *
+ * Output: one JSON object on stdout.
+ * Exit: 0 only handles (or nothing changed), 2 violation, 3 input unreadable
+ * (a missing or option-shaped value, an unknown ref, a failed git call)
+ *
+ * @module pipeline/scripts/handle-diff-audit
+ */
+
+import { readFileSync, writeFileSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+
+import {
+  codeTokens,
+  isHandleConstantsFile,
+  isHandleLine,
+  isSnapshotPath,
+  parseUnifiedDiff,
+  stripHandles,
+} from "./_handle-patterns.mjs";
+import {
+  GitError,
+  diffSince,
+  optionValue,
+  snapshotTree,
+  treeDiff,
+  verifyCommit,
+} from "./_worktree-snapshot.mjs";
+
+const VALUE_FLAGS = new Set(["repo", "base", "since", "baseline", "diff-file"]);
+
+function emit(result, code) {
+  writeFileSync(1, `${JSON.stringify({ ...result, code })}\n`);
+  process.exit(code);
+}
+
+function unreadable(reason) {
+  emit({ ok: false, reason }, 3);
+}
+
+function parseArgs(argv) {
+  const out = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (!a.startsWith("--")) unreadable(`unexpected argument ${a}`);
+    const key = a.slice(2);
+    if (!VALUE_FLAGS.has(key)) unreadable(`unknown option ${a}`);
+    const v = argv[i + 1];
+    if (v === undefined || v.startsWith("-"))
+      unreadable(`${a} needs a value that does not start with "-"`);
+    out[key] = v;
+    i++;
+  }
+  return out;
+}
+
+function readDiff(args) {
+  if (args["diff-file"]) {
+    try {
+      return readFileSync(args["diff-file"], "utf8");
+    } catch (err) {
+      return unreadable(`cannot read --diff-file: ${err.message}`);
+    }
+  }
+  const repo = args.repo || process.cwd();
+  try {
+    if (args.since || args.baseline) {
+      let tree = args.since;
+      if (!tree) {
+        const doc = JSON.parse(readFileSync(args.baseline, "utf8"));
+        tree = optionValue("baseline tree", doc.tree);
+      }
+      return diffSince(repo, tree);
+    }
+    const base = verifyCommit(repo, args.base || "HEAD");
+    return treeDiff(repo, base, snapshotTree(repo));
+  } catch (err) {
+    if (err instanceof GitError || err instanceof SyntaxError || err.code === "ENOENT") {
+      return unreadable(err.message);
+    }
+    throw err;
+  }
+}
+
+/** Multiset difference: tokens of `a` not covered by `b`. */
+function missing(a, b) {
+  const pool = new Map();
+  for (const t of b) pool.set(t, (pool.get(t) || 0) + 1);
+  const out = [];
+  for (const t of a) {
+    const n = pool.get(t) || 0;
+    if (n > 0) pool.set(t, n - 1);
+    else out.push(t);
+  }
+  return out;
+}
+
+export function audit(diffText) {
+  const files = [];
+  const violations = [];
+  const snapshots = [];
+  let handlesAdded = 0;
+  for (const [file, f] of parseUnifiedDiff(diffText)) {
+    if (isSnapshotPath(file)) {
+      snapshots.push(file);
+      continue;
+    }
+    const handles = f.added.filter((l) => isHandleLine(file, l)).length;
+    handlesAdded += handles;
+    files.push({ file, handles, added: f.added.length, removed: f.removed.length });
+    if (f.binary) {
+      violations.push({ file, kind: "binary", tokens: [] });
+      continue;
+    }
+    if (f.isDeleted) {
+      violations.push({ file, kind: "deleted-file", tokens: [] });
+      continue;
+    }
+    if (f.isNew) {
+      if (!isHandleConstantsFile(f.added)) violations.push({ file, kind: "new-file", tokens: [] });
+      continue;
+    }
+    const before = f.hunks.flatMap((h) => codeTokens(h.removed.map((d) => d.text).join("\n")));
+    const after = f.hunks.flatMap((h) =>
+      codeTokens(h.added.map((d) => stripHandles(file, d.text)).join("\n")),
+    );
+    if (before.length === after.length && before.every((t, i) => t === after[i])) continue;
+    const lost = missing(before, after);
+    const extra = missing(after, before);
+    if (lost.length) violations.push({ file, kind: "lost", tokens: [...new Set(lost)] });
+    if (extra.length) violations.push({ file, kind: "extra", tokens: [...new Set(extra)] });
+    if (!lost.length && !extra.length) {
+      const at = before.findIndex((t, i) => t !== after[i]);
+      violations.push({ file, kind: "reordered", tokens: before.slice(at, at + 6) });
+    }
+  }
+  return { ok: violations.length === 0, handlesAdded, files, snapshots, violations };
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const text = readDiff(args);
+  if (!text.trim())
+    emit({ ok: true, handlesAdded: 0, files: [], snapshots: [], violations: [] }, 0);
+  const result = audit(text);
+  emit(result, result.ok ? 0 : 2);
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) main();

package/pipeline/scripts/routine-registry.mjs

@@ -122,6 +122,10 @@ function cmdGet(home, name) {
   process.stdout.write(`${JSON.stringify(r, null, 2)}\n`);
 }
 
+// Every saved routine is written with this grant; permission-baseline.mjs
+// freezes it.
+export const ROUTINE_ALLOWED_TOOLS = "Skill, Bash, Read, Edit, Write, AskUserQuestion";
+
 function buildSkill(args) {
   const desc = args.description;
   const descTr = args["description-tr"];
@@ -132,7 +136,7 @@ function buildSkill(args) {
     `description: ${JSON.stringify(desc)}`,
     descTr ? `description-tr: ${JSON.stringify(descTr)}` : null,
     `argument-hint: ${JSON.stringify(hint)}`,
-    "allowed-tools: Skill, Bash, Read, Edit, Write, AskUserQuestion",
+    `allowed-tools: ${ROUTINE_ALLOWED_TOOLS}`,
     "local-only: true",
     "---",
   ].filter(Boolean);

package/pipeline/scripts/run-ui-tests.sh

@@ -27,7 +27,15 @@
 #
 #   run-ui-tests.sh run --platform <ios|android|web> [--repo <path>] [--changed <f>...]
 #                       [--device <udid|serial>] [--log <path>] [--all]
-#       Run the matching tests (or the whole UI suite with --all).
+#       Run the matching tests (or the whole UI suite with --all). Prints
+#         UI_TEST_LOG=<path>
+#         UI_TEST_SELECTED=<what ran>
+#         UI_TEST_RESULT=<per-test report>|   (empty when the runner has none)
+#         UI_TEST_RESULT_FORMAT=xcresult|junit|
+#       The report sits next to the log: <log stem>.xcresult on iOS,
+#       <log stem>.junit.xml for Playwright, the module's connected test results
+#       directory on Android. It is what test_results_classify reads per test;
+#       the log alone says only whether the run passed.
 #
 # Env:
 #   UI_TEST_LOG   default "$PWD/.pipeline/ui-test.log"
@@ -396,6 +404,7 @@ fi
 }
 
 mkdir -p "$(dirname "$LOG")"
+RESULT=""; RESULT_FORMAT=""
 
 case "$PLATFORM" in
   ios)
@@ -434,9 +443,13 @@ case "$PLATFORM" in
       [ -n "$DEVICE" ] || { echo "run-ui-tests: no booted simulator and no --device" >&2; exit 2; }
     fi
     DEST="platform=iOS Simulator,id=$DEVICE"
+    # xcodebuild refuses a result bundle path that already exists.
+    RESULT="${LOG%.log}.xcresult"
+    rm -rf "$RESULT"
     (cd "$REPO" && xcodebuild test "${CONTAINER_ARGV[@]}" -scheme "$SCHEME" \
-      -destination "$DEST" "${ONLY_ARGV[@]}") >"$LOG" 2>&1
+      -destination "$DEST" -resultBundlePath "$RESULT" "${ONLY_ARGV[@]}") >"$LOG" 2>&1
     RC=$?
+    if [ -d "$RESULT" ]; then RESULT_FORMAT="xcresult"; else RESULT=""; fi
     ;;
   android)
     command -v adb >/dev/null 2>&1 || { echo "run-ui-tests: adb unavailable" >&2; exit 2; }
@@ -450,6 +463,11 @@ case "$PLATFORM" in
     # shellcheck disable=SC2086
     (cd "$REPO" && "$GRADLE" "$TARGET" $ARGS) >"$LOG" 2>&1
     RC=$?
+    MODULE_DIR=$(printf '%s\n' "$TARGET" | sed 's#:connectedAndroidTest$##; s#^:##; s#:#/#g')
+    if [ -d "$REPO/$MODULE_DIR/build/outputs/androidTest-results/connected" ]; then
+      RESULT="$REPO/$MODULE_DIR/build/outputs/androidTest-results/connected"
+      RESULT_FORMAT="junit"
+    fi
     ;;
   web)
     command -v npx >/dev/null 2>&1 || { echo "run-ui-tests: npx unavailable" >&2; exit 2; }
@@ -459,7 +477,10 @@ case "$PLATFORM" in
         # --no-install: npx would otherwise DOWNLOAD the runner on a machine that
         # does not have it, which turns "this repo has no UI tests" into a silent
         # network fetch mid-phase.
-        WEB_ARGV=(npx --no-install playwright test --reporter=line)
+        WEB_ARGV=(npx --no-install playwright test "--reporter=line,junit")
+        RESULT="${LOG%.log}.junit.xml"
+        rm -f "$RESULT"
+        export PLAYWRIGHT_JUNIT_OUTPUT_NAME="$RESULT"
         if [ "$RUN_ALL" -eq 0 ]; then
           OLDIFS="$IFS"; IFS=','
           for m in $MATCHES; do WEB_ARGV+=("$m"); done
@@ -474,11 +495,14 @@ case "$PLATFORM" in
     esac
     (cd "$REPO" && "${WEB_ARGV[@]}") >"$LOG" 2>&1
     RC=$?
+    if [ -n "$RESULT" ] && [ -s "$RESULT" ]; then RESULT_FORMAT="junit"; else RESULT=""; fi
     ;;
 esac
 
 printf 'UI_TEST_LOG=%s\n' "$LOG"
 printf 'UI_TEST_SELECTED=%s\n' "${MATCHES:-$TARGET}"
+printf 'UI_TEST_RESULT=%s\n' "$RESULT"
+printf 'UI_TEST_RESULT_FORMAT=%s\n' "$RESULT_FORMAT"
 
 # The exit code alone is not the verdict here for the same reason it is not one
 # for the build: a runner that died before it reached the tests also exits