@keepsnappy/agent 0.1.0-alpha.17 → 0.1.0-alpha.19

package/dist/keepsnappy.js

@@ -1953,6 +1953,16 @@ var MEASURES = {
     decimals: 1,
     what: "The part of the slowest screen update that React spent outside every component's own render, in its own bookkeeping"
   },
+  jank_ms: {
+    unit: "ms",
+    worse: "higher",
+    at: ["screen", "launch", "press", "drag", "step", "other", "background"],
+    producer: "tracesift",
+    label: "Jank time",
+    short: "jank time",
+    decimals: 1,
+    what: "The time the window's screen updates spent past one 60 Hz frame, added up, read from the full React export"
+  },
   commits_over_2_frames: {
     unit: "count",
     worse: "higher",
@@ -2198,6 +2208,7 @@ function isComponentConfiguration(value) {
 }
 
 // packages/facts/dist/src/places.js
+var COMMIT_IDENTITY_KINDS = ["screen", "press", "drag", "other"];
 var placeWithoutVisit = (id) => placeRef(id).stem.replace(/#(\d+|repeat)$/, "");
 var AFTER_3S = "+3s";
 var kindOf = (stem) => {
@@ -2323,7 +2334,7 @@ function withLaunchNames(windows) {
 }
 
 // packages/derive/dist/src/model.js
-var DERIVATION_VERSION = 27;
+var DERIVATION_VERSION = 28;
 // packages/stats/dist/src/core/rng.js
 function splitmix32(seed) {
   let s = seed >>> 0;
@@ -3180,6 +3191,44 @@ function estimateClockOffset(markers, windows, byOrder = false) {
   const negatives = gaps.filter((g) => g < 0);
   return negatives.length * 2 > starts.length ? Math.min(...negatives) : 0;
 }
+var ulp = (x) => x === 0 ? Number.MIN_VALUE : 2 ** (Math.floor(Math.log2(Math.abs(x))) - 52);
+function fitClockOffset(markers, windows, offset, errorMs) {
+  if (!(errorMs > 0))
+    return offset;
+  const inputs = windows.map(inputWall).filter((x) => x !== undefined).sort((a, b) => a - b);
+  const ss = spans(markers, 0).sort((a, b) => a.markerStart - b.markerStart);
+  const score = (o) => {
+    let started = 0;
+    let inside = 0;
+    for (const [i, s] of ss.entries()) {
+      const next = ss[i + 1]?.markerStart;
+      const t = inputs.find((x) => x >= s.markerStart + o);
+      if (t === undefined || next !== undefined && t >= next + o)
+        continue;
+      started += 1;
+      const end = Math.min(s.markerEnd ?? Infinity, next ?? Infinity) + o;
+      inside += inputs.filter((x) => x >= s.markerStart + o && x < end).length;
+    }
+    return [started, inside];
+  };
+  let best = offset;
+  let top = score(offset);
+  for (const [i, s] of ss.entries()) {
+    const prevEnd = ss[i - 1]?.markerEnd;
+    for (const t of inputs) {
+      if (prevEnd !== undefined && t >= prevEnd + offset && t - (prevEnd + offset) <= s.markerStart + offset - t)
+        continue;
+      const o = t - s.markerStart - ulp(t);
+      if (o >= offset || o < offset - errorMs)
+        continue;
+      const sc = score(o);
+      const better = sc[0] > top[0] || sc[0] === top[0] && (sc[1] > top[1] || sc[1] === top[1] && o > best);
+      if (better)
+        [best, top] = [o, sc];
+    }
+  }
+  return best;
+}
 function spans(markers, offset) {
   const sorted = [...markers].sort((a, b) => a.t_host - b.t_host);
   const out = [];
@@ -3206,7 +3255,8 @@ function ownWindowEnd(windows, t) {
 }
 function alignSteps(markers, windows, opts = {}) {
   const byOrder = opts.byOrder === true;
-  const offset = opts.clockOffsetMs ?? estimateClockOffset(markers, windows, byOrder);
+  const given = opts.clockOffsetMs;
+  const offset = given === undefined ? estimateClockOffset(markers, windows, byOrder) : byOrder && opts.clockErrorMs ? fitClockOffset(markers, windows, given, opts.clockErrorMs) : given;
   const ss = spans(markers, offset).sort((a, b) => a.markerStart - b.markerStart);
   const inputs = windows.map(inputWall).filter((x) => x !== undefined).sort((a, b) => a - b);
   const starts = ss.map((s, i) => {
@@ -3256,7 +3306,7 @@ function clusters(windows) {
   }
   return out;
 }
-function onAppClock(windows, version) {
+function processSegments(windows, version) {
   const order = windows.map((w, i) => ({ w, i })).sort((a, b) => a.w.endWall - b.w.endWall || a.i - b.i);
   const segment = new Map;
   let seg = 0;
@@ -3274,24 +3324,35 @@ function onAppClock(windows, version) {
     prevId = id;
     segment.set(w, seg);
   }
+  return segment;
+}
+function onAppClock(windows, version) {
+  const process2 = processSegments(windows, version);
+  const step = (w) => version >= 28 ? w.clockStep : undefined;
   const offset = new Map;
-  for (const [w, s] of segment) {
+  for (const [w, seg] of process2) {
     const t1 = num(w.raw.t1);
     if (t1 === undefined)
       continue;
-    const o = w.endWall - t1;
-    if (!offset.has(s) || o < offset.get(s))
-      offset.set(s, o);
+    const st = step(w);
+    if (st && w.endWall - t1 < st.floor)
+      continue;
+    const o = w.endWall - t1 - (st?.end ?? 0);
+    if (!offset.has(seg) || o < offset.get(seg))
+      offset.set(seg, o);
   }
   return windows.map((w) => {
-    const s = segment.get(w);
-    const o = s === undefined ? undefined : offset.get(s);
-    const t0 = num(w.raw.t0);
+    const seg = process2.get(w);
     const t1 = num(w.raw.t1);
+    const own = seg === undefined || t1 === undefined ? undefined : w.endWall - t1 - (step(w)?.end ?? 0);
+    const o = seg === undefined ? undefined : offset.get(seg) ?? own;
+    const t0 = num(w.raw.t0);
     if (o === undefined || t0 === undefined || t1 === undefined)
       return w;
+    const st = step(w);
+    const [atStart, atEnd] = [st?.start ?? 0, st?.end ?? 0];
     const touch = version >= 23 ? num(obj2(w.raw.interaction).touchStartT) : undefined;
-    return { ...w, startWall: t0 + o, endWall: t1 + o, ...touch === undefined ? {} : { touchWall: touch + o } };
+    return { ...w, startWall: t0 + o + atStart, endWall: t1 + o + atEnd, ...touch === undefined ? {} : { touchWall: touch + o + atStart } };
   });
 }
 
@@ -3683,7 +3744,7 @@ function profileMetrics(windows, steps, options = {}) {
     const kind = placeRef(key).kind;
     const active = occ.filter((o) => !o.idle);
     const selected = middleBy((active.length ? active : occ).filter((o) => o.window), (o) => o.commitMaxMs, (o) => num2(o.window.raw.id) ?? 0, (o) => num2(o.window.raw.t0) ?? o.window.startWall);
-    const identity = options.commitIdentity && metrics.has(`${key}.commit_max_ms`) && ["screen", "press", "drag", "other"].includes(kind) && selected?.slowestCommit;
+    const identity = options.commitIdentity && metrics.has(`${key}.commit_max_ms`) && COMMIT_IDENTITY_KINDS.includes(kind) && selected?.slowestCommit;
     const openedBy = selected?.window ? options.openedBy?.get(selected.window) : undefined;
     profiles.push({ ...profile, ...identity ? { slowestCommit: identity } : {}, ...openedBy ? { openedBy } : {} });
   }
@@ -3829,7 +3890,7 @@ function withActionWindows(windows, steps = [], version) {
     }
     const durMs = w.raw.endReason === "timeout" ? undefined : num3(w.raw.durMs);
     const raw = { ...rest, name: w.name, kind: w.raw.kind, t0: w.raw.t0, t1: w.raw.t1, ...durMs === undefined ? {} : { durMs }, endReason: a.endReason, sdkEndReason: w.raw.endReason, actionSpanMs: a.spanMs, actionUncoveredMs: a.uncoveredMs };
-    return { name: w.name, startWall: w.startWall, endWall: w.endWall, raw };
+    return { name: w.name, startWall: w.startWall, endWall: w.endWall, raw, ...w.clockStep === undefined ? {} : { clockStep: w.clockStep } };
   });
 }
 function actionMetrics(windows, steps = [], version) {
@@ -4942,7 +5003,7 @@ function keyFirstOpens(windows) {
 }
 
 // packages/derive/dist/src/derive.js
-var DERIVATION_VERSIONS = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 26, 27];
+var DERIVATION_VERSIONS = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 26, 27, 28];
 var windowsForVersion = (windows, version = DERIVATION_VERSION) => version >= 22 ? keyFirstOpens(windows) : windows;
 function stepWindowsFor(windows, version = DERIVATION_VERSION) {
   return windowsForVersion(version >= 16 ? withLaunchNames(windows).filter((w) => !isBackgroundWindow(w)) : windows, version);
@@ -4978,7 +5039,7 @@ function profileOptions(windows, version, processWindows = windows) {
   return { fullRowMs: FULL_ROW_MS, commitIdentity: processes.size <= 1, openedBy };
 }
 function deriveRun(input) {
-  const { run, markers = [], ri, clockOffsetMs, samples = [], memWindow } = input;
+  const { run, markers = [], ri, clockOffsetMs, clockErrorMs, samples = [], memWindow } = input;
   const version = input.derivationVersion ?? DERIVATION_VERSION;
   if (!DERIVATION_VERSIONS.includes(version))
     throw new Error(`unknown derivation version ${String(version)}`);
@@ -4987,7 +5048,7 @@ function deriveRun(input) {
   const cpu = input.cpu && renamed.size ? new Map([...input.cpu].map(([k, v]) => [renamed.get(k) ?? k, v])) : input.cpu;
   const background = version >= 16 ? named.filter(isBackgroundWindow) : [];
   const sdkWindows = stepWindowsFor(input.windows, version);
-  const off = clockOffsetMs === undefined ? {} : { clockOffsetMs };
+  const off = { ...clockOffsetMs === undefined ? {} : { clockOffsetMs }, ...version >= 28 && clockErrorMs !== undefined ? { clockErrorMs } : {} };
   const preSteps = version >= 11 && markers.length ? alignRunSteps(markers, sdkWindows, off, version) : [];
   const windows = version >= 11 ? withActionWindows(sdkWindows, preSteps, version) : sdkWindows;
   const steps = version >= 11 ? preSteps : alignRunSteps(markers, windows, clockOffsetMs === undefined ? {} : { clockOffsetMs }, version);
@@ -5150,102 +5211,9 @@ var markerEnv = (url, runId) => ({
   MAESTRO_KEEPSNAPPY_RUN_ID: runId
 });
 
-// apps/agent/src/upload.ts
-import { join as join4 } from "node:path";
-var MAX_RATE_RETRIES = 5;
-var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-class UploadError extends Error {
-}
-async function call(f, base, path, headers, body, method = "POST") {
-  let res;
-  for (let attempt = 0;; attempt++) {
-    try {
-      res = await f(`${base.replace(/\/+$/, "")}${path}`, {
-        method,
-        headers: method === "POST" ? { "content-type": "application/json", ...headers } : headers,
-        ...method === "POST" ? { body: JSON.stringify(body ?? {}) } : {}
-      });
-    } catch (e) {
-      throw new UploadError(`${method} ${path}: ${e.message}`);
-    }
-    if (res.status !== 429 || attempt >= MAX_RATE_RETRIES)
-      break;
-    const wait = Number(res.headers.get("retry-after") ?? "1");
-    await res.text().catch(() => "");
-    await sleep(Math.min(Math.max(Number.isFinite(wait) ? wait : 1, 1), 60) * 1000);
-  }
-  const text = await res.text();
-  if (res.status < 200 || res.status >= 300)
-    throw new UploadError(`${method} ${path} -> ${res.status} ${text.slice(0, 200)}`);
-  try {
-    return text ? JSON.parse(text) : {};
-  } catch {
-    throw new UploadError(`${method} ${path} -> ${res.status}, the answer is not JSON (is the URL the KeepSnappy API?): ${text.slice(0, 200)}`);
-  }
-}
-async function uploadRuns(deps, outDir, runs, opts) {
-  const f = opts.fetch ?? fetch;
-  const size = opts.batchSize ?? 200;
-  const skipped = [];
-  let uploaded = 0;
-  for (const r of runs) {
-    if (!r.valid) {
-      skipped.push({ run_id: r.run_id, why: r.invalid_reason || "invalid" });
-      continue;
-    }
-    const log = await deps.fs.readFile(join4(outDir, r.run_id, "keepsnappy.log"));
-    const windows = windowsInRun(parseWindows(log), r.t0, r.t1);
-    if (windows.length === 0) {
-      skipped.push({ run_id: r.run_id, why: "no-windows" });
-      continue;
-    }
-    const externalId = `${opts.externalPrefix}-${r.run_id}`;
-    const created = await call(f, opts.ingestUrl, "/v1/runs", { "x-keepsnappy-key": opts.key }, {
-      external_id: externalId,
-      started_at: r.t0,
-      ended_at: r.t1,
-      device: { ...opts.device?.model ? { model: opts.device.model } : {}, ...opts.device?.os ? { os: opts.device.os } : {}, ...opts.device?.id ? { id: opts.device.id } : {}, exclusive: true },
-      meta: {
-        arm: r.arm,
-        driver: opts.driver ?? "keepsnappy-run",
-        ...opts.meta,
-        ...r.scenario ? { scenario: r.scenario } : {},
-        ...opts.runSetId ? { run_set_id: opts.runSetId } : {}
-      }
-    });
-    const runId = String(created.run_id ?? "");
-    const token = String(created.run_token ?? "");
-    if (!runId || !token)
-      throw new UploadError("POST /v1/runs: response has no run_id/run_token");
-    const items = windows.map((w) => `${w.endWall} KEEPSNAPPY window ${JSON.stringify(w.raw)}`);
-    for (let i = 0;i * size < items.length; i++) {
-      await call(f, opts.ingestUrl, "/v1/windows", { "x-keepsnappy-key": opts.key, "x-keepsnappy-run-token": token }, {
-        batch_id: `${externalId}-${String(i + 1).padStart(4, "0")}`,
-        items: items.slice(i * size, (i + 1) * size)
-      });
-    }
-    const samples = samplesInRun(parseSamples(log), r.t0, r.t1).map((x) => `${x.wall} KEEPSNAPPY sample ${JSON.stringify(x.raw)}`);
-    for (let i = 0;i * size < samples.length; i++) {
-      await call(f, opts.ingestUrl, "/v1/windows", { "x-keepsnappy-key": opts.key, "x-keepsnappy-run-token": token }, {
-        batch_id: `${externalId}-s${String(i + 1).padStart(4, "0")}`,
-        items: samples.slice(i * size, (i + 1) * size)
-      });
-    }
-    let markers = [];
-    try {
-      markers = parseMarkersNdjson(await deps.fs.readFile(join4(outDir, r.run_id, "markers.ndjson")));
-    } catch {}
-    for (const m of markers) {
-      await call(f, opts.ingestUrl, "/v1/markers", { authorization: `Bearer ${token}` }, { step: m.step, phase: m.phase, t_host: m.t_host });
-    }
-    await call(f, opts.ingestUrl, `/v1/runs/${runId}/finish`, { "x-keepsnappy-key": opts.key }, {});
-    uploaded++;
-  }
-  return { uploaded, skipped };
-}
-
 // packages/present/dist/src/capital.js
 var upperFirst = (s) => s ? s.charAt(0).toUpperCase() + s.slice(1) : s;
+var lowerFirst = (s) => s ? s.charAt(0).toLowerCase() + s.slice(1) : s;
 
 // packages/present/dist/src/placeWords.js
 var GENERIC_GROUPS = new Set(["app", "tabs", "root"]);
@@ -5285,7 +5253,13 @@ var STATE_WORDS = {
 var INFO_WORDS = { heat: "Phone heated up" };
 var isWorseState = (state) => state === "worse";
 var NOT_BLOCKING = "not blocking";
-var badgedWord = (word, blocking) => word === STATE_WORDS.worse && blocking === false ? `${word} (${NOT_BLOCKING})` : word;
+var badgedWord = (word, blocking) => `${word}${notBlockingBadge(word, blocking)}`;
+var notBlockingBadge = (word, blocking) => word === STATE_WORDS.worse && blocking === false ? ` (${NOT_BLOCKING})` : "";
+var BLOCKED_WORD = "Blocked";
+var NOT_COMPUTED_WORD = "Verdict not computed yet (computed on demand)";
+var NO_BASELINE_WORD = "Waiting for main";
+var NOT_COMPARED_WORD = "Not compared with main";
+var NOT_JUDGED_WORD = "Not judged";
 
 // packages/present/dist/src/values.js
 var NO_VALUE = "–";
@@ -5314,17 +5288,23 @@ function roundTo(v, decimals) {
     return Number(magnitude.toFixed(decimals)) * Math.sign(v);
   return Number(`${Math.round(scaled)}e-${decimals}`) * Math.sign(v);
 }
+function written(unit, decimals, v) {
+  if (unit === "ms" && Math.abs(v) >= LONG_MS && Math.abs(v) < 1e9)
+    return { n: roundTo(v / 1000, 1) + 0, seconds: true };
+  return { n: roundTo(v * shownUnit(unit).scale, decimals) + 0, seconds: false };
+}
 function format(unit, decimals, v) {
   if (v === null || v === undefined || !Number.isFinite(v))
     return NO_VALUE;
+  const { n, seconds } = written(unit, decimals, v);
+  if (seconds)
+    return `${String(n)} s`;
   const shown = shownUnit(unit);
-  if (unit === "ms" && Math.abs(v) >= LONG_MS && Math.abs(v) < 1e9)
-    return `${String(roundTo(v / 1000, 1) + 0)} s`;
-  const text = String(roundTo(v * shown.scale, decimals) + 0);
-  return shown.unit ? `${text} ${shown.unit}` : text;
+  return shown.unit ? `${String(n)} ${shown.unit}` : String(n);
 }
+var defOf = (measure) => isMeasureId(measure) ? MEASURES[measure] : BREAKDOWN_MEASURES[measure];
 function valueText(measure, v) {
-  const def = isMeasureId(measure) ? MEASURES[measure] : BREAKDOWN_MEASURES[measure];
+  const def = defOf(measure);
   return format(def.unit, def.decimals, v);
 }
 var KEY_SEPARATOR = ":";
@@ -5342,6 +5322,13 @@ function fieldValueText(field, v) {
   const def = fieldDef(field.split(KEY_SEPARATOR)[0]);
   return format(def?.unit, def?.decimals ?? FALLBACK_DECIMALS, v);
 }
+function timeMove(field, a, b) {
+  if (a === null || b === null || !(a > 0))
+    return null;
+  const breakdown = breakdownMeasure(field);
+  const unit = breakdown ? BREAKDOWN_MEASURES[breakdown].unit : fieldDef(field.split(KEY_SEPARATOR)[0])?.unit;
+  return unit === "ms" ? Math.abs(b - a) / a : null;
+}
 
 // packages/present/dist/src/rowWords.js
 var GONE_TAILS = {
@@ -5370,6 +5357,14 @@ function notInRunRowsText(c, page) {
   const them = c.screens + c.places === 1 ? "it" : "them";
   return { lead: `${what} ${GONE_TAILS[page].notInRun}:`, rest: ` the ${page === "journey" ? "newest session" : "journey"} did not reach ${them}; not counted.` };
 }
+var sdkTag = (version) => version.replace(/^\d+\.\d+\.\d+-/, "");
+var placeChartMarker = (tag) => `Place names changed with SDK ${tag}`;
+var placeNamesChangedOmitted = (tag) => `the line where place names changed (SDK ${tag})`;
+var componentChartMarker = (tag) => `SDK ${tag}: names changed, library time now counted`;
+var ownTimeOnlyBefore = (version) => `own time only, before SDK ${version}`;
+var placeWasText = (oldKey) => `before it this place was ${oldKey}`;
+var PLACE_NOT_JOINED_TEXT = "no recorded old name, its history starts here";
+var componentNotJoinedText = (sdk) => `${componentChartMarker(sdk)}; values before it were ${ownTimeOnlyBefore(sdk)}, not joined`;
 var OUTSIDE_APP_NAME = "Outside app components";
 var OTHER_RENDER_WORK_NAME = "Other render work";
 var plural = (n, one, many) => `${n} ${n === 1 ? one : many}`;
@@ -5388,9 +5383,6 @@ function leadBody(subject, measure, main, pr) {
 var screenLeadText = (tier, subject, measure, main, pr) => `${STATE_WORDS[TIER_STATE[tier]]}: ${leadBody(subject, measure, main, pr)}`;
 var FOR_INFORMATION = "For information";
 var informationLeadText = (subject, measure, main, pr) => `${FOR_INFORMATION}: ${leadBody(subject, measure, main, pr)}`;
-function foldedText(n, rows, page) {
-  return `${n} ${GONE_TAILS[page][rows === "components" ? "removed" : "notInRun"]}`;
-}
 function placeShownName(p, o = {}) {
   const target = p.target ? componentShownName(p.target.name, p.target.file) : libraryViewName(p.kind, p.host ?? "");
   const named = p.target && p.parent ? `${target} in ${componentShownName(p.parent.name, p.parent.file)}${p.k ? `, ${ordinal(p.k)}` : ""}` : target;
@@ -5451,6 +5443,19 @@ var placeOpenWord = (id) => {
   const open = placeOpen(id);
   return open ? OPEN_WORDS[open] : null;
 };
+var TWIN2 = /\+3s$/;
+function foldTwins(rows, placeOf, also = () => "") {
+  const seen = new Set;
+  const out = rows.filter((r) => {
+    const key = `${placeOf(r).replace(TWIN2, "")}\x00${also(r)}`;
+    if (seen.has(key))
+      return false;
+    seen.add(key);
+    return true;
+  });
+  return { rows: out, folded: rows.length - out.length };
+}
+var foldedTwinsText = (n) => `${n} “${PLACE_KIND_WORDS.after3s}” ${n === 1 ? "twin" : "twins"} folded into ${n === 1 ? "its place" : "their places"}`;
 function placeIdShownName(id, o = {}) {
   const p = placeParts(id);
   if (!p)
@@ -5537,6 +5542,42 @@ function shortestPaths(files) {
   }
   return out;
 }
+// packages/present/dist/src/problems.js
+var FAR_OVER_BUDGET_WORD = "Far over budget";
+var PROBLEM_TAG_WORDS = { new: NEW_IN_PR_CHIP, main: "Also on main", none: NOT_COMPARED_WORD };
+var PROBLEM_TAG_LINE_WORDS = { new: "new in this PR", main: "also on main", none: "not compared with main" };
+var problems = (n) => `${n.toLocaleString("en-US")} ${n === 1 ? "problem" : "problems"}`;
+var places = (n) => `${n.toLocaleString("en-US")} ${n === 1 ? "place" : "places"}`;
+function problemCountsText(c, own) {
+  const tags = c.tags;
+  const split = tags ? `: ${[`${tags.new} ${PROBLEM_TAG_LINE_WORDS.new}`, ...["main", "none"].filter((t) => tags[t]).map((t) => `${tags[t]} ${PROBLEM_TAG_LINE_WORDS[t]}`)].join(", ")}` : "";
+  return `${problems(c.count)} at ${places(c.places)} in ${own} own runs${split}${c.far_count ? `; ${c.far_count} of them ${FAR_OVER_BUDGET_WORD.toLowerCase()}` : ""}`;
+}
+var newProblems = (n) => `${n.toLocaleString("en-US")} new ${n === 1 ? "problem" : "problems"}`;
+var PROBLEMS_BLOCK_WORDS = {
+  branch: {
+    heading: "New problems in this branch",
+    sub: "too slow on their own, whatever main does; they don’t block the merge",
+    seeAll: (n) => `See all ${newProblems(n)}`,
+    alsoLine: (n) => `${problems(n)} also on main`,
+    notComparedLine: (n) => `${problems(n)} not compared with main`,
+    choices: { new: PROBLEM_TAG_WORDS.new, also: PROBLEM_TAG_WORDS.main, not_compared: PROBLEM_TAG_WORDS.none },
+    panelTitle: "Problems in this branch",
+    panelNote: "Each one is too slow in this branch’s own runs, whatever main does. Problems never block.",
+    filter: "Which problems"
+  },
+  main: {
+    heading: "New problems in this session",
+    sub: "too slow on their own, whatever earlier sessions did",
+    seeAll: (n) => `See all ${newProblems(n)}`,
+    alsoLine: (n) => `${problems(n)} also in earlier sessions`,
+    notComparedLine: (n) => `${problems(n)} not compared with earlier sessions`,
+    choices: { new: "New in this session", also: "Also in earlier sessions", not_compared: "Not compared with earlier sessions" },
+    panelTitle: "Problems in this session",
+    panelNote: "Each one is too slow in this session’s own runs, whatever earlier sessions did. Problems never block.",
+    filter: "Which problems"
+  }
+};
 // packages/present/dist/src/stability.js
 var UNSTABLE_WORDS = {
   short: "main varies too much here",
@@ -5544,8 +5585,34 @@ var UNSTABLE_WORDS = {
   line: "Main varies too much here to tell",
   ratioTip: "1.0 = main’s run-to-run noise alone would pass the warning step about once in 100 comparisons.",
   note: "This place varies a lot between runs. Worth checking why: it may be in the code.",
-  what: "Main’s own runs vary too much here to tell, so a comparison there would mostly measure noise. It is shown with its values, never judged, never blocks and is never counted. It is judged again once main settles."
+  what: "Main’s own runs vary too much here to tell, so a comparison there would mostly measure noise. It is shown with its values, never judged, never blocks and is never counted. It is judged again once main settles.",
+  hint: {
+    work: "The work differs between runs or sessions ({count} {min}–{max}): likely the code or the test steps.",
+    speed: "The same work ran at different speeds ({count} {n} in every run): likely the phone or the session.",
+    unclear: "The stored facts don’t show whether the work or the speed varies."
+  }
 };
+function breakdownParts(ref) {
+  const [kind, ...rest] = ref.split(":");
+  return kind === "b" && rest.length >= 3 ? { key: rest.slice(1, -1).join(":"), measure: rest[rest.length - 1] } : null;
+}
+var countText = (n) => String(Math.round(n * 10) / 10);
+function countName(count, ref) {
+  if (count !== "component.renders" && count !== "component.mounts")
+    return MEASURES[count].short;
+  const key = (ref ? breakdownParts(ref)?.key : undefined) ?? "component";
+  return `${key} ${BREAKDOWN_MEASURES[count === "component.renders" ? "renders" : "mounts"].label}`;
+}
+function unstableHintLine(hint, ref) {
+  if (hint.kind === "unclear" || hint.count === null || hint.range === null)
+    return UNSTABLE_WORDS.hint.unclear;
+  const count = countName(hint.count, ref);
+  if (hint.kind === "work")
+    return UNSTABLE_WORDS.hint.work.replace("{count}", count).replace("{min}", countText(hint.range[0])).replace("{max}", countText(hint.range[1]));
+  return hint.median === null ? UNSTABLE_WORDS.hint.unclear : UNSTABLE_WORDS.hint.speed.replace("{count}", count).replace("{n}", countText(hint.median));
+}
+var unstableNoteWords = (u) => u.hint ? `${UNSTABLE_WORDS.note} ${unstableHintLine(u.hint, u.stabilityRef)}` : UNSTABLE_WORDS.note;
+var mainUnstableWords = (reason) => reason.kind === "noisy_main" ? unstableNoteWords(reason) : "";
 
 // packages/present/dist/src/present.js
 var ASPECT_WORDS = {
@@ -5617,8 +5684,6 @@ function resultContextLines(c, verbose = false, short = false) {
   for (const [screen, rows] of screens) {
     const line = notInRunRowsText({ screens: rows.filter((p) => p.kind === "screen").length, places: rows.filter((p) => p.kind !== "screen").length }, c.page);
     out.push(`${screen ? `${screen}: ` : ""}${line.lead}${line.rest}`);
-    if (rows.length > 3)
-      out.push(`  ${foldedText(rows.length, "places", c.page)}`);
     if (!short || rows.length <= 3)
       out.push(...rows.map((p) => `  ${windowQualified(p.place)}`));
   }
@@ -5628,8 +5693,6 @@ function resultContextLines(c, verbose = false, short = false) {
   for (const [place, rows] of removed) {
     const line = removedRowsText(rows.length, c.page);
     out.push(`${windowQualified(place)}: ${line.lead}${line.rest}`);
-    if (rows.length > 3)
-      out.push(`  ${foldedText(rows.length, "components", c.page)}`);
     if (!short || rows.length <= 3)
       out.push(...rows.map((r) => `  ${r.ref.kind === "breakdown" ? componentReadName({ key: r.ref.key, name: r.ref.name }) : measureWords(r.ref.measure)}`));
   }
@@ -5684,6 +5747,10 @@ var REASON_WORDS = {
   "not-enough-main": "main does not have enough sessions on this phone and journey yet"
 };
 var waitingWords = (runs) => `${runs} main ${runs === 1 ? "run waits" : "runs wait"} for a reprocess`;
+var AT_MOST = "≤ ";
+var atMost = (text, isBound) => isBound ? `${AT_MOST}${text}` : text;
+var AT_LEAST = "≥ ";
+var atLeast = (text, isBound) => isBound ? `${AT_LEAST}${text}` : text;
 // packages/present/dist/src/main-history.js
 var MAIN_TIER_WORDS = {
   same: "In norm",
@@ -5700,11 +5767,13 @@ var MAIN_TIER_RESULT_WORDS = {
   worse: STATE_WORDS.worse
 };
 var MAIN_TIER_RANK = { worse: 0, slight: 1, cant: 2, better: 3, same: 4 };
+var earlierWords = (sessions, since, config) => `main has ${sessions}${config.baseline.sessions === undefined ? "" : ` of ${config.baseline.sessions}`} earlier sessions${since ? ` on ${since}` : ""}`;
 function mainCantWords(reason, config) {
   if (!reason)
     return "";
-  return reason.kind === "noisy_main" ? "main’s runs vary too much there" : `main has ${reason.earlier_sessions}${config.baseline.sessions === undefined ? "" : ` of ${config.baseline.sessions}`} earlier sessions${reason.since_label ? ` on ${reason.since_label}` : ""}`;
+  return reason.kind === "noisy_main" ? "main’s runs vary too much there" : earlierWords(String(reason.earlier_sessions), reason.since_label, config);
 }
+var mainCantRangeWords = (r, config) => earlierWords(`${r.min}–${r.max}`, r.since_label, config);
 var waitingSessionsWords = (sessions) => `${sessions} older main ${sessions === 1 ? "session waits" : "sessions wait"} for a reprocess`;
 function mainPlaceReasonWords(reason, config) {
   switch (reason.kind) {
@@ -5734,9 +5803,11 @@ var SHORT_ASPECT_WORDS = {
   driverVersion: "Driver",
   journeyVersion: "Journey"
 };
+var cantAt = (places) => `${STATE_WORDS["cant-tell"]} at ${places} place${places === 1 ? "" : "s"}`;
 function mainSessionCantWords(places, reason, config) {
-  return `${STATE_WORDS["cant-tell"]} at ${places} place${places === 1 ? "" : "s"}: ${mainCantWords(reason, config)}`;
+  return `${cantAt(places)}: ${mainCantWords(reason, config)}`;
 }
+var mainSessionCantRangeWords = (places, r, config) => `${cantAt(places)}: ${mainCantRangeWords(r, config)}`;
 var KIND_PLURAL = {
   screen: "screens",
   press: "taps",
@@ -5761,6 +5832,495 @@ function mainCutWords(v) {
   return parts.length ? parts.join(" ") : "Measures alike; no baseline cut.";
 }
 var BY_RANK = Object.keys(MAIN_TIER_RANK).sort((a, b) => MAIN_TIER_RANK[a] - MAIN_TIER_RANK[b]);
+// packages/present/dist/src/verdict-section.js
+var places2 = (n) => `${n.toLocaleString("en-US")} ${n === 1 ? "place" : "places"}`;
+var of = (n, total) => `${n.toLocaleString("en-US")} of ${places2(total)}`;
+var runs = (n) => `${n} valid ${n === 1 ? "run" : "runs"}`;
+var VERDICT_SECTION_WORDS = {
+  slower: (n, total, slight) => `${slight ? "A little slower" : "Slower"} at ${of(n, total)}`,
+  blocksMerge: "blocks the merge",
+  faster: (n, total) => `Faster at ${of(n, total)}, slower at none`,
+  mixed: (slower, faster, total) => `Slower at ${of(slower, total)}, faster at ${faster.toLocaleString("en-US")}`,
+  unpublishedSdk: "ran an unpublished SDK build",
+  noneMoved: (total, judged = total) => judged < total ? `No place moved out of its normal range (${judged.toLocaleString("en-US")} of ${total.toLocaleString("en-US")} judged)` : `No place moved out of its normal range (${places2(total)})`,
+  noneMovedMeasured: (measured, same) => same ? `Nothing moved at ${of(same, same + measured)}; ${measured} measured differently` : `Nothing moved; ${measured} ${measured === 1 ? "place was" : "places were"} measured differently`,
+  tooFewRuns: (valid, needed) => `Not compared: ${runs(valid)} of ${needed} needed`,
+  tooFewMainRuns: (valid, needed) => `Not compared: main has ${runs(valid)} of ${needed} needed`,
+  tooFewBefore: (valid) => `Not compared: the sessions before have only ${runs(valid)}`,
+  noBaseline: { branch: "Nothing to compare with: no main runs on this phone yet", main: "Nothing to compare with: no earlier sessions on this phone" },
+  noisy: "Not judged: main’s own runs vary too much at every place here",
+  versionMismatch: "Not compared: the sides were computed with different analysis versions",
+  unconfirmed: (n) => `Can’t confirm ${places2(n)}: a run has no value there`,
+  notCompared: (reason) => `Not compared: ${reason}`,
+  notJudgedYet: (why) => `Not judged yet: ${why} on this phone`,
+  collecting: (collected, baseline, after) => after ? `Main is collecting a new baseline after ${after}: ${collected} of ${baseline} sessions` : `Main is collecting its baseline: ${collected} of ${baseline} sessions`,
+  doesNotBlock: "doesn’t block",
+  fixes: {
+    branch: {
+      "no-baseline": "Add this journey on this phone to main’s nightly runs.",
+      "too-few-runs": "Run this branch again on this phone.",
+      "judged-measures-missing": "Record the judged measures, then run again.",
+      "runs-unknown": "Run this branch again; a full set of runs decides it.",
+      "facts-version-mismatch": "Recompute both sides in Setup; no new runs are needed.",
+      "platforms-differ": "Add this phone’s platform to main’s nightly runs."
+    },
+    main: {
+      "no-baseline": "Nothing to do: main’s next 3 nightly sessions make a result possible.",
+      "too-few-runs": "Main’s next nightly session decides it.",
+      "runs-unknown": "Main’s next nightly session decides it.",
+      "judged-measures-missing": "Record the judged measures on main; its next nightly session is compared.",
+      "facts-version-mismatch": "Recompute both sides in Setup; no new runs are needed."
+    }
+  },
+  waitForMain: { branch: "Nothing to do on this branch; main’s next nightly session decides it.", main: "Main’s next nightly session decides it." },
+  sides: {
+    branch: { left: "Main", right: "This branch", rightShort: "Branch" },
+    main: { left: "Sessions before", right: "Newest session", rightShort: "Newest" },
+    runSet: { left: "Main", right: "This run set", rightShort: "Run set" }
+  },
+  branchSides: (name) => ({ left: "Main", right: name || "This branch", rightShort: "Branch" }),
+  inProgress: (arrived, expected) => `${arrived} of ${expected} runs arrived; the result comes with the last one`,
+  whatChangedLabel: "What changed",
+  forInformation: "for information",
+  allFilter: "All",
+  filter: {
+    label: "Show places",
+    choice: (tierWord) => upperFirst(tierWord),
+    showing: (choice, n) => `Showing ${choice.toLowerCase()}: ${n}`
+  },
+  countsLabel: "Places by result",
+  links: {
+    openChart: "Open chart",
+    seeAll: (n) => `See all ${places2(n)}`,
+    whichPlaces: "Which places",
+    whichChanges: "Which changes",
+    howToFix: "How to fix",
+    whatDiffers: "What differs",
+    whatChanged: "What changed",
+    openSetup: "Open setup",
+    openScreen: "Open screen"
+  }
+};
+// packages/present/dist/src/summary-message.js
+var SUMMARY_WORDS = {
+  notComputed: "Not judged yet",
+  notComputedWhy: "waiting for the judgement",
+  placesOnPage: "the places are on the page",
+  noResult: "No result",
+  main: "Main",
+  newestSlower: "newest session slower",
+  journeys: (n) => `${n} journeys`,
+  phones: (n) => `${n} phones`,
+  heated: (n, of) => `${INFO_WORDS.heat.toLowerCase()} in ${n} of ${of} runs`,
+  fewRuns: "few runs",
+  measuredDifferently: "measured differently",
+  namesChanged: (sdk, mainSessions, needed) => `Main: ${mainSessions} of ${needed} sessions on SDK ${sdkTag(sdk)}`,
+  morePlaces: (n) => `+${n} more ${n === 1 ? "place" : "places"} changed`,
+  compared: {
+    branch: (sessions, days) => `vs main’s last ${sessions}${days}`,
+    main: (sessions, days) => `newest session vs main’s ${sessions} before${days}`,
+    mainSlower: (sessions, days) => `newest session slower than main’s ${sessions} before${days}`
+  },
+  sessions: (n) => `${n} ${n === 1 ? "session" : "sessions"}`,
+  days: (days) => days ? ` (${days})` : "",
+  runs: (runs, each) => each ? `${each} ${each === 1 ? "run" : "runs"} each` : `${runs} ${runs === 1 ? "run" : "runs"}`,
+  unblock: (why, fix) => `${why} → ${fix}`,
+  link: {
+    comparison: "See the comparison",
+    session: "See the session",
+    branch: (branch) => `Open ${branch}`,
+    runSet: "Open the run set"
+  }
+};
+var ORDER = ["worse", "warning", "cant-tell", "not-computed", "better", "no-change"];
+var rank = (l) => ORDER.indexOf(l.state);
+var WORD = { ...STATE_WORDS, "not-computed": SUMMARY_WORDS.notComputed };
+var shownLane = (lanes) => [...lanes].sort((a, b) => rank(a) - rank(b) || b.places - a.places)[0];
+var clip = (s, n) => s.length > n ? `${s.slice(0, n - 1)}…` : s;
+var NAME = { name: 32, button: 30 };
+var TOP2 = 3;
+var MAX_LINES = 5;
+var upper = (s) => s ? `${s[0].toUpperCase()}${s.slice(1)}` : s;
+var fromTo = (a, b) => {
+  const unit = (v) => / [^\d\s]+$/.exec(v)?.[0];
+  return unit(a) && unit(a) === unit(b) ? `${a.slice(0, -unit(a).length)} → ${b}` : `${a} → ${b}`;
+};
+var days = (labels) => {
+  const a = labels[0], b = labels.at(-1);
+  if (!a || !b || a === b)
+    return a ?? "";
+  const [ma] = a.split(" ");
+  const [mb, db] = b.split(" ");
+  return ma === mb ? `${a}–${db}` : `${a}–${b}`;
+};
+var changeLine = (c, tier) => {
+  const values = c.main !== null && c.now !== null ? `${fromTo(c.main, c.now)}${c.change ? ` (${c.change})` : ""}` : c.change;
+  return [c.place ?? upper(c.measure), ...c.place ? [c.measure] : [], values, WORD[c.tier ?? tier]].filter(Boolean).join(" · ");
+};
+var wordReason = (word) => word?.includes(": ") ? word.slice(word.indexOf(": ") + 2) : null;
+var notJudgedWhy = (l) => l.state === "not-computed" && l.word?.startsWith(`${NOT_JUDGED_WORD}: `) ? upper(l.word.slice(NOT_JUDGED_WORD.length + 2)) : null;
+function why(l) {
+  if (l.state === "not-computed")
+    return notJudgedWhy(l) ?? upper(SUMMARY_WORDS.notComputedWhy);
+  if (l.state === "cant-tell" && l.namesChanged)
+    return SUMMARY_WORDS.namesChanged(l.namesChanged.sdk, l.namesChanged.mainSessions, l.namesChanged.needed);
+  if (l.answer)
+    return l.answer;
+  if (l.state === "no-change")
+    return l.places ? VERDICT_SECTION_WORDS.noneMoved(l.places) : noneMoved;
+  if (l.state !== "cant-tell")
+    return upper(SUMMARY_WORDS.placesOnPage);
+  return upper(wordReason(l.word) ?? (l.word === NO_BASELINE_WORD ? l.word : REASON_WORDS["judged-measures-missing"]));
+}
+function unblock(l, pr) {
+  const page = pr ? "branch" : "main";
+  const reason = l.namesChanged ? "not-enough-main" : l.reason;
+  if (!reason)
+    return null;
+  const fix = reason === "not-enough-main" ? VERDICT_SECTION_WORDS.waitForMain[page] : VERDICT_SECTION_WORDS.fixes[page][reason];
+  return fix ? lowerFirst(fix.replace(/\.$/, "")) : null;
+}
+var noneMoved = VERDICT_SECTION_WORDS.noneMoved(1).replace(/ \(.*\)$/, "");
+function conditions(l, pr) {
+  const moved = l.state === "worse" || l.state === "warning";
+  return [
+    pr && l.state === "worse" ? l.blocking ? VERDICT_SECTION_WORDS.blocksMerge : NOT_BLOCKING : "",
+    moved && l.measuredDifferently ? SUMMARY_WORDS.measuredDifferently : "",
+    (moved || l.state === "better") && l.fewRuns ? SUMMARY_WORDS.fewRuns : ""
+  ].filter(Boolean);
+}
+function compared(l, pr, slower) {
+  const judged = l.state === "worse" || l.state === "warning" || l.state === "better" || l.state === "no-change";
+  if (!judged || !l.main?.sessions)
+    return null;
+  const args = [SUMMARY_WORDS.sessions(l.main.sessions), SUMMARY_WORDS.days(days(l.main.labels))];
+  const what = pr ? SUMMARY_WORDS.compared.branch(...args) : slower ? SUMMARY_WORDS.compared.mainSlower(...args) : SUMMARY_WORDS.compared.main(...args);
+  return `${what} · ${SUMMARY_WORDS.runs(l.main.runs, l.main.each)}`;
+}
+function summaryMessage(input) {
+  const l = shownLane(input.lanes);
+  if (!l) {
+    return {
+      state: "not-computed",
+      newestSlower: false,
+      lead: `${SUMMARY_WORDS.notComputed} · ${clip(input.branch, NAME.name)}`,
+      ...withLines([upper(SUMMARY_WORDS.notComputedWhy)]),
+      link: { label: SUMMARY_WORDS.link.branch(clip(input.branch, NAME.button - 5)), url: input.url }
+    };
+  }
+  const journeys = new Set(input.lanes.map((x) => x.journey ?? "-")).size;
+  const phones = new Set(input.lanes.map((x) => x.phone ?? "-")).size;
+  const single = input.lanes.length === 1;
+  const newestSlower = !input.pr && (l.state === "worse" || l.state === "warning");
+  const lead = [
+    notJudgedWhy(l) ? NOT_JUDGED_WORD : WORD[l.state],
+    ...input.app ? [input.app] : [],
+    journeys === 1 ? l.journey ?? "journey" : SUMMARY_WORDS.journeys(journeys),
+    input.pr && input.prNumber ? `${input.branch} (#${input.prNumber})` : input.branch,
+    phones === 1 ? l.phone ?? "unknown phone" : SUMMARY_WORDS.phones(phones)
+  ].join(" · ");
+  const lines = [];
+  const basis = compared(l, input.pr, newestSlower);
+  const extra = conditions(l, input.pr).join(", ");
+  const heat = l.heatedRuns ? upper(SUMMARY_WORDS.heated(l.heatedRuns, l.runs)) : null;
+  const tail = [...basis || extra ? [basis ? `${basis}${extra ? `; ${extra}` : ""}` : upper(extra)] : [], ...heat ? [heat] : []];
+  if (l.state === "worse" || l.state === "warning" || l.state === "better") {
+    const seen = new Set;
+    const places = l.changes.filter((c) => {
+      const key = c.key ?? c.place ?? c.measure;
+      return seen.has(key) ? false : (seen.add(key), true);
+    });
+    const room = MAX_LINES - tail.length;
+    const top = places.length > room ? places.slice(0, Math.min(TOP2, room - 1)) : places.slice(0, TOP2);
+    lines.push(...top.map((c) => changeLine(c, l.state)));
+    if (!top.length)
+      lines.push(why(l));
+    const more = l.places - top.length;
+    if (top.length && more > 0)
+      lines.push(SUMMARY_WORDS.morePlaces(more));
+  } else {
+    const fix = l.state === "cant-tell" ? unblock(l, input.pr) : null;
+    lines.push(fix ? SUMMARY_WORDS.unblock(why(l), fix) : why(l));
+  }
+  lines.push(...tail);
+  const label = input.pr ? SUMMARY_WORDS.link.comparison : SUMMARY_WORDS.link.session;
+  return { state: l.state, newestSlower, lead, ...withLines(lines), link: { label, url: (single ? l.url : null) ?? input.url } };
+}
+var withLines = (lines) => ({ lines, detail: lines.join(`
+`) });
+function pendingMessage(branch, url) {
+  return { state: "not-computed", newestSlower: false, lead: `${SUMMARY_WORDS.notComputed} · ${clip(branch, NAME.name)}`, ...withLines([upper(SUMMARY_WORDS.notComputedWhy)]), link: { label: SUMMARY_WORDS.link.runSet, url } };
+}
+function noResultMessage(branch, reason, url) {
+  return { state: "not-computed", newestSlower: false, lead: `${SUMMARY_WORDS.noResult} · ${clip(branch, NAME.name)}`, ...withLines([reason.replace(/\.$/, "")]), link: url ? { label: SUMMARY_WORDS.link.runSet, url } : null };
+}
+// packages/present/dist/src/run-set-message.js
+var midLine = (label, metric) => !metric.startsWith("component:") && /^[A-Z][a-z]*(\s|$)/.test(label) ? `${label[0].toLowerCase()}${label.slice(1)}` : label;
+function movedItems(v, sc) {
+  const flat = v.items.filter((i) => i.scenario === sc.scenario && (!sc.device || !i.device_id || i.device_id === sc.device.id));
+  const h = sc.headline;
+  if (h?.errors === undefined)
+    return flat.filter((i) => i.state === "worse" || i.state === "better");
+  const graded = [...h.errors, ...h.warnings ?? []].map((g) => {
+    const same = flat.find((i) => i.step === g.window && i.metric === g.metric);
+    return {
+      ...same ?? { kind: "change", low_data: false, low_data_reason: null },
+      scenario: sc.scenario,
+      step: g.window,
+      metric: g.metric,
+      state: "worse",
+      grade: g.grade,
+      baseline: g.baseline ?? same?.baseline ?? null,
+      ...(g.baseline != null ? g.baseline_is_bound : same?.baseline_is_bound) ? { baseline_is_bound: true } : {},
+      ...(g.baseline != null ? g.change_is_bound : same?.change_is_bound) ? { change_is_bound: true } : {},
+      candidate: g.candidate ?? same?.candidate ?? null,
+      change_text: g.change,
+      ...g.finding ? { finding: g.finding } : {},
+      ...g.label ? { label_text: midLine(g.label, g.metric) } : {},
+      ...sc.device ? { device_id: sc.device.id } : {}
+    };
+  });
+  return [...graded, ...flat.filter((i) => i.state === "better" && (i.judged ?? "outcome") === "outcome")];
+}
+var placeCount = (rows) => new Set(rows.map((i) => `${i.scenario}|${i.device_id ?? ""}|${i.finding ?? placeRef(i.step ?? "*").stem}`)).size;
+var linkOf = (x, set) => x?.share_url || set?.share_url || x?.dashboard_url || set?.dashboard_url || null;
+var measureWord = (i) => {
+  if (i.label_text)
+    return i.label_text;
+  if (i.metric === "dur_ms" && placeKindWord(i.step ?? "") !== "Tap")
+    return "length";
+  return measureDef(i.metric)?.short ?? i.metric.replace(/_/g, " ");
+};
+var changeWords = (i) => {
+  if (i.change_text)
+    return i.change_text.replace(/ \(.*\)$/, "");
+  const { baseline: b, candidate: c } = i;
+  if (b === null || c === null)
+    return "";
+  if (b === 0)
+    return atLeast(`${c - b >= 0 ? "+" : ""}${fieldValueText(i.metric, c - b)}`, i.change_is_bound);
+  const p = Math.round((c / b - 1) * 100);
+  return atLeast(`${p >= 0 ? "+" : ""}${p} %`, i.change_is_bound);
+};
+var placeOf = (step) => !step || step === "flow" || step === "*" ? null : placeLabel(step);
+function stateOf(sc, errors) {
+  if (sc.state === null)
+    return sc.word === NO_BASELINE_WORD ? "cant-tell" : "not-computed";
+  if (sc.state === "inconclusive")
+    return "cant-tell";
+  if (sc.state === "warn")
+    return errors || sc.word?.startsWith(STATE_WORDS.worse) ? "worse" : "warning";
+  return sc.state;
+}
+function laneOf(v, sc, set) {
+  const moved = sc.state === "inconclusive" ? [] : movedItems(v, sc);
+  const worse = moved.filter((i) => i.state === "worse").sort((a, b) => Number(a.grade === "warn") - Number(b.grade === "warn"));
+  const errors = worse.filter((i) => i.grade !== "warn");
+  const state = stateOf(sc, errors.length);
+  const shown = state === "better" ? moved.filter((i) => i.state === "better") : worse;
+  return {
+    journey: sc.scenario,
+    phone: sc.device?.model ?? null,
+    state,
+    answer: sc.headline?.answer ?? null,
+    word: sc.word ?? null,
+    changes: shown.map((i) => ({
+      place: placeOf(i.step),
+      measure: measureWord(i),
+      key: i.finding ?? placeRef(i.step ?? "*").stem,
+      tier: i.state === "better" ? "better" : i.grade === "warn" ? "warning" : "worse",
+      main: i.baseline === null ? null : atMost(fieldValueText(i.metric, i.baseline), i.baseline_is_bound),
+      now: i.candidate === null ? null : fieldValueText(i.metric, i.candidate),
+      change: changeWords(i)
+    })),
+    places: placeCount(shown),
+    blocking: sc.headline?.blocking ?? v.blocking ?? v.headline?.blocking ?? true,
+    measuredDifferently: !!sc.headline?.measured_differently?.length,
+    fewRuns: sc.low_data,
+    heatedRuns: sc.heated_runs ?? 0,
+    runs: sc.runs.valid + sc.runs.invalid,
+    namesChanged: sc.context?.namesChanged ?? null,
+    url: linkOf(sc, set),
+    main: sc.main ?? null,
+    reason: sc.headline?.reason ?? sc.headline?.reasons?.[0] ?? null
+  };
+}
+var isPending = (s) => lanesOf(s).every((l) => l.state === "not-computed" && !l.word?.startsWith(`${NOT_JUDGED_WORD}: `));
+var lanesOf = (s) => s.verdicts ? s.verdicts.scenarios.map((sc) => laneOf(s.verdicts, sc, s)) : [];
+var isPr = (s) => !!s.verdicts?.scenarios.some((sc) => sc.role === "comparison");
+var runSetMessage = (s) => summaryMessage({ branch: s.branch, pr: isPr(s), lanes: lanesOf(s), url: linkOf(s) ?? s.dashboard_url, app: s.app ?? null, prNumber: s.pull_request?.number ?? null });
+var MESSAGE_COLORS = { error: "#D6334A", warn: "#C47A00", better: "#238359", none: "#7C8492" };
+function messageTone(s) {
+  const lanes = s ? lanesOf(s) : [];
+  const pr = !!s && isPr(s);
+  if (lanes.some((l) => l.state === "worse" && (l.blocking || !pr)))
+    return { mark: "\uD83D\uDD34", color: MESSAGE_COLORS.error };
+  if (lanes.some((l) => l.state === "warning"))
+    return { mark: "\uD83D\uDFE1", color: MESSAGE_COLORS.warn };
+  switch (shownLane(lanes)?.state) {
+    case "better":
+      return { mark: "\uD83D\uDFE2", color: MESSAGE_COLORS.better };
+    case "cant-tell":
+      return { mark: "❔", color: MESSAGE_COLORS.none };
+    default:
+      return { mark: "⚪", color: MESSAGE_COLORS.none };
+  }
+}
+var esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+function slackPayload(m, tone) {
+  const lead = `${tone.mark} ${esc(m.lead)}`;
+  return {
+    attachments: [{
+      color: tone.color,
+      fallback: lead,
+      blocks: [
+        { type: "section", text: { type: "mrkdwn", text: `*${lead}*
+${esc(m.detail)}` } },
+        ...m.link ? [{ type: "actions", elements: [{ type: "button", text: { type: "plain_text", text: m.link.label }, url: m.link.url }] }] : []
+      ]
+    }]
+  };
+}
+function resultSlackPayload(s, o = {}) {
+  if (!s.verdicts)
+    return null;
+  const lanes = lanesOf(s);
+  const moved = lanes.some((l) => l.state === "worse" || l.state === "warning");
+  const heat = lanes.some((l) => l.heatedRuns > 0);
+  const improved = lanes.some((l) => l.state === "better") || s.verdicts.state === "better";
+  if (isPr(s) ? !moved && !heat : !moved && !improved && !heat && !o.always)
+    return null;
+  return slackPayload(runSetMessage(s), messageTone(s));
+}
+var noResultSlackPayload = (branch, reason, url) => slackPayload(noResultMessage(branch, reason, url), { mark: "⚪", color: MESSAGE_COLORS.none });
+var markdown = (m, mark) => `### ${mark} ${m.lead}
+
+${m.lines.join(`  
+`)}
+${m.link ? `
+[${m.link.label} ›](${m.link.url})
+` : ""}`;
+var resultMarkdown = (s) => markdown(runSetMessage(s), messageTone(s).mark);
+var noResultMarkdown = (branch, reason, url) => markdown(noResultMessage(branch, reason, url), "⚪");
+var pendingMarkdown = (branch, url) => markdown(pendingMessage(branch, url), "⚪");
+// packages/present/dist/src/stale.js
+function staleNoteText(why) {
+  const newer = why.includes("newer-run-set");
+  const rules = why.some((w) => w === "core-version" || w === "config");
+  if (newer && rules)
+    return "Result from an older run set and older rules.";
+  if (newer)
+    return "Result from an older run set; a newer one has arrived.";
+  if (rules)
+    return "Result from older rules; it is not recomputed yet.";
+  return "Result from older inputs.";
+}
+var staleFlagText = (why) => {
+  const note = staleNoteText(why).replace(/\.$/, "");
+  return `${note.charAt(0).toLowerCase()}${note.slice(1)}`;
+};
+var STALE_MARK = "stale result";
+// apps/agent/src/upload.ts
+import { join as join4 } from "node:path";
+var MAX_RATE_RETRIES = 5;
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var pause = (ms) => sleep(ms);
+
+class UploadError extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+  }
+}
+async function call(f, base, path, headers, body, method = "POST") {
+  let res;
+  for (let attempt = 0;; attempt++) {
+    try {
+      res = await f(`${base.replace(/\/+$/, "")}${path}`, {
+        method,
+        headers: method === "POST" ? { "content-type": "application/json", ...headers } : headers,
+        ...method === "POST" ? { body: JSON.stringify(body ?? {}) } : {}
+      });
+    } catch (e) {
+      throw new UploadError(`${method} ${path}: ${e.message}`, 0);
+    }
+    if (res.status !== 429 || attempt >= MAX_RATE_RETRIES)
+      break;
+    const wait = Number(res.headers.get("retry-after") ?? "1");
+    await res.text().catch(() => "");
+    await sleep(Math.min(Math.max(Number.isFinite(wait) ? wait : 1, 1), 60) * 1000);
+  }
+  const text = await res.text();
+  if (res.status < 200 || res.status >= 300)
+    throw new UploadError(`${method} ${path} -> ${res.status} ${text.slice(0, 200)}`, res.status);
+  try {
+    return text ? JSON.parse(text) : {};
+  } catch {
+    throw new UploadError(`${method} ${path} -> ${res.status}, the answer is not JSON (is the URL the KeepSnappy API?): ${text.slice(0, 200)}`);
+  }
+}
+async function uploadRuns(deps, outDir, runs, opts) {
+  const f = opts.fetch ?? fetch;
+  const size = opts.batchSize ?? 200;
+  const skipped = [];
+  let uploaded = 0;
+  for (const r of runs) {
+    if (!r.valid) {
+      skipped.push({ run_id: r.run_id, why: r.invalid_reason || "invalid" });
+      continue;
+    }
+    const log = await deps.fs.readFile(join4(outDir, r.run_id, "keepsnappy.log"));
+    const windows = windowsInRun(parseWindows(log), r.t0, r.t1);
+    if (windows.length === 0) {
+      skipped.push({ run_id: r.run_id, why: "no-windows" });
+      continue;
+    }
+    const externalId = `${opts.externalPrefix}-${r.run_id}`;
+    const created = await call(f, opts.ingestUrl, "/v1/runs", { "x-keepsnappy-key": opts.key }, {
+      external_id: externalId,
+      started_at: r.t0,
+      ended_at: r.t1,
+      device: { ...opts.device?.model ? { model: opts.device.model } : {}, ...opts.device?.os ? { os: opts.device.os } : {}, ...opts.device?.id ? { id: opts.device.id } : {}, exclusive: true },
+      meta: {
+        arm: r.arm,
+        driver: opts.driver ?? "keepsnappy-run",
+        ...opts.meta,
+        ...r.scenario ? { scenario: r.scenario } : {},
+        ...opts.runSetId ? { run_set_id: opts.runSetId } : {}
+      }
+    });
+    const runId = String(created.run_id ?? "");
+    const token = String(created.run_token ?? "");
+    if (!runId || !token)
+      throw new UploadError("POST /v1/runs: response has no run_id/run_token");
+    const items = windows.map((w) => `${w.endWall} KEEPSNAPPY window ${JSON.stringify(w.raw)}`);
+    for (let i = 0;i * size < items.length; i++) {
+      await call(f, opts.ingestUrl, "/v1/windows", { "x-keepsnappy-key": opts.key, "x-keepsnappy-run-token": token }, {
+        batch_id: `${externalId}-${String(i + 1).padStart(4, "0")}`,
+        items: items.slice(i * size, (i + 1) * size)
+      });
+    }
+    const samples = samplesInRun(parseSamples(log), r.t0, r.t1).map((x) => `${x.wall} KEEPSNAPPY sample ${JSON.stringify(x.raw)}`);
+    for (let i = 0;i * size < samples.length; i++) {
+      await call(f, opts.ingestUrl, "/v1/windows", { "x-keepsnappy-key": opts.key, "x-keepsnappy-run-token": token }, {
+        batch_id: `${externalId}-s${String(i + 1).padStart(4, "0")}`,
+        items: samples.slice(i * size, (i + 1) * size)
+      });
+    }
+    let markers = [];
+    try {
+      markers = parseMarkersNdjson(await deps.fs.readFile(join4(outDir, r.run_id, "markers.ndjson")));
+    } catch {}
+    for (const m of markers) {
+      await call(f, opts.ingestUrl, "/v1/markers", { authorization: `Bearer ${token}` }, { step: m.step, phase: m.phase, t_host: m.t_host });
+    }
+    await call(f, opts.ingestUrl, `/v1/runs/${runId}/finish`, { "x-keepsnappy-key": opts.key }, {});
+    uploaded++;
+  }
+  return { uploaded, skipped };
+}
+
 // apps/agent/src/summary.ts
 var fieldWord = (field) => measureDef(field)?.short ?? field;
 function plainMetric(metric) {
@@ -5799,7 +6359,6 @@ function summarize(input) {
 
 // apps/agent/src/remote.ts
 var isBlocking = (s) => !!s?.verdicts && (s.verdicts.blocking ?? s.verdicts.state === "worse");
-var midLine = (label, metric) => !metric.startsWith("component:") && /^[A-Z][a-z]*(\s|$)/.test(label) ? `${label[0].toLowerCase()}${label.slice(1)}` : label;
 function heatNote(sc) {
   const n = sc.heated_runs ?? 0;
   if (!n)
@@ -5807,30 +6366,6 @@ function heatNote(sc) {
   const phone = sc.device ? `${sc.device.model}${sc.device.os ? ` · ${sc.device.os}` : ""}` : "unknown phone";
   return `${INFO_WORDS.heat} in ${n} of ${sc.runs.valid + sc.runs.invalid} runs · ${sc.scenario ?? "journey"} · ${phone}`;
 }
-function movedItems(v, sc) {
-  const flat = v.items.filter((i) => i.scenario === sc.scenario && (!sc.device || !i.device_id || i.device_id === sc.device.id));
-  const h = sc.headline;
-  if (h?.errors === undefined)
-    return flat.filter((i) => i.state === "worse" || i.state === "better");
-  const graded = [...h.errors, ...h.warnings ?? []].map((g) => {
-    const same = flat.find((i) => i.step === g.window && i.metric === g.metric);
-    return {
-      ...same ?? { kind: "change", low_data: false, low_data_reason: null },
-      scenario: sc.scenario,
-      step: g.window,
-      metric: g.metric,
-      state: "worse",
-      grade: g.grade,
-      baseline: g.baseline ?? same?.baseline ?? null,
-      candidate: g.candidate ?? same?.candidate ?? null,
-      change_text: g.change,
-      ...g.finding ? { finding: g.finding } : {},
-      ...g.label ? { label_text: midLine(g.label, g.metric) } : {},
-      ...sc.device ? { device_id: sc.device.id } : {}
-    };
-  });
-  return [...graded, ...flat.filter((i) => i.state === "better" && (i.judged ?? "outcome") === "outcome")];
-}
 var placeOfRow = (g) => g.finding ?? placeRef(g.window).stem;
 function movedCounts(sc) {
   const h = sc.headline;
@@ -5840,7 +6375,6 @@ function movedCounts(sc) {
   const slightly = new Set((h.warnings ?? []).map(placeOfRow).filter((p) => !worse.has(p)));
   return { worse: worse.size, warnings: slightly.size, better: h.counts.better, noChange: h.counts.no_change, inconclusive: h.counts.inconclusive };
 }
-var placeCount = (rows) => new Set(rows.map((i) => `${i.scenario}|${i.device_id ?? ""}|${i.finding ?? placeRef(i.step ?? "*").stem}`)).size;
 var addCounts = (xs) => xs.reduce((a, c) => ({ worse: a.worse + c.worse, warnings: a.warnings + c.warnings, better: a.better + c.better, noChange: a.noChange + c.noChange, inconclusive: a.inconclusive + c.inconclusive }), { worse: 0, warnings: 0, better: 0, noChange: 0, inconclusive: 0 });
 var setupLine = (h) => {
   const parts = [
@@ -5856,13 +6390,35 @@ async function createRunSet(t, body) {
     throw new UploadError("POST /v1/run-sets: response has no run_set_id (is the URL the KeepSnappy API?)");
   return { run_set_id: r.run_set_id, dashboard_url: String(r.dashboard_url ?? "") };
 }
+var UNKNOWN_OUTCOME = new Set([0, 502, 503, 504]);
+var CONFIRM_READS = 6;
+var CONFIRM_WAIT_MS = 1e4;
 async function completeRunSet(t, id, verdicts) {
   const path = `/v1/run-sets/${encodeURIComponent(id)}/complete`;
-  const r = await call(t.fetch ?? fetch, t.url, path, keyHeader(t), { verdicts });
+  let r;
+  try {
+    r = await call(t.fetch ?? fetch, t.url, path, keyHeader(t), { verdicts });
+  } catch (e) {
+    const closed = e instanceof UploadError && UNKNOWN_OUTCOME.has(e.status ?? -1) ? await confirmedClose(t, id) : null;
+    if (closed)
+      return closed;
+    throw e;
+  }
   if (!r.run_set_id)
     throw new UploadError(`POST ${path}: response has no run_set_id`);
   return r;
 }
+async function confirmedClose(t, id) {
+  const path = `/v1/run-sets/${encodeURIComponent(id)}`;
+  for (let i = 0;i < CONFIRM_READS; i++) {
+    if (i)
+      await pause(CONFIRM_WAIT_MS);
+    const s = await call(t.fetch ?? fetch, t.url, path, keyHeader(t), undefined, "GET").catch(() => null);
+    if (s?.run_set_id && (s.status === "processed" || s.status === "failed"))
+      return s;
+  }
+  return null;
+}
 async function createIngestRun(t, body) {
   const r = await call(t.fetch ?? fetch, t.url, "/v1/runs", keyHeader(t), body);
   if (!r.run_id || !r.run_token)
@@ -5887,16 +6443,15 @@ var word = (s, server, blocking) => badgedWord(server || stateWord(s ?? "inconcl
 var setWord = (v) => word(v?.state ?? null, v?.word, v?.blocking ?? v?.headline?.blocking);
 var scenarioWord = (sc) => word(sc.state, sc.word, sc.headline?.blocking);
 var notComputed = (s) => !s.verdicts || s.verdicts.state === null && !s.verdicts.blocking;
-var resultWord = (s) => setWord(s.verdicts);
-var UNCHECKED_GATE = "Verdict not computed yet (computed on demand): --fail-on-worse checked nothing";
-var uncheckedGate = (s) => notComputed(s) ? UNCHECKED_GATE : null;
+var UNCHECKED_GATE = `${NOT_COMPUTED_WORD}: --fail-on-worse checked nothing`;
+var uncheckedGate = (s) => notComputed(s) ? s.verdicts?.word && s.verdicts.word !== NOT_COMPUTED_WORD ? `${s.verdicts.word}: --fail-on-worse checked nothing` : UNCHECKED_GATE : null;
 var countsLine = (c) => countsWords(c);
 var noCounts = (c) => !c.worse && !c.warnings && !c.better && !c.noChange && !c.inconclusive;
-var change = (metric, a, b) => {
+var change = (metric, a, b, bounds) => {
   if (a === null || b === null)
     return "";
-  const pct = a === 0 ? "" : ` ${b >= a ? "+" : "-"}${Math.round(Math.abs(b / a - 1) * 100)}%`;
-  return `${pct} (${fieldValueText(metric, a)} -> ${fieldValueText(metric, b)})`;
+  const pct = a === 0 ? "" : ` ${atLeast(`${b >= a ? "+" : "-"}${Math.round(Math.abs(b / a - 1) * 100)}%`, bounds.change_is_bound)}`;
+  return `${pct} (${atMost(fieldValueText(metric, a), bounds.baseline_is_bound)} -> ${fieldValueText(metric, b)})`;
 };
 function formatRunSet(s, top = 5) {
   const lines = [];
@@ -5926,11 +6481,12 @@ function formatRunSet(s, top = 5) {
     lines.push(...resultContextLines(sc.context).map((line) => `  ${line}`));
     if (heatNote(sc))
       lines.push(`  ${heatNote(sc)}`);
+    lines.push(...(sc.headline?.session_speed ?? []).map((line) => `  ${line}`));
     const allMoved = movedItems(v, sc).sort((a, b) => Number(b.state === "worse") - Number(a.state === "worse") || Number(a.grade === "warn") - Number(b.grade === "warn"));
     const moved = allMoved.slice(0, top);
     for (const i of moved) {
       const what = i.label_text ? `${i.step && i.step !== "*" ? `${placeLabel(i.step)}: ` : ""}${i.label_text}` : i.step ? `${placeLabel(i.step)}: ${fieldWord(i.metric)}` : plainMetric(i.metric);
-      lines.push(`  ${stateWord(i.state === "worse" && i.grade === "warn" ? "warn" : i.state).padEnd(WORD_WIDTH)} ${what}${i.change_text ? `: ${i.change_text}` : change(i.metric, i.baseline, i.candidate)}`);
+      lines.push(`  ${stateWord(i.state === "worse" && i.grade === "warn" ? "warn" : i.state).padEnd(WORD_WIDTH)} ${what}${i.change_text ? `: ${i.change_text}` : change(i.metric, i.baseline, i.candidate, i)}`);
     }
     if (allMoved.length > moved.length)
       lines.push(`  ${allMoved.length - moved.length} more`);
@@ -5947,35 +6503,12 @@ function formatRunSet(s, top = 5) {
 `);
 }
 function markdownRunSet(s, fallback) {
-  if (!s || !s.verdicts) {
+  if (!s || !s.verdicts)
     return `### KeepSnappy
 
 Runs uploaded for \`${fallback.branch}\`. The result appears on the dashboard: [open KeepSnappy](${fallback.dashboardUrl})
 `;
-  }
-  const v = s.verdicts;
-  const heated = v.scenarios.flatMap((sc) => heatNote(sc) ?? []);
-  const contextLines = v.scenarios.flatMap((sc) => laneContextLines(sc.context, sc.scenario ?? "-", sc.device?.model ?? "-"));
-  const rows = v.scenarios.map((sc) => {
-    const c = movedCounts(sc);
-    return `| ${sc.scenario ?? "-"} | ${sc.device ? sc.device.model : "-"} | ${scenarioWord(sc)}${sc.low_data ? ` (${FEW_RUNS})` : ""} | ${noCounts(c) ? "–" : `${c.worse} / ${c.warnings} / ${c.better} / ${c.noChange} / ${c.inconclusive}`} | ${sc.dashboard_url ? `[open](${sc.dashboard_url})` : "-"} |`;
-  });
-  return [
-    `### KeepSnappy: ${setWord(v)}`,
-    "",
-    ...setupLine(v.headline) ? [`${setupLine(v.headline)}.`, ""] : [],
-    `\`${s.branch}\`${s.commit_sha ? ` @ \`${s.commit_sha.slice(0, 7)}\`` : ""}, ${s.runs.valid}/${s.runs.total} runs used.${v.low_data ? ` ${FEW_RUNS}.` : ""}`,
-    "",
-    `| Journey | Device | Result | ${STATE_WORDS.worse} / ${STATE_WORDS.warning} / ${STATE_WORDS.better} / ${STATE_WORDS["no-change"]} / ${STATE_WORDS["cant-tell"]} | Details |`,
-    "|---|---|---|---|---|",
-    ...rows,
-    ...contextLines.length ? ["", ...contextLines] : [],
-    ...heated.length ? ["", ...heated.map((note) => `${note}.`)] : [],
-    "",
-    `[Open the dashboard](${s.dashboard_url})`,
-    ""
-  ].join(`
-`);
+  return isPending(s) ? pendingMarkdown(s.branch, linkOf(s) ?? s.dashboard_url) : resultMarkdown(s);
 }
 
 // apps/agent/src/run.ts
@@ -9351,7 +9884,7 @@ function parseArms(spec) {
   return spec.split(",").map((part) => {
     const eq = part.indexOf("=");
     if (eq <= 0)
-      throw new Error(`bad --arms entry "${part}", expected NAME=<app-path-or-bundle-id>`);
+      throw new ConfigError([`bad --arms entry "${part}", expected NAME=<app-path-or-bundle-id>`]);
     return { name: part.slice(0, eq).trim(), target: part.slice(eq + 1).trim() };
   });
 }
@@ -9361,10 +9894,10 @@ function parseArmEnv(specs, arms) {
   for (const spec of specs ?? []) {
     const m = /^([^:=]+):([A-Za-z_][A-Za-z0-9_]*)=(.*)$/s.exec(spec);
     if (!m)
-      throw new Error(`bad --arm-env "${spec}", expected ARM:KEY=VALUE`);
+      throw new ConfigError([`bad --arm-env "${spec}", expected ARM:KEY=VALUE`]);
     const [, arm = "", key = "", value = ""] = m;
     if (!names.has(arm))
-      throw new Error(`--arm-env "${spec}": no arm named ${arm} (arms: ${[...names].join(", ")})`);
+      throw new ConfigError([`--arm-env "${spec}": no arm named ${arm} (arms: ${[...names].join(", ")})`]);
     const e = env.get(arm) ?? {};
     e[key] = value;
     if (!key.startsWith("MAESTRO_"))
@@ -9375,12 +9908,15 @@ function parseArmEnv(specs, arms) {
 }
 
 // apps/agent/src/runner.ts
+var TEST_ERROR = "test-error";
+var TEST_FAILED = "test-failed";
+var failedTest = (reason) => reason.startsWith(`${TEST_FAILED}:`) || reason.startsWith(`${TEST_ERROR}:`);
 var isBuildPath = (target) => !!target && /\.(app|ipa)\/?$/.test(target);
 async function measure(deps, source, installer, opts) {
   const { fs, clock, spawner, log } = deps;
   const flows = opts.flows?.length ? opts.flows : [{ name: undefined, command: opts.testCommand }];
   if (flows.some((f) => !f.command[0]))
-    throw new Error("no test command given (put it after `--`)");
+    throw new ConfigError(["no test command given (put it after `--`)"]);
   await fs.mkdir(opts.outDir);
   const runsPath = join7(opts.outDir, "runs.ndjson");
   await fs.writeFile(runsPath, "");
@@ -9421,9 +9957,9 @@ async function measure(deps, source, installer, opts) {
 --- stderr ---
 ${r.stderr}` : ""}`);
       if (r.error)
-        reason = `test-error: ${r.error}`;
+        reason = `${TEST_ERROR}: ${r.error}`;
       else if (r.code !== 0)
-        reason = `test-failed: exit ${r.code}`;
+        reason = `${TEST_FAILED}: exit ${r.code}`;
     }
     const t1 = clock.now();
     let windows = [];
@@ -9521,7 +10057,7 @@ async function replayRuns(deps, sources, outDir, scenario) {
   const runs = [];
   for (const src of sources) {
     const text = await deps.fs.readFile(join8(src.dir, "runs.ndjson")).catch(() => {
-      throw new Error(`--replay ${src.dir}: no runs.ndjson (not a keepsnappy out dir)`);
+      throw new ConfigError([`--replay ${src.dir}: no runs.ndjson (not a keepsnappy out dir)`]);
     });
     for (const line of text.split(`
 `)) {
@@ -9541,7 +10077,7 @@ async function replayRuns(deps, sources, outDir, scenario) {
     }
   }
   if (runs.length === 0)
-    throw new Error(`--replay: no valid runs in ${sources.map((x) => x.dir + (x.arm ? `:${x.arm}` : "")).join(", ")}`);
+    throw new ConfigError([`--replay: no valid runs in ${sources.map((x) => x.dir + (x.arm ? `:${x.arm}` : "")).join(", ")}`]);
   await deps.fs.writeFile(join8(outDir, "runs.ndjson"), runs.map((r) => JSON.stringify(r)).join(`
 `) + `
 `);
@@ -9555,7 +10091,7 @@ var DEFAULT_API_URL = "https://keepsnappy-api-922918702810.europe-west1.run.app"
 // apps/agent/src/journeys.ts
 import { isAbsolute, relative, resolve as resolve2, sep } from "node:path";
 var charCount = (s) => [...s].length;
-function clip(s, max) {
+function clip2(s, max) {
   if (charCount(s) <= max)
     return s;
   const parts = typeof Intl.Segmenter === "function" ? Array.from(new Intl.Segmenter(undefined, { granularity: "grapheme" }).segment(s), (x) => x.segment) : [...s];
@@ -9589,7 +10125,7 @@ function flowHeader(text) {
     para.push(t);
   }
   const description = para.join(" ").replace(/\s+/g, " ").trim();
-  return { ...title ? { title: clip(title, TITLE_MAX) } : {}, ...description ? { description: clip(description, DESCRIPTION_MAX) } : {} };
+  return { ...title ? { title: clip2(title, TITLE_MAX) } : {}, ...description ? { description: clip2(description, DESCRIPTION_MAX) } : {} };
 }
 async function repoRoot(deps) {
   const r = await deps.spawner.run("git", ["rev-parse", "--show-toplevel"]).catch(() => null);
@@ -9643,10 +10179,11 @@ function baseRefs(env) {
   return target ? [`origin/${target}`] : ["origin/main", "main"];
 }
 var SHA = /^[0-9a-f]{40,64}$/;
+var onMain = (env, branch) => !!branch && baseRefs(env).some((r) => !r.startsWith("-") && r.replace(REMOTE, "") === branch);
 var FIX = "fetch main and the commit, in CI with fetch-depth: 0, or pass --base-commit SHA";
 async function defaultBaseCommit(deps, env, o) {
   const refs = baseRefs(env).filter((r) => !r.startsWith("-"));
-  if (o.branch && refs.some((r) => r.replace(REMOTE, "") === o.branch))
+  if (onMain(env, o.branch))
     return {};
   const tip = o.commit?.trim();
   if (!tip)
@@ -9682,6 +10219,34 @@ async function commitFields(deps, env, shas) {
   const pr = await pullRequestInfo(deps, env);
   return { ...commit ? { commit } : {}, ...base ? { base_commit: base } : {}, ...pr ? { pull_request: { ...pr } } : {} };
 }
+var MAIN_MERGES_LIMIT = 200;
+var SQUASH = /^(.*?)\s*\(#(\d+)\)$/;
+var MERGE = /^Merge pull request #(\d+) from \S+$/;
+function mergeOf(sha, subject, body) {
+  const merge = MERGE.exec(subject);
+  const squash = merge ? null : SQUASH.exec(subject);
+  const number = Number(merge?.[1] ?? squash?.[2] ?? 0);
+  const title = (merge ? body.split(`
+`).find((l) => l.trim())?.trim() : squash?.[1]) || subject.trim() || sha.slice(0, 7);
+  return { sha, ...number > 0 ? { number } : {}, title: Array.from(title).slice(0, 300).join("") };
+}
+async function mainMerges(deps, env, o) {
+  if (!onMain(env, o.branch))
+    return {};
+  const tip = o.commit?.trim();
+  if (!tip || tip.startsWith("-"))
+    return { warning: "main merges not recorded: no commit is recorded for the run set (pass --commit, or run in GitHub Actions)" };
+  const r = await deps.spawner.run("git", ["log", "--first-parent", `--max-count=${MAIN_MERGES_LIMIT}`, "--format=%H%x1f%s%x1f%b%x1e", tip, "--"], { timeoutMs: 1e4 }).catch(() => null);
+  const merges = r && r.code === 0 ? r.stdout.split("\x1E").map((x) => x.replace(/^\n/, "").split("\x1F")).filter(([sha]) => sha && SHA.test(sha)).map(([sha, s, b]) => mergeOf(sha, s ?? "", b ?? "")) : [];
+  if (!merges.length)
+    return { warning: `main merges not recorded: git log ${tip.slice(0, 12)} failed (fetch main and the commit, in CI with fetch-depth: 0)` };
+  if (merges.length < MAIN_MERGES_LIMIT) {
+    const shallow = await deps.spawner.run("git", ["rev-parse", "--is-shallow-repository"], { timeoutMs: 5000 }).catch(() => null);
+    if (shallow?.code === 0 && shallow.stdout.trim() === "true")
+      return { merges, warning: `main merges stop at the clone's depth (${merges.length}): fetch main with fetch-depth: 0 for the PRs of main changes` };
+  }
+  return { merges };
+}
 
 // apps/agent/src/run-command.ts
 var EXIT = { ok: 0, infra: 1, config: 2, worse: 3 };
@@ -9727,7 +10292,7 @@ async function runCommand(deps, o, positionals, rt = { env: process.env, print:
     api = { url, key, ...rt.fetch ? { fetch: rt.fetch } : {} };
   }
   if (o.wait && !o.upload)
-    throw new ConfigError(["--wait needs --upload (the verdict is computed by the server)"]);
+    throw new ConfigError(["--wait needs --upload (it waits until the server has processed the uploaded runs)"]);
   if (o.wait && !git.branch)
     throw new ConfigError(["--wait needs the branch: pass --branch, or run in GitHub Actions (GITHUB_HEAD_REF / GITHUB_REF_NAME)"]);
   if (o["fail-on-worse"] && !o.wait)
@@ -9746,11 +10311,15 @@ async function runCommand(deps, o, positionals, rt = { env: process.env, print:
   let runSet;
   if (api && git.branch) {
     const base = await baseCommitFor(deps, rt.env, { explicit: o["base-commit"], branch: git.branch, commit: git.commit }, rt.print);
+    const main = await mainMerges(deps, rt.env, { branch: git.branch, commit: git.commit });
+    if (main.warning)
+      rt.print(main.warning);
     runSet = await createRunSet(api, {
       branch: git.branch,
       ...git.commit ? { commit_sha: git.commit } : {},
       ...base ? { base_commit_sha: base } : {},
       ...await commitFields(deps, rt.env, { commit: git.commit, base }),
+      ...main.merges ? { merges: main.merges } : {},
       device: { ...device, provider },
       scenarios: flows.map((f) => f.name),
       journeys: await journeysFor(flows, { readFile: (p) => deps.fs.readFile(p), root: await repoRoot(deps) }),
@@ -9792,8 +10361,14 @@ ${outcome.summary}`);
   const info = { device, ...git.branch ? { branch: git.branch } : {}, ...git.commit ? { commit: git.commit } : {} };
   await deps.fs.writeFile(join9(out, RUN_INFO), `${JSON.stringify({ ...info, ...runSet ? { run_set_id: runSet.run_set_id } : {} }, null, 2)}
 `);
-  if (!api)
+  if (!api) {
+    if (!runs.some((run) => run.valid)) {
+      const reasons = [...new Set(runs.map((run) => run.invalid_reason).filter(Boolean))];
+      rt.print(`No valid run was recorded: ${runs.length === 0 ? "no runs were attempted" : `${runs.length} ${runs.length === 1 ? "run" : "runs"} invalid${reasons.length ? ` (${reasons.join(", ")})` : ""}`}.`);
+      return EXIT.infra;
+    }
     return EXIT.ok;
+  }
   const up = await uploadRuns(deps, out, runs, {
     ingestUrl: api.url,
     key: api.key,
@@ -9808,7 +10383,9 @@ ${outcome.summary}`);
   if (up.uploaded === 0) {
     if (runSet)
       await completeRunSet(api, runSet.run_set_id, "on-read").catch(infra("no run was uploaded, and the run set could not be closed"));
-    rt.print("Blocked: no run sent any data. Check that the build carries the SDK and that the app reaches the API.");
+    const failed = up.skipped.length > 0 && up.skipped.every((x) => failedTest(x.why));
+    const why = [...new Set(up.skipped.map((x) => x.why))].join(", ");
+    rt.print(`${BLOCKED_WORD}: no run sent any data. ${failed ? `Every run failed its test command (${why}); see test.log in each run folder of ${out}.` : "Check that the build carries the SDK and that the app reaches the API."}`);
     if (runSet)
       await writeResult(deps, out, rt, runSet, null, git.branch, true);
     return EXIT.infra;
@@ -9817,7 +10394,7 @@ ${outcome.summary}`);
     return EXIT.ok;
   let summary = null;
   if (o.wait) {
-    summary = await completeRunSet(api, runSet.run_set_id, "inline").catch(infra("the runs are uploaded, but the verdict could not be computed"));
+    summary = await completeRunSet(api, runSet.run_set_id, "inline").catch(infra("the runs are uploaded, but the run set could not be closed"));
     rt.print(`
 ${formatRunSet(summary)}`);
   } else {
@@ -9854,10 +10431,7 @@ async function writeResult(deps, out, rt, runSet, summary, branch, blocked = fal
 `);
   const step = rt.env.GITHUB_STEP_SUMMARY;
   if (step)
-    await deps.fs.appendFile(step, blocked ? `### KeepSnappy: Blocked
-
-No run sent any data. [Open the dashboard](${url})
-` : markdownRunSet(summary, { dashboardUrl: url, branch }));
+    await deps.fs.appendFile(step, blocked ? noResultMarkdown(branch, "No run sent any data.", url) : markdownRunSet(summary, { dashboardUrl: url, branch }));
 }
 
 // apps/agent/src/doctor.ts
@@ -10319,7 +10893,7 @@ import { existsSync, readFileSync, statSync } from "node:fs";
 import { dirname as dirname2, join as join11, relative as relative2, resolve as resolve4 } from "node:path";
 import { fileURLToPath } from "node:url";
 function driverVersion() {
-  const built = "0.1.0-alpha.17";
+  const built = "0.1.0-alpha.19";
   if (built)
     return built;
   let dir = dirname2(fileURLToPath(import.meta.url));
@@ -10374,6 +10948,600 @@ var SDK_FLUSH_WORST_CASE_MS = 315000;
 var FLUSH_MARGIN_MS = 30000;
 var FLUSH_WAIT_MS = SDK_FLUSH_WORST_CASE_MS + FLUSH_MARGIN_MS;
 var FLUSH_STATUSES = new Set(["ok", "error", "off"]);
+// packages/verdict-core/dist/src/window-count.js
+var WINDOW_DEPENDENT_JOURNEY_MEASURES = ["sampler.cpu_ms", "sampler.frames.longest_gap_ms"];
+var OFF = new WeakSet;
+// packages/verdict-core/dist/src/clauses.js
+var row = (id, what, unit, cmp, ruling, uncalibrated, value) => ({ id, what, unit, cmp, ruling, uncalibrated, value });
+var NO_RULING = "no ruling: a starting value of the deciding config (L2 audit F-13)";
+var FLOOR = { rel: 0.3, abs: 5 };
+var COMPONENT_WARN_MS = { update: 5, work: 10 };
+var CLAUSES = {
+  "G-MINRUNS": row("G-MINRUNS", `Valid runs a side needs to be compared at all; fewer is "Can't tell: too few runs".`, "runs", "≥", "no ruling for the deciding config (L2 audit G-MINRUNS)", true, { runs: 2 }),
+  "B-BASELINE": row("B-BASELINE", "The baseline is main's newest sessions on the same phone, journey and renderer.", "sessions", "≥", "REQ-VER-33 (Q4); the number is a starting value", true, { sessions: 3 }),
+  "M-LEVELSHIFT": row("M-LEVELSHIFT", "A change on main is confirmed when this many following main sessions agree.", "sessions", "≥", "REQ-VER-33, plan 63 §3 (controller 2026-10-17)", false, { confirmSessions: 2 }),
+  "S-UNCERTAIN": row("S-UNCERTAIN", "A worse result is uncertain and does not block while main has fewer sessions than this.", "sessions", "≥", 'REQ-VER-38, Arek 2026-10-16 "Nie blokuj przy małej bazie"', false, { belowMainSessions: 3 }),
+  "G-JUDGE-FROM": row("G-JUDGE-FROM", "A phone or simulator is judged only with at least this many main sessions.", "sessions", "≥", "REQ-VER-41, Arek 2026-10-18", false, { mainSessions: 3 }),
+  "W-WORKKIND": row("W-WORKKIND", "The share of render time spent mounting from which a place is an in-screen mount, not an update.", "share", "≥", "REQ-MET-25; TraceSift MOUNT_DOMINANT_SHARE", true, { mountShareAtLeast: 0.8 }),
+  "W-WINDOW-COUNT": row("W-WINDOW-COUNT", "A PR run that opened fewer windows on a screen than this share of main's median there leaves that screen (its taps, scrolls and steps) and the journey's window-dependent totals out of its comparisons.", "share", "≥", "plan 51 D2 floor (90 % of the usual window count), Arek 2026-10-22 ~07:20, per screen (plan 79 S8)", false, { below: 0.9 }),
+  "T-FRAME": row("T-FRAME", "One frame, the unit of every frame limit, the same on every screen (a 120 Hz phone is not held to 8.3 ms).", "ms", ">", "REQ-MET-23, Arek 2026-10-16", false, { ms: LIMIT_FRAME_MS }),
+  "C-DETAIL-MS": row("C-DETAIL-MS", "A component below this keeps key and ms only and is not listed as New or Removed.", "ms", "≥", "plan 79 S9 r2, Arek 2026-10-23 13:20; half the lowest component rule floor (judged and evidence)", false, { ms: Math.min(FLOOR.abs, COMPONENT_WARN_MS.update, COMPONENT_WARN_MS.work) / 2 }),
+  "T-WARN-MS": row("T-WARN-MS", "A judged change counts as Slightly worse past at least this many ms (an update, or an entry / in-screen mount).", "ms", ">", "REQ-MET-26 (Arek 2026-10-16 ~14:30, ~17:30); followups [RULED 2026-10-18 ~09:40]", false, COMPONENT_WARN_MS),
+  "TIER-ERROR": row("TIER-ERROR", "A judged change is Worse past at least this many ms (an update, or an entry / in-screen mount).", "ms", ">", "REQ-MET-26 (Arek 2026-10-16 ~17:30); over the 100 ms budget alone is only a warning (Arek 2026-10-17)", false, { update: 15, work: 30 }),
+  "S-BETTER": row("S-BETTER", "Nothing worse and a judged improvement past the Worse line measured from main reads Better; the same magnitude must make a regression Worse. Applies to timing noise curves and memory thresholds.", "", null, "REQ-VER-47; Arek 2026-10-22 ~15:35, option 1 (standing-rulings.md): Better only past the Worse line; controller review ruling 2026-10-22: measure from main using the same timing noise and memory thresholds as Worse; no new number", false, { from: "error-tier" }),
+  "T-WARN-NOISE": row("T-WARN-NOISE", "No-change noise curve per judged measure: Slightly worse past c x k95 x sqrt(main), Worse past c x k99 x sqrt(main).", "ms", ">", 'Arek 2026-10-16 "Ok" (the relative part adapts to size), 2026-10-18 ~09:40 (k95 warns, k99 errs); docs/stats/noise/2026-10-16-noise-fit.md "Result to encode"', false, {
+    render: { c: 0.9244, k95: 1.5678, k99: 2.2255 },
+    commit: { c: 0.8326, k95: 1.7675, k99: 2.8108 },
+    component: { c: 0.6481, k95: 1.8075, k99: 2.6648 }
+  }),
+  "T-NOISE-JANK": row("T-NOISE-JANK", "The judged `jank` rule: the no-change noise curve of jank time, as T-WARN-NOISE; at a main median of 0, Slightly worse past zeroWarn and Worse past zeroError.", "ms", ">", "W8 option A, Arek 2026-10-26 [ctl-arek-jank-time]; fitted by the 2026-10-16 method (dedup-nomi, PR 3x3 vs main 3x3, every split) on pack v3 aa-ni (S23 TapIn, 10 sessions, 4200 splits, 19 places with a median above 0, R² -0.27; the 10-16 S23 and iPhone sessions are no longer stored); zeroWarn = the largest d99 at a median of 0 over the A/A pools with an export (farm16 Pixel 7), zeroError = zeroWarn x k99 / k95", true, {
+    jank: { c: 0.9159, k95: 2.5757, k99: 3.2072, zeroWarn: 10.38, zeroError: 12.92 }
+  }),
+  "T-REL": row("T-REL", "The relative part of both tiers when a rule has no noise curve; the deciding config's tiers cap it at the error ms, so no input reaches it.", "share", ">", "REQ-MET-26, controller 2026-10-16", false, { rel: 0.3 }),
+  "J-MEMORY-RETAINED": row("J-MEMORY-RETAINED", "Memory the journey kept after the end GC: Slightly worse past max(warn MB, warn % of main), Worse past max(error MB, error % of main), on every device.", "MB", ">", "REQ-MET-4, Arek 2026-10-20 ~08:00, pair B (standing-rulings.md); provisional", true, { warn: { abs: 20, rel: 0.1 }, error: { abs: 150, rel: 0.3 } }),
+  "E-REACT-COUNTS": row("E-REACT-COUNTS", "Commit and render counts are evidence past max(floor, +50 % of main).", "count", ">", "REQ-MET-13, Arek 2026-10-20 (morning rulings, Layer 2); provisional", true, { commits: { rel: 0.5, abs: 2 }, renders: { rel: 0.5, abs: 10 } }),
+  "E-RENDER-UPPER": row("E-RENDER-UPPER", "Timer-carried render time is evidence past max(floor, % of main).", "ms", ">", "REQ-MEAS-32 option A (Arek 2026-10-17); the number has no ruling", true, { render_upper: FLOOR }),
+  "E-BACKGROUND": row("E-BACKGROUND", "Background places are evidence past max(floor, % of main).", "ms", ">", "REQ-MEAS-32; the number has no ruling", true, { background_commit: FLOOR, background_render: FLOOR, background_component: FLOOR }),
+  "E-LAUNCH": row("E-LAUNCH", "The launch screen is evidence past max(5 ms, +30 % of main).", "ms", ">", "REQ-VER-15; floor adopted 2026-10-21 from config.ts F-13, [ctl-stab-noold-1625]", true, { launch_commit: FLOOR, launch_render: FLOOR, launch_component: FLOOR }),
+  "E-STEP": row("E-STEP", "A declared step is evidence past max(5 ms, +30 % of main).", "ms", ">", "REQ-MET-14; floor adopted 2026-10-21 from config.ts F-13, [ctl-stab-noold-1625]", true, { step_commit: FLOOR, step_render: FLOOR, step_component: FLOOR }),
+  "E-COMMIT-MAX": row("E-COMMIT-MAX", "The slowest commit at a judged window is evidence past max(5 ms, +30 % of main) while jank time is judged.", "ms", ">", "W8 option A, Arek 2026-10-26 [ctl-arek-jank-time]: commit_max_ms stays shown as evidence", true, { commit_max: FLOOR }),
+  "E-TOUCH": row("E-TOUCH", "Touch response is evidence past max(10 ms, +20 % of main).", "ms", ">", 'ruling "touch response is not judged" (REQ-MET-24)', true, { touch: { rel: 0.2, abs: 10 } }),
+  "E-FREEZE": row("E-FREEZE", "The longest freeze (window, journey) is evidence past max(17 ms, +50 % of main).", "ms", ">", NO_RULING, true, { freeze: { rel: 0.5, abs: 17 }, freeze_journey: { rel: 0.5, abs: 17 } }),
+  "E-MEMORY-PLACE": row("E-MEMORY-PLACE", "Memory added at a place is evidence past this many MB (screens have their own), on every device.", "MB", ">", 'REQ-MET-4 amendment 2026-10-18 ~21:10 and ~22:20 ("abs 2 MB, screens 10 MB")', true, { memory_added: { abs: 2 }, memory_added_screen: { abs: 10 } }),
+  "E-MEMORY-JOURNEY": row("E-MEMORY-JOURNEY", "Memory at launch, end growth and peak growth are evidence past max(2 MB, +8 % of main).", "MB", ">", NO_RULING, true, { memory_launch: { rel: 0.08, abs: 2 }, memory_end_growth: { rel: 0.08, abs: 2 }, memory_peak_growth: { rel: 0.08, abs: 2 } }),
+  "E-CPU-JOURNEY": row("E-CPU-JOURNEY", "Whole-journey CPU is evidence past +5 % of main.", "ms (relative part only)", ">", 'no ruling: "a +10 % whole-app CPU change must show as evidence"', true, { cpu: { rel: 0.05 } }),
+  "E-WINDOW-LOAD": row("E-WINDOW-LOAD", "Window CPU, long tasks, GC time, requests and JS CPU are evidence past max(floor, % of main).", "ms (requests: count)", ">", NO_RULING, true, {
+    window_cpu: { rel: 0.5, abs: 20 },
+    long_tasks: { rel: 0.3, abs: 50 },
+    gc: { rel: 0.5, abs: 2 },
+    requests: { rel: 0.5, abs: 1 },
+    js_cpu: { rel: 0.5, abs: 5 }
+  }),
+  "P-SLOW-COMMIT": row("P-SLOW-COMMIT", "Single problem: the slowest commit over this many frames in every PR run, on phones.", "frames", ">", "REQ-MET-27, Arek 2026-10-16 (a commit over one 60 Hz frame drops below 60 fps)", true, { frames: 1 }),
+  "P-HEAVY-COMPONENT": row("P-HEAVY-COMPONENT", "Single problem: a component's self time over this many frames in every PR run, on phones.", "frames", ">", "REQ-MET-27, Arek 2026-10-16", true, { frames: 1 }),
+  "P-HEAVY-ENTRY": row("P-HEAVY-ENTRY", "Single problem: React render time over this budget in every PR run at an entry or in-screen mount; also the budget of both kinds of work.", "ms", ">", "REQ-MET-25 ruling d (about 100 ms)", true, { ms: 100 }),
+  "P-BUDGETS": row("P-BUDGETS", "The budget of an update, shown with a single problem, in frames.", "frames", ">", "REQ-MET-25 ruling d", true, { updateFrames: 1 }),
+  "U-NOISY": row("U-NOISY", "A place is unstable on main above this ratio of spread to allowed, and stays so down to `below`; from this many main runs in this many sessions.", "ratio", ">", "REQ-MET-29, Arek 2026-10-18 ~12:00-13:20; thresholds provisional", false, { above: 1, below: 0.75, minMainRuns: 6, minSessions: 3 })
+};
+var CLAUSE_LIST = Object.values(CLAUSES);
+// packages/verdict-core/dist/src/config.js
+var WINDOWS = ["screen", "press", "drag", "step", "other"];
+var STEP = ["step"];
+var JUDGED_WINDOWS = WINDOWS.filter((k) => !STEP.includes(k));
+var BACKGROUND = ["background"];
+var LAUNCH = ["launch"];
+var SHOWN2 = [...WINDOWS, ...LAUNCH];
+var REACT_PLACES = [...SHOWN2, ...BACKGROUND];
+var JOURNEY = ["journey"];
+var DEVICE = ["device"];
+var ANY_DEVICE = ["device", "sim"];
+var ENTRY_BUDGET_MS = 100;
+var UNCERTAIN_BELOW_MAIN_SESSIONS = 3;
+var GUESS = (from) => ({ uncalibrated: true, source: `${from}; starting value carried from the plan 58 table (today's warn value), plan 57 calibrates it` });
+var evidenceRule = (id, on, places, threshold, from, more = {}) => ({
+  id,
+  role: "evidence",
+  on,
+  places,
+  devices: DEVICE,
+  threshold,
+  ...GUESS(from),
+  ...more
+});
+var MEMORY_MEASURES = Object.keys(MEASURES).filter((id) => MEASURES[id].unit.startsWith("MB"));
+var REACT_MEASURES = [
+  "commit_max_ms",
+  "render_ms",
+  "commits",
+  "renders",
+  "mounts",
+  "commits_over_budget",
+  "mount_share",
+  "self_ms_top",
+  "component_ms",
+  "dimension:component",
+  "dimension:updater",
+  "jank_ms"
+];
+var WINDOW_MODEL_AFFECTS = [
+  "commits",
+  "renders",
+  "mounts",
+  "alloc_mb",
+  "gc_count",
+  "gc_ms",
+  "render_ms",
+  "js_cpu_ms",
+  "cpu_ms",
+  "commit_max_ms",
+  "commits_over_budget",
+  "longtask_ms",
+  "longtask_max_ms",
+  "touch_max_ms",
+  "net_requests",
+  "net_duplicates",
+  "dur_ms",
+  "sampler_frames_missed",
+  "sampler_footprint_delta_mb",
+  "memory_left_mb",
+  "retained_mb_per_cycle",
+  "dimension:component",
+  "dimension:updater",
+  "jank_ms"
+];
+var MEASURES_AT = (kind) => [...Object.keys(MEASURES).filter((id) => MEASURES[id].at.includes(kind)), "dimension:component", "dimension:updater"];
+var SPLIT_AFFECTS = [
+  ...REACT_MEASURES,
+  ...Object.keys(MEASURES).filter((id) => /^(commits_over_|slow_commit_|mount_share_|unsettled_commit_)/.test(id))
+];
+var GC_STEP_AFFECTS = [
+  "gc_heap_before_mb",
+  "gc_heap_kept_mb",
+  "gc_heap_garbage_mb",
+  "gc_memory_before_mb",
+  "gc_memory_after_mb",
+  "gc_memory_step_added_mb",
+  "gc_memory_kept_mb",
+  "gc_command_ms",
+  "gc_queue_ms"
+];
+var SAMPLER_EDGE_AFFECTS = [
+  "cpu_ms",
+  "sampler.cpu_ms",
+  "sampler_frames_missed",
+  "sampler_longest_gap_ms",
+  "sampler.frames.longest_gap_ms",
+  "sampler.frames.missed",
+  "sampler.frames.presented",
+  ...MEMORY_MEASURES.filter((m) => !GC_STEP_AFFECTS.includes(m))
+];
+var DRAG_TIME_AND_CPU = ["dur_ms", "action_span_ms", "next_input_gap_ms", "action_uncovered_ms", "cpu_ms", "main_thread_ms", "sampler_cpu_cores", "js_cpu_ms", "js_thread_ms", "js_thread_app_ms"];
+var LOADED_MEMORY = Object.keys(MEASURES).filter((id) => /^(mem|sampler\.memory|ri\.memory)\./.test(id) || id === "memory_left_mb");
+var END_READ_DECLARES = [{ affects: ["mem.retained_growth_mb", "mem.end_after_gc_mb"], places: ["journey"] }];
+var END_READ_SOURCE = `plan 78 G4/G5, Arek 2026-10-21 (D5, "po GC powinniśmy robić manualny odczyt pamięci"): right after the end GC the driver asks the SDK for one memory reading (derivation 23, docs/design/endgc-manual-memory-read.md); memory kept is that reading minus launch, not the GC's own post record. REQ-FARM-35`;
+var PLACE_KEY_KINDS = ["screen", "launch", "press", "drag"];
+var SDK_A17_PLACES = ["screen", "press", "drag", "step"];
+var SDK_RELEASES = [
+  {
+    version: "0.1.0-alpha.9",
+    previous: "0.1.0-alpha.8",
+    declares: [{ affects: WINDOW_MODEL_AFFECTS, places: ["press", "drag"] }, { affects: ["mount_share", "mount_share_min", "mount_share_max"] }],
+    uncalibrated: false,
+    source: 'packages/react-native/CHANGELOG.md "window model 2" and "mountSelfMs"; git merge-base --is-ancestor 988945d / 5995729 v0.1.0-alpha.9 (yes), v0.1.0-alpha.8 (no)'
+  },
+  {
+    version: "0.1.0-alpha.10",
+    previous: "0.1.0-alpha.9",
+    declares: [{ affects: SAMPLER_EDGE_AFFECTS }],
+    uncalibrated: false,
+    source: 'packages/react-native/CHANGELOG.md 0.1.0-alpha.10 "a sample at every window edge"; git merge-base --is-ancestor 7331c8f v0.1.0-alpha.10 (yes), v0.1.0-alpha.9 (no)'
+  },
+  {
+    version: "0.1.0-alpha.11",
+    previous: "0.1.0-alpha.10",
+    declares: [
+      { affects: MEASURES_AT("screen"), places: ["screen"] },
+      { affects: SPLIT_AFFECTS, places: WINDOWS },
+      { affects: MEASURES_AT("launch"), places: LAUNCH },
+      { affects: GC_STEP_AFFECTS, places: ["step"] }
+    ],
+    uncalibrated: false,
+    source: `pending release: window model 3, screen windows end at the next action with no 3 s cap (REQ-MEAS-12, packages/react-native/CHANGELOG.md; commits 741c36a and 62c0107 on main, not in v0.1.0-alpha.10); work split by its cause, every window's React measures are its judged part (REQ-MEAS-32, CHANGELOG "work is split by its cause", branch feat/action-causes-d16); the launch screen starts when the app starts a surface (REQ-MEAS-22, same branch); screen windows start at the action that caused them, with no time limits (REQ-MEAS-28, same branch); the GC command before a declared step adds the gc_* step rows (docs/plans/gc-before-action.md, branch feat/gc-before-action)`
+  },
+  {
+    version: "0.1.0-alpha.12",
+    previous: "0.1.0-alpha.11",
+    declares: [{ affects: [...new Set([...MEASURES_AT("press"), ...MEASURES_AT("drag")])], places: ["press", "drag"] }],
+    uncalibrated: false,
+    source: 'packages/react-native/CHANGELOG.md 0.1.0-alpha.12 "Drag names that hold across runs, and flings on a moving list": back-to-back flings on a moving list are drags, not presses (`press:<row>` becomes `drag:<list>`), and generated list ids are no longer names; those press and drag places are not comparable across the change. Arek 2026-10-21 (A/A "Slightly worse" decision, Q-10): alpha.12 declares this rename; nothing else in it changes a measure (REQ-FARM-35).',
+    renamed: { places: ["press", "drag"] }
+  },
+  {
+    version: "0.1.0-alpha.13",
+    previous: "0.1.0-alpha.12",
+    declares: "nothing",
+    uncalibrated: false,
+    source: 'KeepSnappy native module, capture protocol and artifact naming; measurement calculations unchanged from alpha.12 (REQ-FARM-35, Arek 2026-10-19: declared "changes nothing"). Requires rebuilt native clients and coordinated server migration (docs/keepsnappy-migration.md).'
+  },
+  {
+    version: "0.1.0-alpha.14",
+    previous: "0.1.0-alpha.13",
+    declares: END_READ_DECLARES,
+    uncalibrated: false,
+    source: `SDK answers the driver's memread command with one sample (reason endgc-read:<n>); ${END_READ_SOURCE}. Nothing else since alpha.13 changes a measure: the flush always ends and is acknowledged (#140), local builds carry +local (#147), each "Not an instrument change" in packages/react-native/CHANGELOG.md`
+  },
+  {
+    version: "0.1.0-alpha.15",
+    previous: "0.1.0-alpha.14",
+    declares: "nothing",
+    uncalibrated: false,
+    source: "Shared release version only: git log v0.1.0-alpha.14..main -- packages/react-native is empty; SDK capture and measurement calculations are unchanged from alpha.14 (REQ-FARM-35)."
+  },
+  {
+    version: "0.1.0-alpha.16",
+    previous: "0.1.0-alpha.15",
+    declares: [
+      { affects: ["dimension:component", "dimension:updater", "self_ms_top", "component_ms"] },
+      { affects: [...new Set(PLACE_KEY_KINDS.flatMap((k) => MEASURES_AT(k)))], places: PLACE_KEY_KINDS }
+    ],
+    renamed: { places: PLACE_KEY_KINDS, dimensions: ["component", "updater"] },
+    uncalibrated: false,
+    source: "plan 79 (docs/plans/79-ui-change-flexibility.md): client component keys with library time rolled up; places keyed by client components (D4, Arek 2026-10-21 ~19:15 and 2026-10-22 ~19:20); S9: every client component retained by value, compact detail below C-DETAIL-MS, SDK omission and derivation-26 completeness"
+  },
+  {
+    version: "0.1.0-alpha.17",
+    previous: "0.1.0-alpha.16",
+    declares: [
+      { affects: [...new Set(SDK_A17_PLACES.flatMap((k) => MEASURES_AT(k)))], places: SDK_A17_PLACES },
+      { affects: [...WINDOW_DEPENDENT_JOURNEY_MEASURES], places: ["journey"] }
+    ],
+    renamed: { places: ["screen", "press", "drag"] },
+    uncalibrated: false,
+    source: "#277 (plan 74 step 4 SDK review): screen windows end at every touch delivered while open; late-mounting screens keep their component key (3-commit cap gone), so screen keys and the press/drag keys on them change; the run commit stream is cut at the flush, not inside a window (window times of long journeys and journey CPU change); a gesture whose touchEnd never reached JS moves press → drag; a late press takes its own open sample (press sampler measures). Flush answers lost data as error (validity only, no measure). Launch and journey memory stay compared."
+  }
+];
+var DRIVER_RELEASES = [
+  {
+    version: "0.1.0-alpha.12",
+    previous: "0.1.0-alpha.11",
+    declares: "nothing",
+    uncalibrated: false,
+    source: 'Host clock round trips each run (c1a430ed): the clock error falls from 126-197 ms on the S23, so step edges line up better; a stale element is looked up again; flingTimes, flingUntil, stableCentres and tapAt added for journeys. REQ-FARM-35, Arek 2026-10-19 ~21:40 (standing-rulings): declared "changes nothing" although it holds c1a430ed.'
+  },
+  {
+    version: "0.1.0-alpha.13",
+    previous: "0.1.0-alpha.12",
+    declares: "nothing",
+    uncalibrated: false,
+    source: 'KeepSnappy link route, flush and GC answer element names and Android command name (the protocol cutover, docs/keepsnappy-migration.md); timing and touches unchanged. REQ-FARM-35, Arek 2026-10-19: declared "changes nothing".'
+  },
+  {
+    version: "0.1.0-alpha.14",
+    previous: "0.1.0-alpha.13",
+    declares: END_READ_DECLARES,
+    uncalibrated: false,
+    source: `driver sends memread after the end GC's answer and waits for its answer before the flush; ${END_READ_SOURCE}. Nothing else since alpha.13 changes a measure: the flush is re-sent once and an unacknowledged flush fails the run (#140), driver-log.json is written as the run goes (#157), each "Not an instrument change" in packages/appium-driver/CHANGELOG.md`
+  },
+  {
+    version: "0.1.0-alpha.15",
+    previous: "0.1.0-alpha.14",
+    declares: "nothing",
+    uncalibrated: false,
+    source: "Activation settles for 2 s before the journey relaunch (be050585, #167, ACTIVATION_SETTLE_MS); absent Android attributes read as null (3fed6c8c, #159). The delay is before the measured journey; attribute normalization is element lookup and post-window acknowledgement handling. No window edge, touch, GC, memory read or flush timing changes (REQ-FARM-35)."
+  },
+  {
+    version: "0.1.0-alpha.16",
+    previous: "0.1.0-alpha.15",
+    declares: "nothing",
+    uncalibrated: false,
+    source: '#260 list and gesture helpers in appium-driver (not in the run path; adopting modules send identical gestures; CHANGELOG "Not an instrument change"); #211 driver.unit is evidence only (meta.device_unit). No window edge, touch, GC, memory read or flush timing changes (REQ-FARM-35).'
+  },
+  {
+    version: "0.1.0-alpha.17",
+    previous: "0.1.0-alpha.16",
+    declares: [
+      { affects: MEASURES_AT("drag"), places: ["drag"] },
+      { affects: MEASURES_AT("step"), places: ["step"] },
+      { affects: LOADED_MEMORY }
+    ],
+    uncalibrated: false,
+    source: "Drag end points move above the platform bottom system-gesture zone (fix/driver-gesture-zone); start points unchanged; on iOS a shortened drag keeps its duration (slower); on Android it keeps its speed (ends sooner). A drag's end, and the duration of a step whose scroll steps contain such drags, can change. W1 (#306): farm sessions record no video or device logs by default (`--capture off`), so the phone carries less load and every memory measure (mem.*, memory_left_mb, sampler.memory.*, ri.memory.*) is measured differently from capture-on alpha.16 sessions (Elastyczność 2026-10-26 15:45 B1-DIFF; controller Stab 4). The declaration only separates alpha.16 from alpha.17: two alpha.17 sessions with capture on and off still compare unflagged until the run's setup.capture (#344) is judged (follow-up). Screens and taps stay compared (REQ-FARM-35)."
+  },
+  {
+    version: "0.1.0-alpha.18",
+    previous: "0.1.0-alpha.17",
+    declares: [{ affects: DRAG_TIME_AND_CPU, places: ["drag"], platforms: ["ios"] }],
+    uncalibrated: false,
+    source: "R-SCROLL-BUILD (#355 one scroll primitive and the counted gesture retry, #356 the scroll fault matrix). Android declares nothing: on a phone that takes every gesture the driver sends the same requests, bodies and waits as alpha.17 (the whole command stream is pinned). iOS: each checked drag (every to-top drag of flingUntilShown/passChecked and the first drag of each scrollToEnd pass) gains two frame reads of the held row, one right before and one right after it, so a drag window's time and CPU can change; its React render, commits and memory stay compared. A phone that drops a gesture (BrowserStack Galaxy S23, S25 Ultra) gets that gesture once more, as a counted harness defect (REQ-FARM-35)."
+  },
+  {
+    version: "0.1.0-alpha.19",
+    previous: "0.1.0-alpha.18",
+    declares: [
+      { affects: MEASURES_AT("drag"), places: ["drag"], platforms: ["ios"] },
+      { affects: MEASURES_AT("step"), places: ["step"], platforms: ["ios"] }
+    ],
+    uncalibrated: false,
+    source: "#393 (fix/keepsnappy-clamped-row-drag-travel, appium-driver CHANGELOG 2026-10-27): on iOS a row-to-top drag whose end safeBottomY clamps (chat history on every iPhone with a home indicator) starts 33 pt higher, so it travels 33 pt further in the same 400 ms (a faster release, a longer coast), with one list lookup and two frame reads right before it. Every measure of that drag window can move, React work included (more rows scroll by), and so can the step whose scroll steps contain it. Android and unclamped drags send the same requests as alpha.18 (pinned): declares nothing there (REQ-FARM-35)."
+  }
+];
+var UNSTABLE_NOISY = {
+  reason: "noisy",
+  spread: "sessions",
+  robust: true,
+  between: false,
+  above: 1,
+  below: 0.75,
+  minMainRuns: 6,
+  minSessions: 3,
+  curve: { render: 0.9244, commit: 0.8326, component: 0.6481 },
+  uncalibrated: false,
+  source: 'Arek 2026-10-18 ~12:00, ~12:20 (noisy on main = unstable, main only, per comparison, hysteresis), 12:50 (within-session spread only: a regression that lands on main moves whole sessions and must stay judged), 13:20 ("zrób na razie wg rekomendacji"; threshold provisional). ' + "Ratio = z99 x the predicted no-change difference SD from the pooled within-session MAD of main (Var(median) = (pi/2) sigma^2 / n) / the smallest warning step at main's median. " + "Replay (noisy/REPORT.md, derivation 22, 1 PR vs 3 main): S23 night 2 -> 1 false worse z 60 (MAD rule 0), sim 0, NI pool 95 -> 64 warnings z 840 (MAD 92); 3 vs 3 0 everywhere; flagged per split S23 17.8, NI 4.9, sim 0.7; judged per split S23 64.5 -> 46.8; flips S23 8 (MAD 21); planted main steps flagged noisy 0 (MAD 5-29 %, with the between-session part 56-99 %). " + "Curve: kept for the judged-rule lookup; the ratio uses the warning step"
+};
+
+class ConfigError2 extends Error {
+  problems;
+  constructor(problems) {
+    super(`invalid verdict config: ${problems.join("; ")}`);
+    this.problems = problems;
+    this.name = "ConfigError";
+  }
+}
+var noRow = (id) => {
+  throw new ConfigError2([`${id}: no row in the clause table`]);
+};
+var NOISE_FITS = { ...CLAUSES["T-WARN-NOISE"].value, ...CLAUSES["T-NOISE-JANK"].value };
+var TIER_REL = 0.3;
+var TIER_UPDATE_MS = { warnMs: 5, errorMs: 15 };
+var TIER_WORK_MS = { warnMs: 10, errorMs: 30 };
+var NOISE_SOURCE = 'Arek 2026-10-16 "Ok" (the relative part adapts to size, "przy małych pomiarach 50 %, przy coraz większych stopniowo coraz mniejszy"; sqrt form, one curve per measure and the two lifts chosen by the controller): ' + 'keepsnappy-measure scratchpad/measure/noise/fit.md "Result to encode" (scripts fit.py MODE=dedup-nomi, lifts.py). Data: S23 TapIn live-ui-appium 11 sessions x 3 (A/A 6073ac76, c86689e2, 4a784c05, f8d36522, 6814be6b; #1 b6d080ec, 52f47229, df55466a; #2 2a55a595, ab33b26e, 3042c714; changed places removed) and iPhone 15 Pro Appium A/A 6 x 3 (a18884dd, 9e364887, c775eab0, d45eb2c1, d3637624, b745fa1c), derivation 14; one place per window (+3s twins and one-window steps dropped), press:new-messages-indicator and its step left out (pushed chat, external work); 41 S23 and 40 iPhone places. ' + "R² of c x sqrt(m) before the dedup (fit.md §2): render 0.66, commit 0.44, component 0.42 (fitted on self_ms_top, the largest component); the dedup moves c by at most 0.03. Places above the lifted curve, S23 / iPhone: k95 render 0 z 41 / 4 z 40, commit 1 / 3, component 2 / 2; k99 render 0 / 1, commit 0 / 1, component 0 / 1. " + "Limits: the iPhone is not fully inside at k95; the iPhone set has 6 sessions (20 splits per place), SDK alpha.7 and window model 1; no split by kind of work";
+var CAPPED_SOURCE = 'Arek 2026-10-16 ~23:00 "Ok" (followups "[RULED 2026-10-16 ~23:00]"): REQ-MET-26 tiers, the relative part min(30 % of base, error tier ms) of the ~19:00 session-bar ruling, on all three judged measures (~17:50); the 30 % and the ms are not calibrated';
+var TIERS_SOURCE = 'REQ-MET-26: update error past 15 ms, entry and mount past 30 ms; going over the 100 ms limit is a warning, not an error (Arek 2026-10-17, followups 530fb5a: "Sam w sobie nie, to raczej ostrzeżenie"); same numbers as the pairs candidate (tiers2 BASE_LEVELS)';
+var MEMORY_PAIR_SOURCE = "REQ-MET-4, Arek 2026-10-20 ~08:00, standing-rulings.md pair B: Slightly worse above max(20 MB, 10 % of main), Worse above max(150 MB, 30 %); provisional, one rule for every device; docs/stats/memory/2026-10-20-memory-kept-two-thresholds.md";
+var COUNT_SOURCE = "REQ-MET-13, Arek 2026-10-20 ruling (docs/handoffs/2026-10-20-morning-rulings.md, Layer 2): counts are evidence only; commits above max(50 %, +2), renders above max(50 %, +10); provisional, not calibrated";
+var noiseJudged = (id, on) => {
+  const fit = NOISE_FITS[id] ?? noRow(id);
+  const noise = { a: 0, b: fit.c, power: 0.5, lift: fit.k95 };
+  return {
+    id,
+    role: "judged",
+    on,
+    places: JUDGED_WINDOWS,
+    devices: ANY_DEVICE,
+    threshold: [{ abs: TIER_UPDATE_MS.warnMs, noise }],
+    uncalibrated: false,
+    source: `k95 lift ${fit.k95}, error tier k99 lift ${fit.k99}, c ${fit.c}; ${NOISE_SOURCE}`,
+    thresholdByWork: { entry: [{ abs: TIER_WORK_MS.warnMs, noise }], mount: [{ abs: TIER_WORK_MS.warnMs, noise }] },
+    errorNoise: { ...noise, lift: fit.k99 }
+  };
+};
+var part = (b) => ({ ...b.rel !== undefined ? { rel: b.rel } : {}, ...b.abs !== undefined ? { abs: b.abs } : {} });
+var EVIDENCE_BARS = new Map(Object.values(CLAUSES).filter((c) => c.id.startsWith("E-")).flatMap((c) => Object.entries(c.value).map(([rule, bar]) => [rule, { bar, uncalibrated: c.uncalibrated }])));
+function withClauseValues(base) {
+  if (!base.better)
+    throw new ConfigError2(["better: missing from base config"]);
+  const warnMs = CLAUSES["T-WARN-MS"].value;
+  const errorMs = CLAUSES["TIER-ERROR"].value;
+  const memory = CLAUSES["J-MEMORY-RETAINED"];
+  const judgedByNoise = (r) => {
+    const fit = NOISE_FITS[r.id] ?? noRow(r.id);
+    const n = { a: 0, b: fit.c, power: 0.5, lift: fit.k95, ...fit.zeroWarn !== undefined ? { atZero: fit.zeroWarn } : {} };
+    return {
+      ...r,
+      threshold: [{ abs: warnMs.update, noise: n }],
+      thresholdByWork: { entry: [{ abs: warnMs.work, noise: n }], mount: [{ abs: warnMs.work, noise: n }] },
+      errorNoise: { a: 0, b: fit.c, power: 0.5, lift: fit.k99, ...fit.zeroError !== undefined ? { atZero: fit.zeroError } : {} },
+      uncalibrated: (r.id in CLAUSES["T-NOISE-JANK"].value ? CLAUSES["T-NOISE-JANK"] : CLAUSES["T-WARN-NOISE"]).uncalibrated
+    };
+  };
+  const evidence = (r) => {
+    const e = EVIDENCE_BARS.get(r.id) ?? noRow(r.id);
+    const at = r.thresholdAt && Object.fromEntries(Object.keys(r.thresholdAt).map((kind) => [kind, [part((EVIDENCE_BARS.get(`${r.id}_${kind}`) ?? noRow(`${r.id}_${kind}`)).bar)]]));
+    return { ...r, threshold: [part(e.bar)], ...at ? { thresholdAt: at } : {}, uncalibrated: e.uncalibrated };
+  };
+  const valued = (r) => {
+    if (r.id === "memory_retained")
+      return { ...r, threshold: [part(memory.value.warn)], uncalibrated: memory.uncalibrated };
+    return r.role === "judged" ? judgedByNoise(r) : evidence(r);
+  };
+  const rules = base.rules.map(valued);
+  const frames = (id) => ({ above: { frames: CLAUSES[id].value.frames }, uncalibrated: CLAUSES[id].uncalibrated });
+  const entry = CLAUSES["P-HEAVY-ENTRY"];
+  const unstable = CLAUSES["U-NOISY"];
+  const c = (id) => CLAUSES[id];
+  return {
+    ...base,
+    better: { ...base.better, from: c("S-BETTER").value.from, uncalibrated: c("S-BETTER").uncalibrated },
+    minRuns: c("G-MINRUNS").value.runs,
+    baseline: { ...base.baseline, sessions: c("B-BASELINE").value.sessions, uncalibrated: c("B-BASELINE").uncalibrated },
+    levelShift: { ...base.levelShift, confirmSessions: c("M-LEVELSHIFT").value.confirmSessions, uncalibrated: c("M-LEVELSHIFT").uncalibrated },
+    uncertain: { ...base.uncertain, belowMainSessions: c("S-UNCERTAIN").value.belowMainSessions, uncalibrated: c("S-UNCERTAIN").uncalibrated },
+    judgeFrom: { ...base.judgeFrom, mainSessions: c("G-JUDGE-FROM").value.mainSessions, uncalibrated: c("G-JUDGE-FROM").uncalibrated },
+    work: { ...base.work, mountShareAtLeast: c("W-WORKKIND").value.mountShareAtLeast, uncalibrated: c("W-WORKKIND").uncalibrated },
+    ...base.windowCount ? { windowCount: { ...base.windowCount, below: c("W-WINDOW-COUNT").value.below, uncalibrated: c("W-WINDOW-COUNT").uncalibrated } } : {},
+    frame: { ...base.frame, ms: c("T-FRAME").value.ms, uncalibrated: c("T-FRAME").uncalibrated },
+    tiers: {
+      ...base.tiers,
+      rel: c("T-REL").value.rel,
+      update: { warnMs: warnMs.update, errorMs: errorMs.update },
+      work: { warnMs: warnMs.work, errorMs: errorMs.work },
+      uncalibrated: c("T-WARN-MS").uncalibrated || c("TIER-ERROR").uncalibrated || c("T-REL").uncalibrated,
+      memory: { error: part(memory.value.error), uncalibrated: memory.uncalibrated }
+    },
+    rules,
+    problems: base.problems.map((p) => {
+      if (p.id === "slow-commit")
+        return { ...p, ...frames("P-SLOW-COMMIT") };
+      if (p.id === "heavy-component")
+        return { ...p, ...frames("P-HEAVY-COMPONENT") };
+      if (p.id === "heavy-entry")
+        return { ...p, above: { value: entry.value.ms }, uncalibrated: entry.uncalibrated };
+      return noRow(p.id);
+    }),
+    budgets: { ...base.budgets, entry: { value: entry.value.ms }, mount: { value: entry.value.ms }, update: { frames: c("P-BUDGETS").value.updateFrames }, uncalibrated: c("P-BUDGETS").uncalibrated },
+    unstable: base.unstable.map((u) => ({
+      ...u,
+      above: unstable.value.above,
+      below: unstable.value.below,
+      minMainRuns: unstable.value.minMainRuns,
+      minSessions: unstable.value.minSessions,
+      uncalibrated: unstable.uncalibrated,
+      curve: Object.fromEntries(Object.keys(u.curve).map((id) => [id, (NOISE_FITS[id] ?? noRow(`unstable curve ${id}`)).c])),
+      ...u.reads ? { reads: u.reads.map(valued) } : {}
+    }))
+  };
+}
+var COMMIT_MAX_JUDGED = noiseJudged("commit", { measure: "commit_max_ms" });
+var RENDER_JUDGED = noiseJudged("render", { measure: "render_ms" });
+var COMPONENT_JUDGED = noiseJudged("component", { dimension: "component", measure: "self_ms" });
+var MEMORY_RETAINED = {
+  id: "memory_retained",
+  role: "judged",
+  on: { measure: "mem.retained_growth_mb" },
+  places: JOURNEY,
+  devices: ANY_DEVICE,
+  threshold: [{ rel: 0.1, abs: 20 }],
+  uncalibrated: true,
+  source: MEMORY_PAIR_SOURCE
+};
+var JANK_SOURCE = `W8 option A, Arek 2026-10-26 ("Opcja A jest git", [ctl-arek-jank-time]): jank time (the window's commit times past one 60 Hz frame, added up) is judged in place of the slowest commit, so one spike no longer decides and jitter below a frame counts 0; curve T-NOISE-JANK; deciding since simple-4.26 after the pack v3 replay (A/A Slightly worse 58 -> 46 of 840 on aa-ni, doses 54 of 54)`;
+var SHAPE = {
+  id: "simple-4.26+noise95-99",
+  minRuns: 2,
+  baseline: { sessions: 3, ...GUESS("Q4 / REQ-VER-33: main's newest 3 sessions against one PR session (the quieter setting of the plan 58 simulation)") },
+  repeats: { kind: "every-pr-beyond-every-main" },
+  frame: { ms: LIMIT_FRAME_MS, uncalibrated: false, source: "Arek 2026-10-16: one frame is 16.7 ms on every screen; lag starts below 60 fps, so a 120 Hz phone is not held to 8.3 ms" },
+  levelShift: {
+    confirmSessions: 2,
+    uncalibrated: false,
+    source: "the smallest number of agreeing main sessions with zero noise confirmations on the data (plan 63 §3; controller 2026-10-17), reviewer scripts scratchpad/rev-p6-scripts on the S23 sessions with candidates only after 3 sessions in their bounded baseline: aa-shifts (no change): A/A all 120 orders 0 shifts at m = 1 and m = 2, 11 sessions x 60 random orders 1 of 60 at both; aa-inject (false later shifts after an injected real step): m = 1 2 of 40 sequences, m = 2 0 of 40. Limit: a component with two typical levels (AnimatedView at step:gia.history-first gave the 1 of 60) can fool any m"
+  },
+  uncertain: { belowMainSessions: UNCERTAIN_BELOW_MAIN_SESSIONS, uncalibrated: false, source: 'Arek 2026-10-16: "Nie blokuj przy małej bazie". With fewer than 3 main sessions a worse result is reported as uncertain and does not fail the check' },
+  work: {
+    mountShareAtLeast: 0.8,
+    uncalibrated: true,
+    source: "TraceSift MOUNT_DOMINANT_SHARE (0.8); the share is a lower-biased estimate (PR C review), so it only separates an in-screen mount from an update; an entry is decided by the route-change label alone"
+  },
+  instrument: {
+    aspects: ["sdk", "driver", "driverVersion", "journeyVersion", "actionGc"],
+    sdkReleases: SDK_RELEASES,
+    uncalibrated: false,
+    source: 'Arek 2026-10-16 ("Tak, to też ustalaliśmy"): the SDK, the driver and the journey are the instrument (REQ-VER-35); a release declares the measures it affects (REQ-VER-34); a forced GC before each step is a different instrument (REQ-VER-13, docs/plans/gc-before-action.md)',
+    driverReleases: DRIVER_RELEASES,
+    unknownDiffers: ["journeyVersion"]
+  },
+  calibrated: { platforms: ["ios", "android"], uncalibrated: false, source: 'REQ-FARM-26: Android moved in by Arek ("Ok", 2026-10-17) after the S23 A/A, 5 sessions × 3 runs: 0 z 25 false worse under the deciding rule (stats-android/aa/aa-report.md)' },
+  rules: [
+    { ...COMMIT_MAX_JUDGED, id: "jank", on: { measure: "jank_ms" }, source: JANK_SOURCE },
+    evidenceRule("commit_max", { measure: "commit_max_ms" }, JUDGED_WINDOWS, [], "W8 option A: the slowest commit is shown, jank time is judged", { devices: ANY_DEVICE }),
+    RENDER_JUDGED,
+    COMPONENT_JUDGED,
+    { ...evidenceRule("commits", { measure: "commits" }, REACT_PLACES, [{ rel: 0.5, abs: 2 }], "render and commit counts are evidence only (ruling a)"), source: COUNT_SOURCE },
+    { ...evidenceRule("renders", { measure: "renders" }, REACT_PLACES, [{ rel: 0.5, abs: 10 }], "render and commit counts are evidence only (ruling a)"), source: COUNT_SOURCE },
+    evidenceRule("render_upper", { measure: "render_ms_upper" }, WINDOWS, [{ rel: TIER_REL, abs: TIER_UPDATE_MS.warnMs }], "REQ-MEAS-32 timers, option A (Arek 2026-10-17): judged plus timer-carried render time is evidence with the render threshold; render_ms decides"),
+    evidenceRule("background_commit", { measure: "commit_max_ms" }, BACKGROUND, [{ rel: TIER_REL, abs: TIER_UPDATE_MS.warnMs }], "background places are evidence only (REQ-MEAS-32)"),
+    evidenceRule("background_render", { measure: "render_ms" }, BACKGROUND, [{ rel: TIER_REL, abs: TIER_UPDATE_MS.warnMs }], "background places are evidence only (REQ-MEAS-32)"),
+    evidenceRule("background_component", { dimension: "component", measure: "self_ms" }, BACKGROUND, [{ rel: TIER_REL, abs: TIER_UPDATE_MS.warnMs }], "background places are evidence only (REQ-MEAS-32)"),
+    evidenceRule("launch_commit", { measure: "commit_max_ms" }, LAUNCH, [{ rel: TIER_REL, abs: TIER_UPDATE_MS.warnMs }], "the launch screen is evidence only (REQ-VER-15)"),
+    evidenceRule("launch_render", { measure: "render_ms" }, LAUNCH, [{ rel: TIER_REL, abs: TIER_UPDATE_MS.warnMs }], "the launch screen is evidence only (REQ-VER-15)"),
+    evidenceRule("launch_component", { dimension: "component", measure: "self_ms" }, LAUNCH, [{ rel: TIER_REL, abs: TIER_UPDATE_MS.warnMs }], "the launch screen is evidence only (REQ-VER-15)"),
+    evidenceRule("step_commit", { measure: "commit_max_ms" }, STEP, [{ rel: TIER_REL, abs: TIER_UPDATE_MS.warnMs }], "a declared step is evidence only (REQ-MET-14)"),
+    evidenceRule("step_render", { measure: "render_ms" }, STEP, [{ rel: TIER_REL, abs: TIER_UPDATE_MS.warnMs }], "a declared step is evidence only (REQ-MET-14)"),
+    evidenceRule("step_component", { dimension: "component", measure: "self_ms" }, STEP, [{ rel: TIER_REL, abs: TIER_UPDATE_MS.warnMs }], "a declared step is evidence only (REQ-MET-14)"),
+    evidenceRule("touch", { measure: "touch_max_ms" }, SHOWN2, [{ rel: 0.2, abs: 10 }], "touch response is not judged (ruling)"),
+    evidenceRule("freeze", { measure: "sampler_longest_gap_ms" }, SHOWN2, [{ rel: 0.5, abs: 17 }], "v5.3 warn level"),
+    evidenceRule("freeze_journey", { measure: "sampler.frames.longest_gap_ms" }, JOURNEY, [{ rel: 0.5, abs: 17 }], "v5.3 warn level"),
+    evidenceRule("memory_added", { measure: "memory_left_mb" }, SHOWN2, [{ abs: 2 }], "v5.3 warn level", { thresholdAt: { screen: [{ abs: 10 }] }, devices: ANY_DEVICE }),
+    evidenceRule("memory_launch", { measure: "mem.launch_mb" }, JOURNEY, [{ rel: 0.08, abs: 2 }], "v5.3 warn level"),
+    evidenceRule("memory_end_growth", { measure: "mem.end_growth_mb" }, JOURNEY, [{ rel: 0.08, abs: 2 }], "v5.3 warn level"),
+    evidenceRule("memory_peak_growth", { measure: "mem.peak_growth_mb" }, JOURNEY, [{ rel: 0.08, abs: 2 }], "v5.3 warn level"),
+    evidenceRule("cpu", { measure: "sampler.cpu_ms" }, JOURNEY, [{ rel: 0.05 }], "a +10 % whole-app CPU change must show as evidence (hard case, with room for run noise on both sides); the prototype used 20 %"),
+    evidenceRule("window_cpu", { measure: "cpu_ms" }, SHOWN2, [{ rel: 0.5, abs: 20 }], "v5.3 warn level"),
+    evidenceRule("long_tasks", { measure: "longtask_ms" }, SHOWN2, [{ rel: 0.3, abs: 50 }], "v5.3 warn level"),
+    evidenceRule("gc", { measure: "gc_ms" }, SHOWN2, [{ rel: 0.5, abs: 2 }], "v5.3 warn level"),
+    evidenceRule("requests", { measure: "net_requests" }, SHOWN2, [{ rel: 0.5, abs: 1 }], "v5.3 warn level"),
+    evidenceRule("js_cpu", { measure: "js_cpu_ms" }, SHOWN2, [{ rel: 0.5, abs: 5 }], "v5.3 warn level"),
+    MEMORY_RETAINED
+  ],
+  problems: [
+    {
+      id: "slow-commit",
+      on: { measure: "commit_max_ms" },
+      places: JUDGED_WINDOWS,
+      devices: DEVICE,
+      above: { frames: 1 },
+      inRuns: "all",
+      uncalibrated: true,
+      source: "Arek 2026-10-16: a commit over one 60 Hz frame (16.7 ms) drops below 60 fps, where lag starts; present in every PR run (TapIn Appium: 37 places, 9 of them at 17-22 ms in only some sessions)"
+    },
+    {
+      id: "heavy-component",
+      on: { dimension: "component", measure: "self_ms" },
+      places: JUDGED_WINDOWS,
+      devices: DEVICE,
+      above: { frames: 1 },
+      inRuns: "all",
+      uncalibrated: true,
+      source: "Arek 2026-10-16: one 60 Hz frame, as the slowest commit; a component with a long render in the PR's own runs; a component that exists only on the PR side lands here, never as a regression row (Q3)"
+    },
+    {
+      id: "heavy-entry",
+      on: { measure: "render_ms" },
+      places: JUDGED_WINDOWS,
+      devices: DEVICE,
+      above: { value: ENTRY_BUDGET_MS },
+      inRuns: "all",
+      work: ["entry", "mount"],
+      uncalibrated: true,
+      source: 'ruling d: an entry or in-screen mount has a budget of about 100 ms of React work; its second half, "no dropped frames during the transition", is covered by `slow-commit` at one frame (the earlier `blocking-commit` at 2 frames only repeated it)'
+    }
+  ],
+  budgets: {
+    entry: { value: ENTRY_BUDGET_MS },
+    mount: { value: ENTRY_BUDGET_MS },
+    update: { frames: 1 },
+    uncalibrated: true,
+    source: "ruling d: entry and in-screen mount about 100 ms; an update one frame (16.7 ms on every screen, Arek 2026-10-16)"
+  },
+  freeze: { on: "sampler_longest_gap_ms", uncalibrated: false, source: 'evidence only: the longest freeze covers the whole window, not the transition; "no dropped frames during the transition" (ruling d) needs per-place frame data that is not available' },
+  notJudgedLabels: ["launch"],
+  unstable: [{
+    ...UNSTABLE_NOISY,
+    step: "own",
+    reads: [COMMIT_MAX_JUDGED, RENDER_JUDGED, COMPONENT_JUDGED, MEMORY_RETAINED],
+    source: `${UNSTABLE_NOISY.source}; Arek 2026-10-26 ("A wygląda kusząco. Oddaj do impl.", ctl-arek-met29-own-step): the step is the place's own work kind's (entry and in-screen mount 10 ms, update 5 ms), the smallest only when the kind is unknown; ctl-arek-jank-time: noisiness still reads the slowest commit, so a place is unstable exactly when it was before jank time was judged`
+  }],
+  judgeFrom: { mainSessions: 3, uncalibrated: false, source: 'Arek 2026-10-18 (REQ-VER-41): a phone is judged only when main has at least 3 sessions on that phone and journey; with fewer the result is "not enough main yet", not judged, not blocking, values shown. Replay (agents/release/replay, d22): 1 PR vs 2 main on the S23 night pool gave 13 z 60 false worse+warning, 1 vs 3 gave 0' },
+  measuredWith: [
+    { aspect: "renderer", affects: REACT_MEASURES },
+    { aspect: "reactExport", affects: MEMORY_MEASURES },
+    { aspect: "windowModel", affects: WINDOW_MODEL_AFFECTS, places: ["press", "drag"], marks: true },
+    { aspect: "screenWindowModel", affects: WINDOW_MODEL_AFFECTS, places: ["screen"], marks: true },
+    { aspect: "cpuSource", affects: ["sampler.cpu_ms"] },
+    { aspect: "causeSplit", affects: REACT_MEASURES, places: REACT_PLACES, marks: true },
+    { aspect: "endGc", affects: MEMORY_MEASURES }
+  ],
+  tiers: {
+    rel: TIER_REL,
+    update: TIER_UPDATE_MS,
+    work: TIER_WORK_MS,
+    uncalibrated: false,
+    source: `${NOISE_SOURCE}; ${CAPPED_SOURCE}; ${TIERS_SOURCE}; ${MEMORY_PAIR_SOURCE}`,
+    relAtMostErrorMs: true,
+    memory: { error: { rel: 0.3, abs: 150 }, uncalibrated: true }
+  },
+  better: { from: CLAUSES["S-BETTER"].value.from, uncalibrated: false, source: CLAUSES["S-BETTER"].ruling },
+  placeCoverage: {
+    uncalibrated: false,
+    source: "plan 79 S1/S2, Arek 2026-10-21 ~18:55 and 2026-10-22 ~16:45: removed never scores; list main-only places; count main sessions that have each place and value"
+  },
+  windowCount: { below: CLAUSES["W-WINDOW-COUNT"].value.below, uncalibrated: CLAUSES["W-WINDOW-COUNT"].uncalibrated, source: 'plan 51 D2 floor (90 % of the usual window count), Arek 2026-10-22 ~07:20 "a changed number of swipes/windows on one screen must affect only that screen"; per PR run, a decrease only (an increase is not marked)' },
+  detail: { componentMs: CLAUSES["C-DETAIL-MS"].value.ms, censored: "certify" },
+  sdkExclusionByPlace: {
+    uncalibrated: false,
+    source: `REQ-VER-35 amendment 2026-10-21 (Arek, "porównywać to co się da"), option (a): only the places an SDK step moved are measured differently; comparable places decide, Can't tell only when no comparable place is left (one test for instrument marks, window counts and SDK exclusions); an unstable place is never judged, so its left-out values are not counted (REQ-MET-29)`
+  }
+};
+var CONFIG = withClauseValues(SHAPE);
+var P2A_SLIGHT = withClauseValues({
+  ...CONFIG,
+  id: `${CONFIG.id}+p2a-sw`,
+  unstable: CONFIG.unstable.map((u) => ({
+    ...u,
+    judgeAt: { line: "error", tier: "warning" },
+    source: `${u.source}; P2a candidate (plan 81, Arek 2026-10-23 ~15:45): judged only past the error line, as Slightly worse, never blocking`
+  }))
+});
+var P4_EVEN = {
+  ...CONFIG,
+  id: `${CONFIG.id}+p4-even`,
+  evenSlowdown: { maxExcess: 0.3, renders: 0.1, commits: 0.25, uncalibrated: true, source: "plan 81 P4 (Opus O2 guesses); Arek 2026-10-23 ~12:45 direction (4); Arek 2026-10-26 ctl-arek-p81-p3p4: render and commit counts may block a downgrade as a guard, never colour a verdict alone" }
+};
+var P3_COMMIT = withClauseValues({
+  ...CONFIG,
+  id: `${CONFIG.id}+p3-commit`,
+  commitGrouping: { uncalibrated: true, source: "plan 81 P3; Arek 2026-10-26 [ctl-arek-p81-p3p4]: two windows that share one proven commit (the same slowest commit in every PR run) may be one finding; never merged without it" }
+});
 // apps/agent/src/device-model.ts
 import { tmpdir } from "node:os";
 import { join as join12 } from "node:path";
@@ -10452,173 +11620,10 @@ async function detectSimulator(deps, udid) {
 }
 
 // apps/agent/src/slack.ts
-var COLOR = { error: "#D6334A", warn: "#C47A00", better: "#238359", none: "#7C8492" };
-var MAX_ROWS = 3;
-var NAME_W = 30;
-var COLUMN_GAP = 1;
-function metricWord(item) {
-  if (item.label_text)
-    return item.label_text;
-  if (item.metric === "dur_ms" && placeKindWord(item.step ?? "") !== "Tap")
-    return "length";
-  return measureDef(item.metric)?.short ?? item.metric.replace(/_/g, " ");
-}
-function change2(item) {
-  if (item.change_text)
-    return item.change_text.replace(/ \(.*\)$/, "");
-  const { baseline: b, candidate: c } = item;
-  if (b === null || c === null)
-    return "";
-  if (b === 0)
-    return `${c - b >= 0 ? "+" : ""}${fieldValueText(item.metric, c - b)}`;
-  const p = Math.round((c / b - 1) * 100);
-  return `${p >= 0 ? "+" : ""}${p} %`;
-}
-var size = (i) => i.baseline === null || i.candidate === null ? 0 : i.baseline === 0 ? i.candidate === 0 ? 0 : Number.POSITIVE_INFINITY : Math.abs(Math.log(Math.max(i.candidate, 0.000000001) / i.baseline));
-var bySize = (a, b) => size(a) === size(b) ? 0 : size(a) > size(b) ? -1 : 1;
-var worseOrder = (a, b) => Number(a.grade === "warn") - Number(b.grade === "warn") || bySize(a, b);
-var isWorse = (i) => i.state === "worse";
-var isBetter = (i) => i.state === "better";
-var differs = (sc) => sc?.headline?.measured_differently ?? [];
-var scenarioBlocks = (sc) => sc?.headline?.blocking !== false;
-var isRed = (i, sc) => i.grade !== "warn" && scenarioBlocks(sc);
-var mark = (i, sc) => isBetter(i) ? "\uD83D\uDFE2" : isRed(i, sc) ? "\uD83D\uDD34" : i.grade !== "warn" ? "⚪" : "\uD83D\uDFE1";
-var fit = (s, w) => s.length > w ? `${s.slice(0, w - 1)}…` : s.padEnd(w);
-var right = (s, w) => s.padStart(w);
-var phone = (sc) => sc?.device ? `${sc.device.model}${sc.device.os ? ` · ${sc.device.os}` : ""}` : "unknown phone";
-function commitLine(ctx) {
-  const c = ctx.commit;
-  if (!c)
-    return null;
-  const short = c.sha.slice(0, 7);
-  return c.title ? `Commit: *${c.title}*${c.author ? ` · ${c.author}` : ""} (${short})` : `Commit ${short}`;
-}
-var section = (text) => ({ type: "section", text: { type: "mrkdwn", text } });
-var context = (text) => ({ type: "context", elements: [{ type: "mrkdwn", text }] });
-function prTable(items, sc) {
-  const cells = items.map((i) => ({ i, main: fieldValueText(i.metric, i.baseline), pr: fieldValueText(i.metric, i.candidate), change: change2(i) }));
-  const widest = (head, pick) => Math.max(head.length, ...cells.map((c) => pick(c).length)) + COLUMN_GAP;
-  const w = [NAME_W, widest("main", (c) => c.main), widest("PR", (c) => c.pr), widest("change", (c) => c.change)];
-  const head = `${" ".repeat(3)}${fit("", w[0])}${right("main", w[1])}${right("PR", w[2])}${right("change", w[3])}`;
-  const rows = cells.flatMap((c) => [
-    `${mark(c.i, sc)} ${fit(placeLabel(c.i.step ?? "*"), w[0])}${right(c.main, w[1])}${right(c.pr, w[2])}${right(c.change, w[3])}`,
-    `   ${metricWord(c.i)}`
-  ]);
-  return ["```", head, ...rows, "```"].join(`
-`);
-}
-function mainCard(i) {
-  const label = (s) => `  ${s.padEnd(16)}`;
-  return [
-    "```",
-    placeLabel(i.step ?? "*"),
-    `${label(metricWord(i))}${right(fieldValueText(i.metric, i.candidate), 9)}`,
-    `${label("usually")}${right(fieldValueText(i.metric, i.baseline), 9)}`,
-    `${label("change")}${right(change2(i), 9)}`,
-    "```"
-  ].join(`
-`);
-}
-function blockedMessage(s, ctx) {
-  const text = `⚪ No result for ${ctx.branch}: the measurement did not finish`;
-  const blocks = [
-    section(`*${text}*
-${ctx.blocked?.reason ?? "No iteration sent any data."}
-Nothing was judged, so this is not a "${STATE_WORDS["no-change"].toLowerCase()}".`),
-    ...commitLine(ctx) ? [context(commitLine(ctx))] : [],
-    ...s ? [section(`\uD83D\uDC49 <${s.dashboard_url}|See what happened>`)] : []
-  ];
-  return { text, attachments: [{ color: COLOR.none, blocks }] };
-}
 function slackMessage(s, ctx) {
   if (ctx.blocked)
-    return blockedMessage(s, ctx);
-  const v = s?.verdicts;
-  if (!s || !v)
-    return null;
-  const items = v.scenarios.flatMap((sc) => sc.state === "inconclusive" ? [] : movedItems(v, sc));
-  const scenarioOf = (i) => v.scenarios.find((sc) => sc.scenario === i.scenario && (!i.device_id || sc.device?.id === i.device_id)) ?? v.scenarios.find((sc) => sc.scenario === i.scenario);
-  const isPr = v.scenarios.some((sc) => sc.role === "comparison");
-  const worse = items.filter(isWorse).sort(worseOrder);
-  const better = items.filter(isBetter).sort(bySize);
-  const commit = commitLine(ctx);
-  const heated = v.scenarios.filter((sc) => heatNote(sc));
-  const contextLines = v.scenarios.flatMap((sc) => laneContextLines(sc.context, sc.scenario ?? "-", phone(sc))).map(context);
-  const heat = heated.map((sc) => context(heatNote(sc)));
-  const errorRows = worse.filter((i) => i.grade !== "warn");
-  const warningRows = worse.filter((i) => i.grade === "warn");
-  const errors = placeCount(errorRows);
-  const warns = placeCount(worse) - errors;
-  const red = errorRows.some((i) => isRed(i, scenarioOf(i)));
-  const notBlocking = errors > 0 && !red;
-  const worseMark = red ? "\uD83D\uDD34" : warns > 0 ? "\uD83D\uDFE1" : "⚪";
-  const worseColor = red ? COLOR.error : warns > 0 ? COLOR.warn : COLOR.none;
-  if (isPr) {
-    if (!worse.length) {
-      if (!heat.length)
-        return null;
-      const head = `⚪ ${ctx.branch}: ${heat.length ? INFO_WORDS.heat : v.word ?? STATE_WORDS["no-change"]}`;
-      const blocks = [section(`*${head}*`), ...heat, ...contextLines, ...commit ? [context(commit)] : [], section(`\uD83D\uDC49 <${heated[0]?.dashboard_url ?? s.dashboard_url}|View the comparison>`)];
-      return { text: head, attachments: [{ color: COLOR.none, blocks }] };
-    }
-    const graded = worse.some((i) => i.grade);
-    const places = (word, n) => `${word.toLowerCase()} in ${n} place${n > 1 ? "s" : ""}`;
-    const counts = graded ? [errors ? `${places(STATE_WORDS.worse, errors)}${notBlocking ? ` (${NOT_BLOCKING})` : ""}` : "", warns ? places(STATE_WORDS.warning, warns) : ""].filter(Boolean).join(", ") : `${places(STATE_WORDS.worse, placeCount(worse))}${notBlocking ? ` (${NOT_BLOCKING})` : ""}`;
-    const head = `${worseMark} ${ctx.branch}: ${counts}`;
-    const blocks = [section(`*${head}*`), ...contextLines];
-    const groups = new Map;
-    for (const i of worse)
-      groups.set(scenarioOf(i), [...groups.get(scenarioOf(i)) ?? [], i]);
-    let shown = 0;
-    for (const [sc, list] of groups) {
-      if (shown >= MAX_ROWS)
-        break;
-      const rows = list.slice(0, MAX_ROWS - shown);
-      shown += rows.length;
-      const nB = Math.max(...rows.map((r) => r.n_baseline ?? 0));
-      const nC = Math.max(...rows.map((r) => r.n_candidate ?? 0)) || (sc?.runs?.valid ?? 0);
-      const runs = nB && nC ? ` · ${nC} PR run${nC === 1 ? "" : "s"} vs ${nB} main run${nB === 1 ? "" : "s"}` : "";
-      const note = differs(sc).length ? `
-_Measured differently (${differs(sc).join(", ")})${scenarioBlocks(sc) ? "" : ` — ${NOT_BLOCKING}`}_` : "";
-      const nonblocking = !scenarioBlocks(sc) && rows.some((i) => i.grade !== "warn") && !differs(sc).length ? ` · ${NOT_BLOCKING}` : "";
-      blocks.push(section(`*${sc?.scenario ?? "journey"}*${nonblocking} · ${phone(sc)}${runs}${note}
-${prTable(rows, sc)}`));
-    }
-    const more = worse.length - shown;
-    blocks.push(...heat);
-    if (commit)
-      blocks.push(context(commit));
-    blocks.push(section(`\uD83D\uDC49 <${groups.keys().next().value?.dashboard_url ?? s.dashboard_url}|View the comparison>${more > 0 ? ` · ${more} more` : ""}`));
-    return { text: head, attachments: [{ color: worseColor, blocks }] };
-  }
-  const improved = better.length > 0 || v.state === "better";
-  if (!worse.length && !improved && !ctx.always && !heat.length)
-    return null;
-  const parts = [errors ? `${errors} ${STATE_WORDS.worse.toLowerCase()}${notBlocking ? ` (${NOT_BLOCKING})` : ""}` : "", warns ? `${warns} ${STATE_WORDS.warning.toLowerCase()}` : "", better.length ? `${placeCount(better)} ${STATE_WORDS.better.toLowerCase()}` : ""].filter(Boolean);
-  const quiet = improved ? STATE_WORDS.better.toLowerCase() : (v.state === null || v.state === "inconclusive") && v.word ? v.word : STATE_WORDS["no-change"].toLowerCase();
-  const status = parts.length ? `${ctx.branch}: ${parts.join(", ")}` : !improved && heat.length && !ctx.always ? `${ctx.branch}: ${INFO_WORDS.heat}` : quiet.startsWith("Main: ") && ctx.branch === "main" ? quiet : `${ctx.branch}: ${quiet}`;
-  const head = `${worse.length ? worseMark : improved ? "\uD83D\uDFE2" : v.state === "inconclusive" && (ctx.always || !heat.length) ? "❔" : "⚪"} ${status}`;
-  const journeys = new Set(v.scenarios.map((sc) => `${sc.scenario}|${sc.device?.id}`)).size;
-  const blocks = [section(`*${head}*
-${journeys} journey${journeys === 1 ? "" : "s"} checked`), ...contextLines];
-  let shown = 0;
-  for (const [title, list] of [[STATE_WORDS.worse, errorRows], [STATE_WORDS.warning, warningRows], [STATE_WORDS.better, better]]) {
-    for (const i of list) {
-      if (shown >= MAX_ROWS)
-        break;
-      shown++;
-      const sc = scenarioOf(i);
-      blocks.push(section(`*${title}*${i.grade !== "warn" && isWorse(i) && !scenarioBlocks(sc) ? ` (${NOT_BLOCKING})` : ""} · *${sc?.scenario ?? "journey"}* · ${phone(sc)}
-${mainCard(i)}`));
-    }
-  }
-  const more = worse.length + better.length - shown;
-  blocks.push(...heat);
-  if (commit)
-    blocks.push(context(commit));
-  blocks.push(section(`\uD83D\uDC49 <${s.dashboard_url}|Open KeepSnappy>${more > 0 ? ` · ${more} more changes` : ""}`));
-  const color = worse.length ? worseColor : improved ? COLOR.better : COLOR.none;
-  return { text: head, attachments: [{ color, blocks }] };
+    return noResultSlackPayload(ctx.branch, ctx.blocked.reason, s ? linkOf(s) : null);
+  return s ? resultSlackPayload(s, { always: ctx.always }) : null;
 }
 async function postToSlack(url, payload, fetchImpl = fetch) {
   try {
@@ -10703,7 +11708,7 @@ function instrumentFlags(f) {
   return { ...driver ? { "driver-version": driver } : {}, ...journey ? { "journey-version": journey } : {} };
 }
 var TOKENS_STUB = "// Replaced by `keepsnappy farm open` for one upload. Never commit real tokens.\noutput.keepsnappyTokens = {};\n";
-var JOURNEY = /^[A-Za-z0-9][A-Za-z0-9._-]{0,199}$/;
+var JOURNEY2 = /^[A-Za-z0-9][A-Za-z0-9._-]{0,199}$/;
 var DEFAULT_TTL = 21600;
 var POLL_MS = 5000;
 function tokensJs(api, runSetId, tokens, links = maestroLinkFields()) {
@@ -10790,7 +11795,7 @@ async function farmOpen(deps, f, rt) {
   if (journeys.length === 0)
     problems.push("--journeys a,b is required (the flow names the device runs, one history per journey)");
   for (const j of journeys)
-    if (!JOURNEY.test(j))
+    if (!JOURNEY2.test(j))
       problems.push(`--journeys: "${j}" is not a journey name (letters, digits, . _ -)`);
   if (new Set(journeys).size !== journeys.length)
     problems.push("--journeys lists a journey twice");
@@ -10818,11 +11823,15 @@ async function farmOpen(deps, f, rt) {
   const withInstrument = { ...f, ...instrumentFlags(f) };
   const setup = Object.fromEntries(SETUP_FLAGS.flatMap(([flag, key]) => withInstrument[flag]?.trim() ? [[key, withInstrument[flag].trim().slice(0, 200)]] : []));
   const base = await baseCommitFor(deps, rt.env, { explicit: f["base-commit"], branch: git.branch, commit: git.commit }, rt.print);
+  const main = await mainMerges(deps, rt.env, { branch: git.branch, commit: git.commit });
+  if (main.warning)
+    rt.print(main.warning);
   const rs = await createRunSet(api, {
     branch: git.branch,
     ...git.commit ? { commit_sha: git.commit } : {},
     ...base ? { base_commit_sha: base } : {},
     ...await commitFields(deps, rt.env, { commit: git.commit, base }),
+    ...main.merges ? { merges: main.merges } : {},
     device: { model: device.model, ...device.os ? { os: device.os } : {}, provider: device.provider, ...f["device-id"]?.trim() ? { id: f["device-id"].trim() } : {} },
     scenarios: journeys,
     journeys: journeyInfo,
@@ -10939,7 +11948,7 @@ async function settle(api, runSetId, o) {
   }
 }
 var FAILED_SESSION = new Set(["failed", "error", "timedout", "stopped", "skipped"]);
-var median5 = (xs) => {
+var median6 = (xs) => {
   const v = [...xs].sort((a, b) => a - b);
   return v.length % 2 ? v[(v.length - 1) / 2] : (v[v.length / 2 - 1] + v[v.length / 2]) / 2;
 };
@@ -10961,10 +11970,11 @@ function brokenRun(state, runs, session) {
   const others = ordered.filter((r) => r !== last && r.journey === last.journey && has(r)).map((r) => byId.get(r.run_id).windows ?? 0);
   const journey = typeof s.usual_windows === "number" && s.usual_windows > 0 ? s.usual_windows : null;
   const mine = ordered.filter((r) => r.journey === last.journey && has(r) && byId.get(r.run_id).complete !== false).map((r) => byId.get(r.run_id).windows ?? 0).filter((n) => n > 0);
-  const m = mine.length >= 2 ? median5(mine) : null;
-  const changed = m !== null && mine.every((n) => n >= 0.9 * m && 0.9 * n <= m) && (journey === null || m < 0.9 * journey);
-  const usual = changed ? m : journey ?? (others.length ? median5(others) : null);
-  if (usual !== null && (s.windows ?? 0) < 0.9 * usual)
+  const m = mine.length >= 2 ? median6(mine) : null;
+  const floor = CLAUSES["W-WINDOW-COUNT"].value.below;
+  const changed = m !== null && mine.every((n) => n >= floor * m && floor * n <= m) && (journey === null || m < floor * journey);
+  const usual = changed ? m : journey ?? (others.length ? median6(others) : null);
+  if (usual !== null && (s.windows ?? 0) < floor * usual)
     return last;
   return next;
 }
@@ -11000,6 +12010,7 @@ async function farmClose(deps, f, rt) {
     await scrubTokens(deps, state.tokens_js, rt);
   }
 }
+var blockedReason = (session) => `No iteration sent any data${session.known ? ` (device session ${session.status})` : ""}.`;
 async function closeRunSet(deps, f, rt, state, statePath) {
   const settleSeconds = Number(f["settle-seconds"] ?? 60);
   const maxWaitSeconds = Number(f["max-wait-seconds"] ?? Math.max(300, settleSeconds * 3));
@@ -11054,7 +12065,7 @@ async function closeRunSet(deps, f, rt, state, statePath) {
   const blocked = summary.runs.valid === 0 && withData === 0;
   if (blocked) {
     rt.print("");
-    rt.print(`KeepSnappy result for ${where}: Blocked — no iteration sent any data${session.known && !session.passed ? ` (device session ${session.status})` : ""}.`);
+    rt.print(`KeepSnappy result for ${where}: ${BLOCKED_WORD} — no iteration sent any data${session.known && !session.passed ? ` (device session ${session.status})` : ""}.`);
     rt.print("  Check that the build carries the SDK, the activation link ran, and the device reached the API.");
     rt.print(`Dashboard: ${summary.dashboard_url}`);
   } else if (f.wait) {
@@ -11075,36 +12086,14 @@ async function closeRunSet(deps, f, rt, state, statePath) {
 `);
   await githubOutputs(deps, rt, { state: state2.result.state ?? "none", dashboard_url: summary.dashboard_url, run_set_id: state.run_set_id });
   const step = rt.env.GITHUB_STEP_SUMMARY;
-  if (step) {
-    const head = blocked ? `### KeepSnappy: Blocked
-
-No iteration sent any data${session.known ? ` (device session ${session.status})` : ""}. [Open the dashboard](${summary.dashboard_url})
-` : markdownRunSet(f.wait ? summary : null, { dashboardUrl: summary.dashboard_url, branch: state.branch });
-    const noData = summary.runs.no_data?.length ?? 0;
-    const tail = [
-      session.known && !session.passed ? `Device session ${session.status}${session.message ? `: ${session.message}` : ""}.` : "",
-      noData ? `${noData} of ${state.runs.length} iterations sent no data.` : ""
-    ].filter(Boolean);
-    await deps.fs.appendFile(step, `${head}${tail.length ? `
-${tail.join(" ")}
-` : ""}`);
-  }
+  if (step)
+    await deps.fs.appendFile(step, blocked ? noResultMarkdown(state.branch, blockedReason(session), summary.dashboard_url) : markdownRunSet(f.wait ? summary : null, { dashboardUrl: summary.dashboard_url, branch: state.branch }));
   const hook = envValue(rt.env, "SLACK_WEBHOOK");
-  if (hook) {
-    const commit = state.commit ? await commitInfo(deps, state.commit) : undefined;
-    const msg = slackMessage(f.wait || blocked ? summary : null, {
-      branch: state.branch,
-      ...commit ? { commit } : {},
-      ...blocked ? { blocked: { reason: `No iteration sent any data${session.known ? ` (device session ${session.status})` : ""}.` } } : {},
-      always: envValue(rt.env, "SLACK_ALWAYS") === "1"
-    });
-    if (!msg) {
-      rt.print(!f.wait ? "Slack: skipped, the message needs --wait" : notComputed(summary) ? "Slack: nothing to report, the verdict is not computed yet" : `Slack: nothing to report (${resultWord(summary).toLowerCase()})`);
-    } else {
-      const r = await postToSlack(hook, msg, rt.fetch ?? fetch);
-      rt.print(r.ok ? "Slack: posted" : `Slack: not posted (${r.error}); the job is not affected`);
-    }
-  }
+  if (hook && blocked) {
+    const r = await postToSlack(hook, slackMessage(summary, { branch: state.branch, blocked: { reason: blockedReason(session) } }), rt.fetch ?? fetch);
+    rt.print(r.ok ? "Slack: posted" : `Slack: not posted (${r.error}); the job is not affected`);
+  } else if (hook)
+    rt.print("Slack: results are posted after the verdict is computed");
   if (blocked)
     return EXIT.infra;
   if (f["fail-on-worse"] && isBlocking(summary)) {
@@ -11417,7 +12406,7 @@ function nodeFarmRunPorts(deps, rt) {
 }
 var TUNNEL_TARGET = /^(?:localhost|127\.0\.0\.1):(\d{1,5})$/;
 var ENV_PAIR = /^([A-Za-z_][A-Za-z0-9_]*)=([\s\S]*)$/;
-var DEVICE = /^(.+)-([^-]+)$/;
+var DEVICE2 = /^(.+)-([^-]+)$/;
 var SECRETISH = /KEY|TOKEN|SECRET|PASSWORD/i;
 var RUN_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/;
 function planFarmRun(f) {
@@ -11427,7 +12416,7 @@ function planFarmRun(f) {
   const platform = f.platform ?? "ios";
   if (platform !== "ios" && platform !== "android")
     problems.push("--platform must be ios or android");
-  if (!f.device || !DEVICE.test(f.device))
+  if (!f.device || !DEVICE2.test(f.device))
     problems.push('--device "<model>-<os>" is required, e.g. "iPhone 15 Pro-17"');
   const driver = f.driver ?? "maestro";
   if (driver !== "maestro" && driver !== "appium")
@@ -11436,7 +12425,7 @@ function planFarmRun(f) {
   if (journeys.length === 0)
     problems.push("--journeys a,b is required");
   for (const j of journeys)
-    if (!JOURNEY.test(j))
+    if (!JOURNEY2.test(j))
       problems.push(`--journeys: "${j}" is not a journey name (letters, digits, . _ -)`);
   const repeat = Number(f.repeat ?? 5);
   if (!Number.isInteger(repeat) || repeat < 1 || repeat > 100)
@@ -11533,7 +12522,7 @@ function printPlan(p, f, rt) {
     line(`     env ${k}=${substitute(v, {})}`);
   line(`  6. farm close${f.wait ? " --wait" : ""}${f["fail-on-worse"] ? " --fail-on-worse" : ""} with ${join16(p.out, `browserstack.${p.platform}.json`)}`);
   line("  7. always: stop the tunnel, put the empty stub back over the tokens file");
-  line("  exit: 0 any verdict, 1 infrastructure / driver failed / Blocked, 2 configuration, 3 --fail-on-worse (a computed blocking Worse only; no computed verdict: nothing checked)");
+  line(`  exit: 0 any verdict, 1 infrastructure / driver failed / ${BLOCKED_WORD}, 2 configuration, 3 --fail-on-worse (a computed blocking Worse only; no computed verdict: nothing checked)`);
 }
 var ANNOTATION = /^::(error|warning|notice)( [^:]*)?::/;
 async function runDriver2(deps, rt, f, p, ports, ctx) {
@@ -11636,7 +12625,7 @@ async function farmRun(deps, f, rt, ports) {
   let driver = { ok: true, message: null };
   let closeCode = EXIT.ok;
   try {
-    const [model, os] = [DEVICE.exec(f.device)[1], DEVICE.exec(f.device)[2]];
+    const [model, os] = [DEVICE2.exec(f.device)[1], DEVICE2.exec(f.device)[2]];
     const openCode = await farmOpen(deps, {
       ...f,
       journeys: p.journeys.join(","),
@@ -11957,6 +12946,7 @@ import { parseArgs as parseArgs3 } from "node:util";
 var SHORT_SESSIONS = 3;
 var SHORT_POINTS = 5;
 var SHORT_PLACES = 5;
+var SHORT_COMPARE_MEASURES = 3;
 var SHORT_FORM_NOTES = {
   list_findings: "the how-sure lines, the place lines of findings that are not Worse and the lanes that were judged",
   get_finding: "the why, seen and layer lines, the component lines, the memory evidence lines other than the judged measure and the prompt",
@@ -11966,7 +12956,8 @@ var SHORT_FORM_NOTES = {
   place_trend: `the sessions older than the newest ${SHORT_SESSIONS} and the history restarts among them (unknown restarts always stay)`,
   window_history: `the runs older than the newest ${SHORT_POINTS}`,
   pr_status: "the per-journey dashboard links and the heat note",
-  list_problems: `the work and component lines, the dashboard links and the problems after the first ${SHORT_PLACES}`
+  list_problems: `the work and component lines, the dashboard links and the problems after the first ${SHORT_PLACES}`,
+  compare_runs: `the component lines and the measures beyond each place's ${SHORT_COMPARE_MEASURES} times that moved most`
 };
 var andList = (xs) => xs.length < 2 ? xs[0] ?? "" : `${xs.slice(0, -1).join(", ")} and ${xs[xs.length - 1]}`;
 
@@ -11992,9 +12983,13 @@ class Rows {
         this.rows.push({ text: line, short: false, notice: false });
     return this;
   }
+  twin(full, short) {
+    this.rows.push({ text: full, short: false, notice: false }, { text: short, short: true, shortOnly: true });
+    return this;
+  }
   render(form, left = []) {
     if (form !== "short")
-      return this.rows.map((r) => r.text).join(`
+      return this.rows.filter((r) => !r.shortOnly).map((r) => r.text).join(`
 `);
     const kept = [];
     for (const r of this.rows) {
@@ -12023,7 +13018,7 @@ function formatFinding(f, opts = {}) {
     r.both(...laneContextLines(f.lane.context, f.lane.journey, f.lane.phone_name, opts.verbose, opts.form === "short"));
   r.full(line("Why", f.answer.why));
   r.both(line("What to do", f.answer.what_to_do));
-  r.full(line("Seen", f.answer.lifecycle), line("Layer", `${f.layer.id} · ${f.layer.name} (${f.certificate ? "certified" : "uncertified"})${f.limits.length ? `; limits: ${f.limits.join("; ")}` : ""}`));
+  r.full(line("Seen", f.answer.lifecycle), ...f.lifecycle.unstable_note ? [line("", f.lifecycle.unstable_note)] : [], line("Layer", `${f.layer.id} · ${f.layer.name} (${f.certificate ? "certified" : "uncertified"})${f.limits.length ? `; limits: ${f.limits.join("; ")}` : ""}`));
   r.both(line("Id", f.id));
   if (f.why.components.length) {
     r.full(line("Components", ""));
@@ -12051,7 +13046,7 @@ function formatFinding(f, opts = {}) {
 }
 var when = (iso) => iso.slice(0, 16).replace("T", " ");
 var LANES_SHOWN = 8;
-var STATE_WORDS2 = { present: "still present", resolved: "resolved", "not-judged": "not judged in the newest run set" };
+var STATE_WORDS3 = { present: "still present", resolved: "resolved", "not-judged": "not judged in the newest run set" };
 function measuredLines(l, r, opts) {
   const f = l.filters;
   const scope = [f.branch ?? "all branches", f.journey, f.phone].filter(Boolean).join(" · ");
@@ -12069,15 +13064,19 @@ function measuredLines(l, r, opts) {
   };
   if (m.lanes.length === 1) {
     r.both(`${scope}: newest measured ${f.branch ? "" : `on ${n.branch}, `}${lane(n)}; ${plural2(m.run_sets, "run set")} measured.`);
+    r.both(...(n.comparison_notes ?? []).map((line) => `  ${line}`));
+    r.full(...(n.session_speed ?? []).map((line) => `  ${line}`));
     r.both(...laneContextLines(n.context, n.journey, n.phone_name, opts.verbose, opts.form === "short"));
     return [];
   }
   const shown = m.lanes.slice(0, LANES_SHOWN);
   r.add(shown.some((x) => !x.judged || !!x.context), `${scope}: ${plural2(m.run_sets, "run set")} measured; the newest of each journey × phone:`);
   for (const x of shown) {
-    const keep = !x.judged || !!x.context;
+    const keep = !x.judged || !!x.context || !!x.comparison_notes;
     r.add(keep, `  ${x.journey} on ${x.phone_name}${f.branch ? "" : ` (${x.branch})`}: ${lane(x)}`);
     r.add(keep, ...resultContextLines(x.context, opts.verbose, opts.form === "short").map((line) => `    ${line}`));
+    r.add(keep, ...(x.comparison_notes ?? []).map((line) => `    ${line}`));
+    r.full(...(x.session_speed ?? []).map((line) => `    ${line}`));
   }
   if (m.lanes.length > shown.length)
     r.full(`  … ${m.lanes.length - shown.length} more (--journey / --phone narrow it)`);
@@ -12096,7 +13095,7 @@ function countsLine2(l) {
   ].filter(Boolean);
   const state = l.filters.state;
   const unjudged = l.measured.lanes.filter((x) => !x.judged);
-  const head = parts.length ? `${parts.join(", ")}${state === "all" ? "" : `, ${STATE_WORDS2[state] ?? state}`}` : state !== "present" && state !== "all" ? `No finding ${STATE_WORDS2[state] ?? state}` : unjudged.length === l.measured.lanes.length ? `No finding, but nothing was compared yet (${[...new Set(unjudged.map((x) => x.word))].join(", ")}): measure again before calling it clean` : `Nothing ${STATE_WORDS.worse.toLowerCase()}, nothing ${STATE_WORDS.warning.toLowerCase()}, nothing ${STATE_WORDS.better.toLowerCase()}`;
+  const head = parts.length ? `${parts.join(", ")}${state === "all" ? "" : `, ${STATE_WORDS3[state] ?? state}`}` : state !== "present" && state !== "all" ? `No finding ${STATE_WORDS3[state] ?? state}` : unjudged.length === l.measured.lanes.length ? `No finding, but nothing was compared yet (${[...new Set(unjudged.map((x) => x.word))].join(", ")}): measure again before calling it clean` : `Nothing ${STATE_WORDS.worse.toLowerCase()}, nothing ${STATE_WORDS.warning.toLowerCase()}, nothing ${STATE_WORDS.better.toLowerCase()}`;
   const heated = c.heat_runs ?? 0;
   const more = [
     heated ? `${INFO_WORDS.heat.toLowerCase()} in ${plural2(heated, "run")} (run health, layer 3)` : "",
@@ -12140,10 +13139,12 @@ function formatBranchStatus(s, opts = {}) {
   if (s.lanes.length)
     r.both("");
   for (const l of s.lanes) {
-    const shown = l.result === "blocks" ? `${l.word} (blocks)` : badgedWord(l.word, l.blocking);
+    const shown = `${l.result === "blocks" ? `${l.word} (blocks)` : badgedWord(l.word, l.blocking)}${l.stale ? ` (${STALE_FLAG})` : ""}`;
     const sha = l.commit?.sha?.slice(0, 7);
     r.both(`  ${l.journey_title ?? l.journey} on ${l.phone_name}: ${shown} · ${sha ? `commit ${sha}` : "commit not recorded"} (${when(l.at)})${l.in_newest_run_set ? "" : " · older run set"}${l.waiting_for_reprocess ? `; ${waitingWords(l.waiting_for_reprocess)}` : ""}`);
     r.both(...resultContextLines(l.context, opts.verbose, opts.form === "short"));
+    r.both(...(l.comparison_notes ?? []).map((line) => `    ${line}`));
+    r.full(...(l.session_speed ?? []).map((line) => `    ${line}`));
     for (const f of l.worst)
       r.both(`    ${f.id}  ${f.headline}`);
     if (l.present_findings > l.worst.length)
@@ -12152,6 +13153,7 @@ function formatBranchStatus(s, opts = {}) {
       r.full(`    ${l.link}`);
   }
   const links = s.lanes.filter((l) => l.link).length;
+  const staleLanes = s.problems?.stale_lanes ?? 0;
   const heated = s.counts.heat_runs ?? 0;
   const more = [
     [false, heated ? `${INFO_WORDS.heat.toLowerCase()} in ${plural2(heated, "run")} (information, never blocks)` : ""],
@@ -12160,6 +13162,7 @@ function formatBranchStatus(s, opts = {}) {
       s.not_judged_findings ? `${plural2(s.not_judged_findings, "finding")} not judged in the newest run set; they may still be there: keepsnappy findings --branch ${s.branch} --state not-judged` : ""
     ],
     [true, statusProblemsLine(s)],
+    [true, staleLanes ? `${staleWords(staleLanes)}: ${staleLanes === 1 ? "its word and problems are" : "their words and problems are"} of older rules` : ""],
     [true, s.problems?.unread_lanes ? `${unreadWords(s.problems.unread_lanes)} for problems: ${staleResult(s.problems.unread_lanes)}` : ""],
     [true, s.links.overview ? `Dashboard: ${s.links.overview}` : ""],
     [true, s.worst.length ? "One finding with its evidence and a prompt: keepsnappy finding <id> --prompt" : ""]
@@ -12175,9 +13178,11 @@ function statusProblemsLine(s) {
   const p = s.problems;
   if (!p?.count)
     return "";
-  return `${plural2(p.places, "place")} over budget in this branch’s own runs (${p.far_count ? `${p.far_count} far over budget; ` : ""}not a regression, never blocks): list_problems, or keepsnappy problems --branch ${s.branch}`;
+  return `${problemCountsText(p, "this branch’s")}. Not a regression, never blocks: list_problems, or keepsnappy problems --branch ${s.branch}`;
 }
 var unreadWords = (n) => `${n} journey × phone not read`;
+var STALE_FLAG = staleFlagText(["config"]);
+var staleWords = (n) => `${n} journey × phone from a stale result (${STALE_FLAG})`;
 var staleResult = (n) => `${n === 1 ? "its stored result is" : "their stored results are"} not current`;
 function formatProblemList(l, opts = {}) {
   const r = new Rows;
@@ -12194,7 +13199,7 @@ function formatProblemList(l, opts = {}) {
     return r.render(opts.form);
   }
   if (c.count)
-    r.both(`${b}: ${plural2(c.places, "place")} over budget in ${b === l.baseline_branch ? "main’s" : "this branch’s"} own runs${c.far_count ? ` (${c.far_count} far over budget)` : ""}`);
+    r.both(`${b}: ${problemCountsText(c, b === l.baseline_branch ? "main’s" : "this branch’s")}`);
   else if (read)
     r.both(`${b}: no problem over budget in the newest run set (${read} journey × phone read)`);
   else
@@ -12202,10 +13207,12 @@ function formatProblemList(l, opts = {}) {
   r.both(l.note);
   if (read && unread)
     r.both(`${unreadWords(unread)}: ${staleResult(unread)}, so nothing is known about ${unread === 1 ? "its" : "their"} problems.`);
+  if (c.stale_lanes)
+    r.both(`${staleWords(c.stale_lanes)}: ${c.stale_lanes === 1 ? "its" : "their"} problems are listed, each marked “${STALE_MARK}”.`);
   l.problems.forEach((p, i) => {
     const keep = i < SHORT_PLACES;
     r.add(keep, "", `${l.offset + i + 1}. ${p.text}: ${p.place_name}${opts.verbose ? ` (${p.place})` : ""}${p.intermittent ? ` — ${p.note}, not counted` : ""}`);
-    r.add(keep, `   ${p.journey_title ?? p.journey} on ${p.phone_name}, ${p.runs_text}${p.tag_word ? `, ${p.tag_word}` : ""}`);
+    r.add(keep, `   ${p.journey_title ?? p.journey} on ${p.phone_name}, ${p.runs_text}${p.tag_word ? `, ${p.tag_word}` : ""}${p.stale ? `, ${STALE_MARK}` : ""}`);
     const top = p.top_components[0];
     const topName = componentReadNames(p.top_components)[0];
     const detail = [p.work, top ? `heaviest ${topName}${opts.verbose && top.key ? ` (${top.key})` : ""} ${top.self_text}` : null, p.new_component ? NEW_IN_PR_CHIP : null, p.range_text ? `${p.range_text} between runs` : null].filter(Boolean);
@@ -12228,76 +13235,92 @@ function formatProblemList(l, opts = {}) {
 }
 var commitText = (c) => !c ? "commit not recorded" : c.title ? `“${c.title}”${c.author ? ` by ${c.author}` : ""}${c.sha ? ` (${c.sha.slice(0, 7)})` : ""}` : c.sha ? c.sha.slice(0, 7) : "commit not recorded";
 function formatCompare(r, opts = {}) {
-  const out = [
-    `Run A: ${r.a.external_id} on ${r.a.branch ?? "?"}, ${commitText(r.a.commit ? { sha: r.a.commit_sha, ...r.a.commit } : { sha: r.a.commit_sha, title: null, author: null })}`,
-    `Run B: ${r.b.external_id} on ${r.b.branch ?? "?"}, ${commitText(r.b.commit ? { sha: r.b.commit_sha, ...r.b.commit } : { sha: r.b.commit_sha, title: null, author: null })}`,
-    `${r.same_journey ? "Same journey" : "Different journeys"}, ${r.same_phone ? "same phone" : "different phones"}. ${r.note}`
-  ];
+  const rows = new Rows;
+  rows.both(`Run A: ${r.a.external_id} on ${r.a.branch ?? "?"}, ${commitText(r.a.commit ? { sha: r.a.commit_sha, ...r.a.commit } : { sha: r.a.commit_sha, title: null, author: null })}`, `Run B: ${r.b.external_id} on ${r.b.branch ?? "?"}, ${commitText(r.b.commit ? { sha: r.b.commit_sha, ...r.b.commit } : { sha: r.b.commit_sha, title: null, author: null })}`, `${r.same_journey ? "Same journey" : "Different journeys"}, ${r.same_phone ? "same phone" : "different phones"}. ${r.note}`);
   if (r.setup_differs.length)
-    out.push(`Measured differently: ${r.setup_differs.map((d) => `${d.field} ${JSON.stringify(d.a)} → ${JSON.stringify(d.b)}`).join(", ")}`);
+    rows.both(`Measured differently: ${r.setup_differs.map((d) => `${d.field} ${JSON.stringify(d.a)} → ${JSON.stringify(d.b)}`).join(", ")}`);
   for (const w of r.windows) {
     const ms = w.metrics.filter((m) => m.a !== null || m.b !== null);
     const c = w.component_page ?? w.components;
     if (!ms.length && !c)
       continue;
-    out.push("", `${w.window_name}${opts.verbose ? ` (${w.window})` : ""}`);
+    rows.both("", `${w.window_name}${opts.verbose ? ` (${w.window})` : ""}`);
     const singles = [...c?.added ?? [], ...c?.removed ?? [], ...w.component_page?.uncompared?.a ?? [], ...w.component_page?.uncompared?.b ?? []];
     const components = [...c?.rows ?? [], ...singles];
     const names = componentReadNames(components.map((row) => ({ key: row.key, name: row.component })));
     const shown = new Map(components.map((row, i) => [row.key, names[i]]));
     for (const row of c?.rows ?? [])
-      out.push(`  ${shown.get(row.key)}: ${row.self_ms_a === null ? "–" : exactComponentMs(row.self_ms_a)} → ${row.self_ms_b === null ? "–" : exactComponentMs(row.self_ms_b)}${opts.verbose ? ` (${row.key})` : ""}`);
-    for (const [label, rows] of [
+      rows.full(`  ${shown.get(row.key)}: ${row.self_ms_a === null ? "–" : exactComponentMs(row.self_ms_a)} → ${row.self_ms_b === null ? "–" : exactComponentMs(row.self_ms_b)}${opts.verbose ? ` (${row.key})` : ""}`);
+    for (const [label, list] of [
       [READ_WORDS.onlyB, c?.added ?? []],
       [READ_WORDS.onlyA, c?.removed ?? []]
     ]) {
-      for (const row of rows)
-        out.push(`  ${shown.get(row.key)}: ${label}; ${row.self_ms === null ? "–" : exactComponentMs(row.self_ms)}${opts.verbose ? ` (${row.key})` : ""}`);
+      for (const row of list)
+        rows.full(`  ${shown.get(row.key)}: ${label}; ${row.self_ms === null ? "–" : exactComponentMs(row.self_ms)}${opts.verbose ? ` (${row.key})` : ""}`);
     }
     const page = w.component_page;
     if (page) {
       for (const side of ["a", "b"]) {
         if (!page.measured[side])
-          out.push(`  ${notMeasuredText(side)}`);
+          rows.full(`  ${notMeasuredText(side)}`);
         for (const row of page.uncompared?.[side] ?? [])
-          out.push(`  ${shown.get(row.key)}: ${side === "a" ? READ_WORDS.runA : READ_WORDS.runB} ${row.self_ms === null ? "–" : exactComponentMs(row.self_ms)}${opts.verbose ? ` (${row.key})` : ""}`);
+          rows.full(`  ${shown.get(row.key)}: ${side === "a" ? READ_WORDS.runA : READ_WORDS.runB} ${row.self_ms === null ? "–" : exactComponentMs(row.self_ms)}${opts.verbose ? ` (${row.key})` : ""}`);
       }
-      out.push(`  ${componentPageText(page.page, components.length)}`);
+      rows.full(`  ${componentPageText(page.page, components.length)}`);
     } else if (c?.totals)
-      out.push(`  ${componentListsText(c.totals, { rows: c.rows.length, added: c.added?.length ?? 0, removed: c.removed?.length ?? 0 })}`);
+      rows.full(`  ${componentListsText(c.totals, { rows: c.rows.length, added: c.added?.length ?? 0, removed: c.removed?.length ?? 0 })}`);
     if (c?.omissions)
       for (const side of ["a", "b"]) {
         if (page && !page.measured[side])
           continue;
         const o = c.omissions[side];
         if (o.sdkOmitted === null || o.omitted === null || o.sdkOmitted > 0 || o.omitted > 0)
-          out.push(`  ${omissionText({ run_id: side === "a" ? READ_WORDS.runA : READ_WORDS.runB, ...o })}`);
+          rows.full(`  ${omissionText({ run_id: side === "a" ? READ_WORDS.runA : READ_WORDS.runB, ...o })}`);
       }
+    const top = new Set(ms.map((m) => ({ m, by: timeMove(m.metric, m.a, m.b) })).filter((x) => x.by !== null && x.by > 0).sort((x, y) => y.by - x.by).slice(0, SHORT_COMPARE_MEASURES).map((x) => x.m));
     for (const m of ms)
-      out.push(`  ${m.label.padEnd(28)}${m.a_text.padStart(10)} → ${m.b_text}`);
+      rows.add(top.has(m), `  ${m.label.padEnd(28)}${m.a_text.padStart(10)} → ${m.b_text}`);
   }
-  return out.join(`
-`);
+  const p = r.windows_page;
+  if (p) {
+    const order = p.order === "moved" ? ", the ones whose time moved most first" : "";
+    const shownText = r.windows.length ? `Showing places ${p.offset + 1}–${p.offset + r.windows.length} of ${p.total}${order}` : `Showing none of ${p.total} places`;
+    rows.both("", p.next_offset !== null ? `${shownText}; the rest from offset ${p.next_offset} (--offset ${p.next_offset}).` : `${shownText}.`);
+  }
+  return rows.render(opts.form, ["the component lines", `the measures beyond each place's ${SHORT_COMPARE_MEASURES} times that moved most`]);
 }
 function formatHistory(h, opts = {}) {
   const r = new Rows;
   r.both(`${h.window_name}${opts.verbose ? ` (${h.window})` : ""} in ${h.journey_title ?? h.journey} on ${h.branch}: ${h.points.length ? `${plural2(h.points.length, "run")}, oldest first` : h.note ?? "no runs"}`);
   const ms = h.measures.slice(0, 4);
+  const renamed = h.renamed;
+  const renamedAt = renamed ? h.points.findIndex((p) => p.run_id === renamed.from_run_id) : -1;
+  const renamedShown = renamedAt >= h.points.length - SHORT_POINTS;
   if (h.points.length) {
     r.both(`  ${"when".padEnd(17)}${ms.map((m) => (m.label.length > 22 ? `${m.label.slice(0, 21)}…` : m.label).padStart(24)).join("")}  commit`);
     h.points.forEach((p, i) => {
-      r.add(i >= h.points.length - SHORT_POINTS, `  ${(p.at ?? "").slice(0, 16).replace("T", " ").padEnd(17)}${ms.map((m) => fieldValueText(m.metric, p.values[m.metric]).padStart(24)).join("")}  ${commitText(p.commit)}`);
+      if (renamed && i === renamedAt) {
+        const full = `${placeNamesChangedTitle(renamed.sdk)}: ${placeWasText(renamed.legacy_window)}`;
+        if (renamedShown)
+          r.twin(full, `${placeChartMarker(sdkTag(renamed.sdk))}: ${placeWasText(renamed.legacy_window)}`);
+        else
+          r.full(full);
+      }
+      r.add(i >= h.points.length - SHORT_POINTS, `  ${(p.at ?? "").slice(0, 16).replace("T", " ").padEnd(17)}${ms.map((m) => fieldValueText(m.metric, p.values[m.metric]).padStart(24)).join("")}  ${commitText(p.commit)}${opts.verbose && p.window ? ` (${p.window})` : ""}`);
     });
   }
   if (h.findings.length)
     r.both("", "Findings on this window:", ...h.findings.map((f) => `  ${f.answer.headline} — ${f.where.branch} (${f.id})`));
   const older = Math.max(0, h.points.length - SHORT_POINTS);
-  return r.render(opts.form, older ? [plural2(older, "older run")] : []);
+  return r.render(opts.form, [
+    ...older ? [plural2(older, "older run")] : [],
+    ...renamed && renamedAt >= 0 && !renamedShown ? [placeNamesChangedOmitted(sdkTag(renamed.sdk))] : []
+  ]);
 }
 function formatCommits(c) {
   return [
-    `${plural2(c.commits.length, "measured commit")} (${plural2(c.sessions, "session")}) on ${c.branch}, oldest first:`,
-    ...c.commits.map((x) => `  ${when(x.first_measured_at)}  ${commitText(x)}${x.pull_request?.number ? `, PR #${x.pull_request.number}` : ""}${x.sessions > 1 ? `; ${x.sessions} sessions, the last ${when(x.last_measured_at)}` : ""}`),
+    `${plural2(c.commits.length, "measured commit")} (${plural2(c.sessions, "session")}) ${c.from_branch ? `from ${c.from_branch} to ${c.branch}` : `on ${c.branch}`}, oldest first:`,
+    ...c.commits.map((x) => `  ${when(x.first_measured_at)}  ${commitText(x)}${c.from_branch && x.branch ? ` on ${x.branch}` : ""}${x.pull_request?.number ? `, PR #${x.pull_request.number}` : ""}${x.sessions > 1 ? `; ${x.sessions} sessions, the last ${when(x.last_measured_at)}` : ""}`),
     c.note
   ].join(`
 `);
@@ -12333,7 +13356,7 @@ function formatSessionPlaces(p, opts = {}) {
     return r.both("Stale: its statistics are of another derivation or stats version and are not served until the next recompute rewrites them; nothing is known about its places (not zero).").render(opts.form);
   const by = p.filters.measure;
   const byLabel = p.places.flatMap((x) => x.measures).find((m) => m.measure === by)?.label ?? by;
-  r.both(`Stored per-session statistics: no verdict, no comparison. Places by ${byLabel} (${p.filters.sort}), highest first${p.filters.window ? `, matching “${p.filters.window}”` : ""}${p.without_measure ? `; ${p.without_measure} of ${p.total} places ${p.without_measure === 1 ? "has" : "have"} no value for it` : ""}.`, "");
+  r.both(`Stored per-session statistics: no verdict, no comparison. Places by ${byLabel} (${p.filters.sort}), highest first${p.filters.window ? `, matching “${p.filters.window}”` : ""}${p.without_measure ? `; ${p.without_measure} of ${p.total} places ${p.without_measure === 1 ? "has" : "have"} no value for it` : ""}${p.folded_twins ? `; ${foldedTwinsText(p.folded_twins)}` : ""}.`, "");
   let componentLines = 0;
   p.places.forEach((place, i) => {
     const m = place.measures.find((x) => x.measure === by);
@@ -12406,13 +13429,13 @@ function formatMainSessions(h, opts = {}) {
     if (!s.places)
       r.add(k, `  ${MAIN_SUMMARY_PENDING}${s.summary_reason ? ` (${s.summary_reason})` : ""}`);
     else
-      r.add(k, `  ${MAIN_TIERS_WORST_FIRST.map((tier) => `${MAIN_TIER_WORDS[tier]}: ${s.places[tier]}`).join("; ")}${s.cant_reason ? `; ${mainSessionCantWords(s.places.cant, s.cant_reason, baseline)}` : ""}`);
+      r.add(k, `  ${MAIN_TIERS_WORST_FIRST.map((tier) => `${MAIN_TIER_WORDS[tier]}: ${s.places[tier]}`).join("; ")}${s.cant_reason ? `; ${mainSessionCantWords(s.places.cant, s.cant_reason, baseline)}` : s.cant_range ? `; ${mainSessionCantRangeWords(s.places.cant, s.cant_range, baseline)}` : ""}`);
     if (s.waiting_sessions)
       r.add(k, `  ${waitingSessionsWords(s.waiting_sessions)}`);
     if (s.memory)
       r.add(k, `  Memory: ${MAIN_TIER_WORDS[s.memory.tier]}, ${s.memory.median} MB (n ${s.memory.n})${s.memory.cant_reason ? `; ${mainCantWords(s.memory.cant_reason, baseline)}` : ""}`);
     for (const v of h.versions.filter((v) => v.from_run_set_id === s.run_set_id))
-      r.add(k, `  Version: ${v.label}; ${mainCutWords(v)}`);
+      r.add(k, `  Version: ${v.label}; ${mainCutWords(v)}`, ...renamedReleaseLines(v.renamed));
     for (const c of h.changes.filter((c) => c.from_run_set_id === s.run_set_id)) {
       r.add(s === latest, `  Main change: ${windowQualified(c.place)}${opts.verbose ? ` (${c.place}; ${c.ref})` : ""} ${storedRefWords(c.ref, h.changes.filter((x) => x.place === c.place && x.from_run_set_id === c.from_run_set_id).map((x) => x.ref))}, ${c.before_median ?? "–"} → ${c.after_median ?? "–"}`);
       if (k && s !== latest)
@@ -12425,15 +13448,36 @@ function formatMainSessions(h, opts = {}) {
     ...otherChanges ? [plural2(otherChanges, "main change") + " of the other recent sessions"] : []
   ]);
 }
+function formatMainChanges(m) {
+  const r = new Rows().both("Main changes: confirmed level shifts of main, newest first, with the commits from the session before to the first session at the new level.");
+  if (!m.changes.length)
+    r.both("No main changes recorded for this journey and phone.");
+  const short = (sha) => sha?.slice(0, 7) ?? "–";
+  for (const c of m.changes) {
+    r.both(`${when(c.at)}  ${windowQualified(c.place)} ${storedRefWords(c.measure, m.changes.filter((x) => x.place === c.place && x.at === c.at).map((x) => x.measure))}, ${c.from ?? "–"} → ${c.to ?? "–"}, ${MAIN_TIER_WORDS[c.direction]}`);
+    r.both(`  Commits ${short(c.commits[0])} → ${short(c.commits[1])}`);
+    if (c.prs === null)
+      r.both("  PRs not known: no stored merges reach the session before (an older agent, a shallow clone, or no session before)");
+    else if (!c.prs.length)
+      r.both("  No PRs in this range: both sessions ran on the same commit");
+    for (const p of c.prs ?? [])
+      r.both(`  ${p.number === null ? `${short(p.sha)} ${p.title} (no PR)` : `#${p.number} ${p.title}`}`);
+  }
+  return r.render("full");
+}
 function formatMainSessionPlaces(p, opts = {}) {
   const r = new Rows;
   if (p.status !== "ok")
     return r.both(`${MAIN_SUMMARY_PENDING}${p.summary_reason ? ` (${p.summary_reason})` : ""}`).render(opts.form);
   const baselineSessions = p.baseline_sessions;
   r.both(`Main session places: tiers are verdicts vs ${p.baseline_sessions === undefined ? "earlier sessions" : `the ${p.baseline_sessions} sessions before`}.`);
-  for (const x of p.places)
-    r.add(x.tier !== "same", `  ${windowQualified(x.place)}${opts.verbose ? ` (${x.place}; ${x.ref})` : ""} ${storedRefWords(x.ref, p.places.filter((row) => row.place === x.place).map((row) => row.ref))}: ${MAIN_TIER_WORDS[x.tier]}${x.reason ? `; ${mainPlaceReasonWords(x.reason, { baseline: { sessions: baselineSessions } })}` : ""}`);
-  const inNorm = p.places.filter((x) => x.tier === "same").length;
+  const kept = new Set(foldTwins([...p.places].sort((a, b) => MAIN_TIER_RANK[a.tier] - MAIN_TIER_RANK[b.tier]), (x) => x.place, (x) => x.ref).rows);
+  const places = p.places.filter((x) => kept.has(x));
+  for (const x of places)
+    r.add(x.tier !== "same", `  ${windowQualified(x.place)}${opts.verbose ? ` (${x.place}; ${x.ref})` : ""} ${storedRefWords(x.ref, places.filter((row) => row.place === x.place).map((row) => row.ref))}: ${MAIN_TIER_WORDS[x.tier]}${x.reason ? `; ${mainPlaceReasonWords(x.reason, { baseline: { sessions: baselineSessions } })}` : ""}${x.reason && mainUnstableWords(x.reason) ? `. ${mainUnstableWords(x.reason)}` : ""}`);
+  if (places.length < p.places.length)
+    r.both(`  ${foldedTwinsText(p.places.length - places.length)}`);
+  const inNorm = places.filter((x) => x.tier === "same").length;
   return r.render(opts.form, inNorm ? [plural2(inNorm, "place") + " in norm"] : []);
 }
 var signed = (n) => `${n > 0 ? "+" : ""}${Number(n.toFixed(3))}`;
@@ -12443,7 +13487,7 @@ function formatMainVsPrevious(m, opts = {}) {
   if (m.cut === "unknown")
     r.both("History restart: unknown; current summaries unavailable.");
   else if (m.cut)
-    r.both(`History restart: ${m.cut.label}; ${m.cut.cuts.join(", ")}. Numbers cross this restart.`);
+    r.both(`History restart: ${m.cut.label}; ${m.cut.cuts.join(", ")}. Numbers cross this restart.`, ...renamedReleaseLines(m.cut.renamed));
   if (m.not_computed.length)
     r.both(`not_computed: ${m.not_computed.join(", ")}`);
   if (m.stale.length)
@@ -12456,6 +13500,28 @@ function formatMainVsPrevious(m, opts = {}) {
   const smaller = m.places.filter((p, i) => i >= SHORT_PLACES && p.status === "compared").length;
   return r.render(opts.form, smaller ? [plural2(smaller, "smaller mover")] : []);
 }
+function renamedReleaseLines(renamed) {
+  if (!renamed)
+    return [];
+  return [...renamed.places.length ? [`  ${placeNamesChangedTitle(renamed.sdk)}`] : [], ...renamed.dimensions.includes("component") ? [`  ${componentNotJoinedText(renamed.sdk)}`] : []];
+}
+function renamedLines(renamed, places) {
+  if (!renamed)
+    return [];
+  const asked = places.filter((p) => p.legacy_window !== undefined);
+  const windows = [...new Map(asked.map((p) => [p.window, p.legacy_window ?? null])).entries()];
+  const component = renamed.dimensions.includes("component") && places.some((p) => p.ref.startsWith("b:component:"));
+  return [
+    ...windows.length ? [`  ${placeNamesChangedTitle(renamed.sdk)}`, ...windows.map(([w, old]) => `    ${windowQualified(w)}: ${old ? placeWasText(old) : PLACE_NOT_JOINED_TEXT}`)] : [],
+    ...component ? [`  ${componentNotJoinedText(renamed.sdk)}`] : []
+  ];
+}
+function storedValueText(ref, v, unit) {
+  const rest = ref.slice(2);
+  const field = ref.startsWith("b:") ? `${rest.slice(0, rest.lastIndexOf(":"))}.${rest.slice(rest.lastIndexOf(":") + 1)}` : rest;
+  const text = fieldValueText(field, v);
+  return unit && !/[^\d.,\s-]/.test(text) ? `${text} ${unit}` : text;
+}
 function formatPlaceTrend(t, opts = {}) {
   const r = new Rows().both(`${t.journey} · ${t.phone.model} · ${t.baseline_branch}: stored per-session statistics`);
   const newest = new Set(t.sessions.slice(-SHORT_SESSIONS).map((s) => s.run_set_id));
@@ -12467,6 +13533,8 @@ function formatPlaceTrend(t, opts = {}) {
       r.both(`History restarts unknown: ${session.run_set_id} (no current main summary in the history window)`);
     for (const restart of t.restarts.filter((x) => x.from_run_set_id === session.run_set_id)) {
       r.add(k, `History restarts: ${restart.label} (${restart.cuts.join(", ")})`);
+      for (const line of renamedLines(restart.renamed, t.places))
+        r.add(k, line);
       if (!k)
         olderRestarts++;
     }
@@ -12474,10 +13542,10 @@ function formatPlaceTrend(t, opts = {}) {
       const value = place.sessions.find((s) => s.run_set_id === session.run_set_id);
       if (!value)
         continue;
-      const unit = place.unit ? ` ${place.unit}` : "";
+      const value_ = (v) => storedValueText(place.ref, v, place.unit);
       if (!k)
         olderSessions.add(session.run_set_id);
-      r.add(k, `${session.completed_at?.slice(0, 10) ?? "date unknown"} ${session.commit.sha?.slice(0, 7) ?? "commit unknown"} · ${windowQualified(place.window)}${opts.verbose ? ` (${place.window}; ${place.ref})` : ""} · ${place.label} (${storedRefWords(place.ref, t.places.filter((row) => row.window === place.window).map((row) => row.ref))}): median ${value.median}${unit}, MAD ${value.mad}${unit}, n=${value.n}`);
+      r.add(k, `${session.completed_at?.slice(0, 10) ?? "date unknown"} ${session.commit.sha?.slice(0, 7) ?? "commit unknown"} · ${windowQualified(place.window)}${opts.verbose ? ` (${value.window ?? place.window}; ${place.ref})` : ""} · ${place.label} (${storedRefWords(place.ref, t.places.filter((row) => row.window === place.window).map((row) => row.ref))}): median ${value_(value.median)}, MAD ${value_(value.mad)}, n=${value.n}`);
     }
   }
   if (!t.sessions.length)
@@ -12534,6 +13602,8 @@ var branchStatus = (t, branch) => get(t, "v1/branches/status", { branch });
 var listProblems = (t, f = {}) => get(t, "v1/problems", { branch: f.branch, main: f.main ? "true" : undefined, journey: f.journey, phone: f.phone, limit: f.limit, offset: f.offset || undefined });
 var getFinding = (t, id) => get(t, `v1/findings/${encodeURIComponent(id)}`);
 var compareRuns = (t, a, b, page = {}) => get(t, "v1/compare", { a, b, ...page });
+var SHORT_COMPARE_PLACES = 10;
+var compareQuery = (short, page) => short ? { order: "moved", limit: SHORT_COMPARE_PLACES, ...page } : page;
 var windowHistory = (t, q) => get(t, "v1/history", q);
 var commitsBetween = (t, q) => get(t, "v1/commits", q);
 var layers = (t) => get(t, "v1/layers");
@@ -12554,6 +13624,7 @@ var sessionPlaces = (t, f) => get(t, "v1/sessions/places", {
 });
 var SESSION_SORTS = ["median", "p90", "mad"];
 var mainSessions = (t, q) => get(t, "v1/main/sessions", { ...q });
+var mainChanges = (t, q) => get(t, "v1/main/changes", { ...q });
 var mainSessionPlaces = (t, runSetId, q) => get(t, `v1/main/sessions/${encodeURIComponent(runSetId)}/places`, { ...q });
 var mainVsPrevious = (t, q) => {
   const { run_set, ...query } = q;
@@ -12567,12 +13638,13 @@ var FINDINGS_USAGE = `keepsnappy findings [--branch NAME | --main] [--journey KE
   problems --branch NAME | --main [--journey KEY] [--phone MODEL] [--limit N] [--offset N] [--short] [--json]
            (the single problems "Over budget" / "Far over budget" in the branch's own runs, whatever main does: not a regression, never blocking)
   finding  <id> [--prompt] [--short] [--json]                      (--prompt: only the hand-off for a coding agent; with --json the whole finding)
-  compare  <runA> <runB> [--json]                                  (run ids or external ids; one run against one, no statistics)
+  compare  <runA> <runB> [--short] [--limit N] [--offset N] [--json] (run ids or external ids; one run against one, no statistics; --short: the places whose time moved most)
   history  <journey> <window> [--phone MODEL] [--short] [--json]   (exact window id, e.g. "press:live.chat.send")
   commits  <from> [<to>] [--branch NAME] [--json]                  (measured commits between two run sets or commit hashes)
   places   [--run-set ID | --journey KEY [--phone MODEL] [--branch NAME]] [--measure ID] [--sort median|p90|mad] [--window TEXT] [--limit N] [--offset N] [--top-components N] [--short] [--json]
            (every place of one session from its stored statistics: no verdict; the newest closed run set of the journey when --run-set is not given)
   main     --journey KEY --phone MODEL [--sessions N | --session ID] [--vs-previous] [--measure REF] [--limit N] [--offset N] [--short] [--json]
+  main     --journey KEY --phone MODEL --changes [--limit N] [--json]   (main's confirmed changes, newest first: commit range from the session before to the first session at the new level, and the PRs merged in it)
   layers   [--json]
   trend    <journey> <window words...> --phone MODEL [--window PLACE ...] [--ref REF ...] [--sessions N] [--short] [--json]
            (the words after the journey are one window name; more windows with repeated --window)
@@ -12582,7 +13654,7 @@ ${READ_USAGE.detailFlag}
   --short  (findings, status, problems, finding, history, places, main, trend: what decides, without the evidence detail; the same as the MCP tools' form short; --json is unchanged)
   (key: KEEPSNAPPY_KEY or --key-env NAME; API: --api URL or KEEPSNAPPY_API)`;
 var STATES = ["present", "not-judged", "resolved", "all"];
-var SHORT_COMMANDS = new Set(["findings", "status", "problems", "finding", "history", "places", "main", "trend"]);
+var SHORT_COMMANDS = new Set(["findings", "status", "problems", "finding", "compare", "history", "places", "main", "trend"]);
 var FINDINGS_COMMANDS = new Set(["findings", "status", "problems", "finding", "compare", "history", "commits", "places", "layers", "main", "trend"]);
 async function findingsCommand(cmd, argv, rt) {
   const args = (() => {
@@ -12602,6 +13674,7 @@ async function findingsCommand(cmd, argv, rt) {
           state: { type: "string" },
           session: { type: "string" },
           "vs-previous": { type: "boolean" },
+          changes: { type: "boolean" },
           limit: { type: "string" },
           offset: { type: "string" },
           "run-set": { type: "string" },
@@ -12662,6 +13735,11 @@ async function findingsCommand(cmd, argv, rt) {
       if (sessions !== undefined && (o.session || o["vs-previous"]))
         throw new UsageError(["--sessions is for the session list"]);
       const lane = { journey: o.journey, phone: o.phone };
+      if (o.changes) {
+        if (sessions !== undefined || o.session || o["vs-previous"] || o.measure || o.short || offset !== undefined)
+          throw new UsageError(["--changes takes only --journey, --phone, --limit and --json"]);
+        return out(await mainChanges(t, { ...lane, ...limit ? { limit } : {} }), formatMainChanges);
+      }
       if (o["vs-previous"])
         return out(await mainVsPrevious(t, { ...lane, run_set: o.session, measure: o.measure, limit, offset }), formatMainVsPrevious);
       if (o.session)
@@ -12715,7 +13793,8 @@ async function findingsCommand(cmd, argv, rt) {
       const size = o["top-components"] === undefined ? 12 : Number(o["top-components"]);
       if (!Number.isInteger(size) || size < 1 || size > 200)
         throw new UsageError([READ_USAGE.compareTop]);
-      const query = page || o.all || o["top-components"] !== undefined ? { component_offset: ((page ?? 1) - 1) * size, component_limit: size } : {};
+      const components = page || o.all || o["top-components"] !== undefined ? { component_offset: ((page ?? 1) - 1) * size, component_limit: size } : {};
+      const query = compareQuery(o.short === true, { ...components, ...limit ? { limit } : {}, ...offset !== undefined ? { offset } : {} });
       const compared = await compareRuns(t, p[0], p[1], query);
       return out(o.all ? await allCompare(t, compared, size) : compared, formatCompare);
     }
@@ -12868,7 +13947,7 @@ var USAGE = `keepsnappy <command>
           [--device-model NAME --device-os VERSION] [--scenario NAME] [--replay <out dir>[:ARM] ...]
           [--no-markers] [-- <e2e command...>]
           (--fail-on-worse: exit 3 only when the verdict computed on that run set is Worse and blocking; closing never computes one,
-           so with no computed verdict it checks nothing: "Verdict not computed yet (computed on demand): --fail-on-worse checked nothing", exit 0)
+           so with no computed verdict it checks nothing: "${UNCHECKED_GATE}", exit 0)
   measure --repeat N [--arms A=<app|bundle>,B=<app|bundle>] [--arm-env 'A:KEY=VAL' ...] [--bundle-id ID] [--platform ios-sim|ios-device]
           [--device UDID] [--out DIR] [--timeout SEC] [--ri-capture observations.ndjson] [--mem-window NAME]
           [--clock-offset-ms N] [--no-markers]
@@ -12898,7 +13977,7 @@ async function bundleIdOf(deps, target, explicit) {
   if (explicit)
     return explicit;
   if (!target)
-    throw new Error("give --bundle-id (or an arm whose target is a bundle id or .app)");
+    throw new ConfigError(["give --bundle-id (or an arm whose target is a bundle id or .app)"]);
   if (!isBuildPath(target))
     return target;
   const r = await deps.spawner.run("plutil", ["-extract", "CFBundleIdentifier", "raw", `${target.replace(/\/$/, "")}/Info.plist`]);