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

package/dist/keepsnappy.js

@@ -2198,6 +2198,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 +2324,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 +3181,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 +3245,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 +3296,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 +3314,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 +3734,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 +3880,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 +4993,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 +5029,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 +5038,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,100 +5201,6 @@ 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;
 
@@ -5285,7 +5242,12 @@ 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_JUDGED_WORD = "Not judged";
 
 // packages/present/dist/src/values.js
 var NO_VALUE = "–";
@@ -5314,17 +5276,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 = ":";
@@ -5370,6 +5338,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}`;
@@ -5544,8 +5520,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 = {
@@ -5684,6 +5686,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",
@@ -5761,6 +5767,409 @@ 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 places = (n) => `${n.toLocaleString("en-US")} ${n === 1 ? "place" : "places"}`;
+var of = (n, total) => `${n.toLocaleString("en-US")} of ${places(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 (${places(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 ${places(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",
+  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 ${places(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)}`,
+  link: {
+    lane: (journey, phone) => `Open ${journey} on ${phone}`,
+    phone: (phone) => `Open on ${phone}`,
+    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, beside: 18, place: 16, link: 60, button: 30 };
+var DETAIL = 64;
+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}`;
+};
+function clipPlace(place, n) {
+  if (place.length <= n)
+    return place;
+  let cut = place.slice(0, n);
+  if (place[n] !== " " && cut.includes(" "))
+    cut = cut.slice(0, cut.lastIndexOf(" "));
+  cut = cut.trimEnd();
+  const open = (cut.match(/“/g) ?? []).length > (cut.match(/”/g) ?? []).length;
+  return `${cut}…${open ? "”" : ""}`;
+}
+var changeText2 = (c, room) => {
+  const what = `${c.measure} ${c.main !== null && c.now !== null ? fromTo(c.main, c.now) : c.change}`;
+  return c.place ? `${clipPlace(c.place, Math.max(NAME.place, room - what.length - 3))} · ${what}` : upper(what);
+};
+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"]));
+}
+var noneMoved = VERDICT_SECTION_WORDS.noneMoved(1).replace(/ \(.*\)$/, "");
+function conditions(l, pr) {
+  const moved = l.state === "worse" || l.state === "warning";
+  const heat = l.heatedRuns ? SUMMARY_WORDS.heated(l.heatedRuns, l.runs) : "";
+  const heatIsNews = l.state === "no-change" && !!heat;
+  return {
+    always: [pr && l.state === "worse" ? l.blocking ? VERDICT_SECTION_WORDS.blocksMerge : NOT_BLOCKING : "", heatIsNews ? heat : ""].filter(Boolean),
+    optional: [
+      moved && l.measuredDifferently ? SUMMARY_WORDS.measuredDifferently : "",
+      (moved || l.state === "better") && l.fewRuns ? SUMMARY_WORDS.fewRuns : "",
+      heatIsNews ? "" : heat
+    ].filter(Boolean)
+  };
+}
+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)}`,
+      detail: 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 single = input.lanes.length === 1;
+  const phone = l.phone ?? "unknown phone";
+  const several = journeys === 1 ? SUMMARY_WORDS.phones(new Set(input.lanes.map((x) => x.phone ?? "-")).size) : SUMMARY_WORDS.journeys(journeys);
+  const newestSlower = !input.pr && (l.state === "worse" || l.state === "warning");
+  const named = (subject, rest) => [clip(subject, rest.length ? NAME.beside : NAME.name), ...rest];
+  const what = input.pr ? named(input.branch, single ? [] : [several]) : single || journeys === 1 ? named(l.journey ?? "journey", single ? [] : [several]) : [several];
+  const lead = newestSlower ? [SUMMARY_WORDS.main, ...what, SUMMARY_WORDS.newestSlower].join(" · ") : [notJudgedWhy(l) ? NOT_JUDGED_WORD : WORD[l.state], ...what].join(" · ");
+  const top = l.state === "worse" || l.state === "warning" || l.state === "better" ? l.changes[0] : undefined;
+  const { always, optional } = conditions(l, input.pr);
+  const answer = top ? null : always.includes(SUMMARY_WORDS.heated(l.heatedRuns, l.runs)) ? noneMoved : why(l);
+  let extra = [...always];
+  for (const c of optional)
+    if ((answer ?? changeText2(top, 0)).length + `; ${[...extra, c].join(", ")}`.length <= DETAIL)
+      extra = [...extra, c];
+  const tail = extra.length ? `; ${extra.join(", ")}` : "";
+  const detail = `${top ? changeText2(top, DETAIL - tail.length) : answer}${tail}`;
+  const journey = clip(l.journey ?? "journey", NAME.link);
+  const short = (full, fallback) => full.length <= NAME.button ? full : fallback;
+  const label = single ? short(SUMMARY_WORDS.link.lane(journey, phone), SUMMARY_WORDS.link.phone(phone)) : input.pr ? SUMMARY_WORDS.link.branch(clip(input.branch, NAME.button - 5)) : journeys === 1 ? short(SUMMARY_WORDS.link.lane(journey, several), SUMMARY_WORDS.link.phone(several)) : SUMMARY_WORDS.link.runSet;
+  return { state: l.state, newestSlower, lead, detail, link: { label, url: (single ? l.url : null) ?? input.url } };
+}
+function pendingMessage(branch, url) {
+  return { state: "not-computed", newestSlower: false, lead: `${SUMMARY_WORDS.notComputed} · ${clip(branch, NAME.name)}`, detail: 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)}`, detail: 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),
+      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)
+  };
+}
+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 });
+var MESSAGE_COLORS = { error: "#D6334A", warn: "#C47A00", better: "#238359", none: "#7C8492" };
+function messageTone(s) {
+  const lanes = s ? lanesOf(s) : [];
+  if (lanes.some((l) => l.state === "worse" && l.blocking))
+    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.detail}
+${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), "⚪");
+// 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 };
+}
+
 // apps/agent/src/summary.ts
 var fieldWord = (field) => measureDef(field)?.short ?? field;
 function plainMetric(metric) {
@@ -5799,7 +6208,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 +6215,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 +6224,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 = [
@@ -5887,16 +6270,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 +6308,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 +6330,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 +9711,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 +9721,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 +9735,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 +9784,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 +9884,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 +9904,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 +9918,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 +9952,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 +10006,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 +10046,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 +10119,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 +10138,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) }),
@@ -9808,7 +10204,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 +10215,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 +10252,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 +10714,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.18";
   if (built)
     return built;
   let dir = dirname2(fileURLToPath(import.meta.url));
@@ -10374,6 +10769,576 @@ 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-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-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"
+];
+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"
+];
+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)."
+  }
+];
+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;
+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 noise = CLAUSES["T-WARN-NOISE"];
+  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 };
+    return {
+      ...r,
+      threshold: [{ abs: warnMs.update, noise: n }],
+      thresholdByWork: { entry: [{ abs: warnMs.work, noise: n }], mount: [{ abs: warnMs.work, noise: n }] },
+      errorNoise: { ...n, lift: fit.k99 },
+      uncalibrated: 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 rules = base.rules.map((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 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]))
+    }))
+  };
+}
+var SHAPE = {
+  id: "simple-4.25+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: [
+    noiseJudged("commit", { measure: "commit_max_ms" }),
+    noiseJudged("render", { measure: "render_ms" }),
+    noiseJudged("component", { dimension: "component", measure: "self_ms" }),
+    { ...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"),
+    {
+      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
+    }
+  ],
+  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",
+    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`
+  }],
+  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 +11417,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 +11505,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 +11592,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 +11620,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 +11745,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 +11767,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 +11807,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 +11862,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 +11883,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 +12203,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 +12213,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 +12222,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 +12319,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 +12422,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(","),
@@ -11992,9 +12778,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 +12813,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 +12841,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,6 +12859,7 @@ 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.full(...(n.session_speed ?? []).map((line) => `  ${line}`));
     r.both(...laneContextLines(n.context, n.journey, n.phone_name, opts.verbose, opts.form === "short"));
     return [];
   }
@@ -12078,6 +12869,7 @@ function measuredLines(l, r, opts) {
     const keep = !x.judged || !!x.context;
     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.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 +12888,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)` : "",
@@ -12144,6 +12936,7 @@ function formatBranchStatus(s, opts = {}) {
     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.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)
@@ -12283,16 +13076,29 @@ 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 [
@@ -12412,7 +13218,7 @@ function formatMainSessions(h, opts = {}) {
     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,6 +13231,23 @@ 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")
@@ -12432,7 +13255,7 @@ function formatMainSessionPlaces(p, opts = {}) {
   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 } })}` : ""}`);
+    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 } })}` : ""}${x.reason && mainUnstableWords(x.reason) ? `. ${mainUnstableWords(x.reason)}` : ""}`);
   const inNorm = p.places.filter((x) => x.tier === "same").length;
   return r.render(opts.form, inNorm ? [plural2(inNorm, "place") + " in norm"] : []);
 }
@@ -12443,7 +13266,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 +13279,22 @@ 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 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 +13306,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++;
     }
@@ -12477,7 +13318,7 @@ function formatPlaceTrend(t, opts = {}) {
       const unit = place.unit ? ` ${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.median}${unit}, MAD ${value.mad}${unit}, n=${value.n}`);
     }
   }
   if (!t.sessions.length)
@@ -12554,6 +13395,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;
@@ -12573,6 +13415,7 @@ var FINDINGS_USAGE = `keepsnappy findings [--branch NAME | --main] [--journey KE
   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)
@@ -12602,6 +13445,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 +13506,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)
@@ -12868,7 +13717,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 +13747,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`]);