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

package/dist/keepsnappy.js

@@ -212,6 +212,15 @@ class ConfigError extends Error {
     this.name = "ConfigError";
   }
 }
+
+class UsageError extends ConfigError {
+  constructor(lines) {
+    super(lines);
+    this.message = lines.join(`
+`);
+    this.name = "UsageError";
+  }
+}
 var TITLE_MAX = 200;
 var DESCRIPTION_MAX = 2000;
 var TOP = ["project", "app", "platform", "device", "repetitions", "flows", "steps", "output", "timeout_seconds"];
@@ -2189,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) => {
@@ -2314,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;
@@ -3171,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 = [];
@@ -3197,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) => {
@@ -3247,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;
@@ -3265,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 } };
   });
 }
 
@@ -3674,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 } : {} });
   }
@@ -3820,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) {
@@ -4933,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);
@@ -4969,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)}`);
@@ -4978,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);
@@ -5141,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 {
-    return {};
-  }
-}
-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;
 
@@ -5276,6 +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}${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 = "–";
@@ -5304,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 = ":";
@@ -5348,6 +5326,47 @@ var JOURNEY_ROW_WORDS = {
   notInRun: upperFirst(GONE_TAILS.journey.notInRun),
   removed: upperFirst(GONE_TAILS.journey.removed)
 };
+var NEW_IN_PR_CHIP = "New in this PR";
+var placeNamesChangedTitle = (sdk) => `Place names changed with SDK ${sdk}`;
+var restartRowText = (sdk, mainSessions, needed) => `${placeNamesChangedTitle(sdk)}: ${restartContextText(mainSessions, needed)}`;
+var restartContextText = (mainSessions, needed) => `main has ${mainSessions} of ${needed} sessions on the new names`;
+function removedRowsText(n, page) {
+  return { lead: `${plural(n, "component", "components")} ${GONE_TAILS[page].removed}:`, rest: " not counted." };
+}
+function notInRunRowsText(c, page) {
+  const what = [c.screens ? plural(c.screens, "screen", "screens") : "", c.places ? `${c.places} ${c.places === 1 ? "tap or scroll" : "taps and scrolls"}` : ""].filter(Boolean).join(" and ");
+  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}`;
+var rolledUpText = (rolledUpMs, totalMs) => `From libraries: ${valueText("self_ms", rolledUpMs)} of ${valueText("self_ms", totalMs)}`;
+var libraryLineText = (l) => `${l.name} · ${l.renders} rendered · ${valueText("self_ms", l.ms)}`;
+var rolledUpRestText = (rest) => `${plural(rest.n, "other library", "other libraries")} · ${valueText("self_ms", rest.ms)}`;
+var measureWords = (measure) => isMeasureId(measure) ? MEASURES[measure].label : `component ${BREAKDOWN_MEASURES[measure].label}`;
+var TIER_STATE = { worse: "worse", slight: "warning", better: "better", same: "no-change" };
+function leadBody(subject, measure, main, pr) {
+  const unit = shownUnit(isMeasureId(measure) ? MEASURES[measure].unit : BREAKDOWN_MEASURES[measure].unit).unit;
+  const to = valueText(measure, pr);
+  const from = valueText(measure, main);
+  const bare = unit && from.endsWith(` ${unit}`) && to.endsWith(` ${unit}`) ? from.slice(0, from.length - unit.length - 1) : from;
+  return `${subject}, ${measureWords(measure)} ${bare} → ${to}`;
+}
+var screenLeadText = (tier, subject, measure, main, pr) => `${STATE_WORDS[TIER_STATE[tier]]}: ${leadBody(subject, measure, main, pr)}`;
+var FOR_INFORMATION = "For information";
+var informationLeadText = (subject, measure, main, pr) => `${FOR_INFORMATION}: ${leadBody(subject, measure, main, pr)}`;
+function foldedText(n, rows, page) {
+  return `${n} ${GONE_TAILS[page][rows === "components" ? "removed" : "notInRun"]}`;
+}
 function placeShownName(p, o = {}) {
   const target = p.target ? componentShownName(p.target.name, p.target.file) : libraryViewName(p.kind, p.host ?? "");
   const named = p.target && p.parent ? `${target} in ${componentShownName(p.parent.name, p.parent.file)}${p.k ? `, ${ordinal(p.k)}` : ""}` : target;
@@ -5355,7 +5374,7 @@ function placeShownName(p, o = {}) {
 }
 var libraryViewName = (kind, hostType) => `${kind === "drag" ? "Scroll" : "Tap"} outside app components (${hostType})`;
 function componentShownName(name, file) {
-  if (name !== "default")
+  if (name !== "default" || !file)
     return name;
   const path = file.replace(/\.[^.\/]+$/, "");
   const route = /^(?:src\/)?app\/(.*)$/.exec(path)?.[1];
@@ -5394,7 +5413,20 @@ var BACKGROUND_SOURCES = {
   touch: "work of a tap outside its window",
   input: "work of typing outside its window"
 };
+var OPEN_WORDS = { first: "first time", repeat: "again" };
 var OPEN_MARK = /#(1|repeat)$/;
+var isInputKind = (kind) => kind === "press" || kind === "drag";
+function placeOpen(id) {
+  const ref = placeRef(id);
+  if (!isInputKind(ref.kind))
+    return null;
+  const m = OPEN_MARK.exec(ref.stem);
+  return m ? m[1] === "repeat" ? "repeat" : "first" : null;
+}
+var placeOpenWord = (id) => {
+  const open = placeOpen(id);
+  return open ? OPEN_WORDS[open] : null;
+};
 function placeIdShownName(id, o = {}) {
   const p = placeParts(id);
   if (!p)
@@ -5438,6 +5470,14 @@ function placeKindWord(id) {
   const { kind } = placeRef(id);
   return kind === "other" ? "Window" : KIND_WORD[kind];
 }
+function windowQualified(id) {
+  const word = placeOpenWord(id);
+  const label = placeLabel(id);
+  if (!word)
+    return label;
+  const after = placeRef(id).segment === "after3s" ? ` · ${PLACE_KIND_WORDS.after3s}` : "";
+  return `${after ? label.slice(0, -after.length) : label} (${word})${after}`;
+}
 var ELEMENT_SEPARATORS = /(?<!\d)\.|\.(?!\d)|[_-]+/g;
 var elementWords = (testId) => testId.replace(ELEMENT_SEPARATORS, " ").replace(/\s+/g, " ").trim();
 function placeLabel(id, screen) {
@@ -5456,27 +5496,59 @@ function placeLabel(id, screen) {
   const colon = name.indexOf(": ");
   return `${colon > 0 && ref.kind !== "other" ? `${name.slice(0, colon)} · ${name.slice(colon + 2)}` : name}${after}`;
 }
-// packages/present/dist/src/words.js
-var REASON_WORDS = {
-  "no-baseline": "there are no main runs on this phone and journey yet",
-  "too-few-runs": "there are too few valid runs on a side",
-  "judged-measures-missing": "the judged measures are missing on a side",
-  "measured-differently": "the sides were measured differently",
-  "runs-unknown": "a change that would count has no value in some runs, so it cannot be confirmed in every run",
-  "facts-version-mismatch": "the sides were derived with different versions",
-  "not-judged-on-simulators": "timing is not judged on simulators",
-  "platforms-differ": "the sides ran on different platforms (iOS and Android are never compared)",
-  "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`;
+// packages/present/dist/src/placeNames.js
+function shortestPaths(files) {
+  const out = new Map;
+  for (const file of files) {
+    const parts = file.split("/");
+    let shown = file;
+    for (let k = 1;k <= parts.length; k++) {
+      const tail = parts.slice(-k).join("/");
+      if (!files.some((f) => f !== file && f.split("/").slice(-k).join("/") === tail)) {
+        shown = tail;
+        break;
+      }
+    }
+    out.set(file, shown);
+  }
+  return out;
+}
 // packages/present/dist/src/stability.js
 var UNSTABLE_WORDS = {
   short: "main varies too much here",
   label: `${STATE_WORDS["cant-tell"]} · main varies too much here`,
   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.",
-  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."
+  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.",
+  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 = {
   renderer: "React renderer",
@@ -5493,6 +5565,131 @@ var ASPECT_WORDS = {
   endGc: "memory clean-up at the journey end",
   cpuProfiling: "CPU profiling"
 };
+var measuredDifferentlyText = (aspects) => `measured differently (${aspects.map((a) => ASPECT_WORDS[a] ?? a).join(", ")})`;
+
+// packages/present/dist/src/readWords.js
+function componentReadName(c) {
+  const ref = (c.key ? parseComponentKey(c.key) : null) ?? parseComponentKey(c.name);
+  return componentShownName(ref?.name ?? c.name, c.file ?? ref?.file ?? "");
+}
+function componentReadNames(cs) {
+  const names = cs.map(componentReadName);
+  const rawNames = cs.map((c) => (c.key ? parseComponentKey(c.key)?.name : undefined) ?? parseComponentKey(c.name)?.name ?? c.name);
+  return cs.map((c, i) => {
+    const equals = cs.filter((_, k) => rawNames[k] === rawNames[i]);
+    const file = c.file ?? (c.key ? parseComponentKey(c.key)?.file : undefined);
+    const files = equals.flatMap((x) => x.file ?? (x.key ? parseComponentKey(x.key)?.file ?? [] : []));
+    return new Set(files).size > 1 && file ? `${names[i]} · ${shortestPaths(files).get(file)}` : names[i];
+  });
+}
+function storedRefWords(ref, peers = []) {
+  if (!ref.startsWith("b:component:"))
+    return ref;
+  const cut = ref.lastIndexOf(":");
+  const key = ref.slice("b:component:".length, cut);
+  const components = [ref, ...peers].filter((r) => r.startsWith("b:component:")).map((r) => {
+    const componentKey = r.slice("b:component:".length, r.lastIndexOf(":"));
+    return { key: componentKey, name: componentKey };
+  });
+  const name = componentReadNames(components)[0] ?? componentReadName({ key, name: key });
+  return `${name}, ${measureWords(ref.slice(cut + 1))}`;
+}
+function resultContextLines(c, verbose = false, short = false) {
+  if (!c)
+    return [];
+  const out = [];
+  if (c.namesChanged)
+    out.push(restartRowText(c.namesChanged.sdk, c.namesChanged.mainSessions, c.namesChanged.needed));
+  for (const w of c.windows) {
+    const shownPlace = `${windowQualified(w.place)}${verbose ? ` (${w.place})` : ""}`;
+    if (w.slowestCommit)
+      out.push(`${shownPlace}: ${MEASURES.commit_max_ms.label}: ${valueText("commit_max_ms", w.slowestCommit.main)} → ${valueText("commit_max_ms", w.slowestCommit.pr)}`);
+    if (!w.cause)
+      continue;
+    const s = w.cause.subject;
+    const subject = s.kind === "component" ? `${componentShownName(s.ref.name, s.ref.file)}${verbose ? ` (${s.ref.file})` : ""}` : placeShownName({ kind: placeParts(s.place)?.kind === "drag" ? "drag" : "press", target: s.target, parent: s.parent, k: s.k, ...s.host ? { host: s.host } : {} });
+    out.push(`${shownPlace}: ${w.information || !w.tier ? informationLeadText(subject, w.cause.measure, w.cause.main, w.cause.pr) : screenLeadText(w.tier, subject, w.cause.measure, w.cause.main, w.cause.pr)}${w.cause.measuredDifferently?.length ? `; ${measuredDifferentlyText(w.cause.measuredDifferently)}` : ""}`);
+  }
+  const screens = new Map;
+  for (const p of c.notInThisRun) {
+    const parts = placeParts(p.place);
+    const key = parts ? componentShownName(parts.screen.name, parts.screen.file ?? "") : "";
+    screens.set(key, [...screens.get(key) ?? [], p]);
+  }
+  for (const [screen, rows] of screens) {
+    const line = notInRunRowsText({ screens: rows.filter((p) => p.kind === "screen").length, places: rows.filter((p) => p.kind !== "screen").length }, c.page);
+    out.push(`${screen ? `${screen}: ` : ""}${line.lead}${line.rest}`);
+    if (rows.length > 3)
+      out.push(`  ${foldedText(rows.length, "places", c.page)}`);
+    if (!short || rows.length <= 3)
+      out.push(...rows.map((p) => `  ${windowQualified(p.place)}`));
+  }
+  const removed = new Map;
+  for (const r of c.removed)
+    removed.set(r.place, [...removed.get(r.place) ?? [], r]);
+  for (const [place, rows] of removed) {
+    const line = removedRowsText(rows.length, c.page);
+    out.push(`${windowQualified(place)}: ${line.lead}${line.rest}`);
+    if (rows.length > 3)
+      out.push(`  ${foldedText(rows.length, "components", c.page)}`);
+    if (!short || rows.length <= 3)
+      out.push(...rows.map((r) => `  ${r.ref.kind === "breakdown" ? componentReadName({ key: r.ref.key, name: r.ref.name }) : measureWords(r.ref.measure)}`));
+  }
+  return out;
+}
+function laneContextLines(context, journey, phone, verbose = false, short = false) {
+  const lines = resultContextLines(context, verbose, short);
+  return lines.length ? [`${journey} on ${phone}:`, ...lines.map((line) => `  ${line}`)] : [];
+}
+var exactComponentMs = (ms) => `${ms} ms`;
+var componentPageText = (page, count) => `Component rows: ${count ? `${page.offset + 1}–${page.offset + count}` : "0"} of ${page.total} stored${page.next_offset !== null ? `; next --page ${Math.floor(page.next_offset / page.limit) + 1} (MCP component_offset ${page.next_offset})` : ""}.`;
+var omissionText = (o) => `${o.run_id}: SDK omitted ${o.sdkOmitted ?? "unknown"}; Derivation left out ${o.omitted ?? "unknown"}${o.selfMs === null ? "" : ` · ${exactComponentMs(o.selfMs)}`}. Paging leaves recorded omissions unchanged.`;
+var READ_WORDS = {
+  componentTime: "component render time",
+  ownTime: "own time",
+  detailUnavailable: "Only render time recorded; renders, parent and library detail unavailable.",
+  parent: "Placed by",
+  slowest: MEASURES.commit_max_ms.label,
+  runA: "Run A",
+  runB: "Run B",
+  notMeasured: "Not measured",
+  onlyA: "Only in run A",
+  onlyB: "Only in run B"
+};
+var READ_USAGE = {
+  listFindings: `What got ${STATE_WORDS.worse.toLowerCase()} (${STATE_WORDS.worse} / ${STATE_WORDS.warning}) or ${STATE_WORDS.better.toLowerCase()} in the app, worst first, as KeepSnappy measured it on real phones. The answer starts with whether and when the branch was measured and how its newest run set read: an empty list on a branch that was never measured, or whose newest run set was not judged, is not a clean result. Filter by a PR branch or main, journey, phone, and state (present by default; not-judged = the newest run set did not judge it, so it may still be there). Each finding says what changed, where, how sure, and has an id for get_finding. Page with offset.`,
+  components: "  --page N | --all  (places or compare: a component page, or every stored component and place; --top-components sets the bounded page size)",
+  verbose: "  --verbose        (include source files and raw identities in text; JSON is unchanged)",
+  page: "--page must be a whole number from 1; use it only with places or compare.",
+  all: "--all is for places or compare; do not combine it with --page, --offset or --short.",
+  detailFlag: "  --detail         (places: include recorded run detail; also included by --verbose or component paging)",
+  detail: "Include recorded per-run component and window detail.",
+  compareTop: "--top-components must be a whole number from 1 to 200 for compare.",
+  top: "--top-components must be a whole number from 0 to 20, or from 1 to 200 with --page or --all.",
+  paging: "The API did not advance the component page; stopped without claiming the list is complete.",
+  componentOffset: "Skip this many stored components per place.",
+  componentLimit: "Component page size; the response gives stored totals and next offsets."
+};
+var componentListsText = (totals, shown) => `Stored component rows: ${shown.rows} of ${totals.rows} compared; ${shown.added} of ${totals.added} ${READ_WORDS.onlyB.toLowerCase()}; ${shown.removed} of ${totals.removed} ${READ_WORDS.onlyA.toLowerCase()}.`;
+var notMeasuredText = (side) => `${READ_WORDS.notMeasured} in run ${side.toUpperCase()}`;
+
+// packages/present/dist/src/words.js
+var REASON_WORDS = {
+  "no-baseline": "there are no main runs on this phone and journey yet",
+  "too-few-runs": "there are too few valid runs on a side",
+  "judged-measures-missing": "the judged measures are missing on a side",
+  "measured-differently": "the sides were measured differently",
+  "runs-unknown": "a change that would count has no value in some runs, so it cannot be confirmed in every run",
+  "facts-version-mismatch": "the sides were derived with different versions",
+  "not-judged-on-simulators": "timing is not judged on simulators",
+  "platforms-differ": "the sides ran on different platforms (iOS and Android are never compared)",
+  "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",
@@ -5501,6 +5698,13 @@ var MAIN_TIER_WORDS = {
   slight: STATE_WORDS.warning,
   worse: STATE_WORDS.worse
 };
+var MAIN_TIER_RESULT_WORDS = {
+  same: STATE_WORDS["no-change"],
+  better: STATE_WORDS.better,
+  cant: STATE_WORDS["cant-tell"],
+  slight: STATE_WORDS.warning,
+  worse: STATE_WORDS.worse
+};
 var MAIN_TIER_RANK = { worse: 0, slight: 1, cant: 2, better: 3, same: 4 };
 function mainCantWords(reason, config) {
   if (!reason)
@@ -5526,7 +5730,6 @@ function mainPlaceReasonWords(reason, config) {
   }
 }
 var MAIN_SUMMARY_PENDING = "Runs received; the summary is not computed yet.";
-var MAIN_NEWEST_SUMMARY_PENDING = `Newest: ${MAIN_SUMMARY_PENDING}`;
 var SHORT_ASPECT_WORDS = {
   ...ASPECT_WORDS,
   sdk: "SDK",
@@ -5561,8 +5764,412 @@ function mainCutWords(v) {
     const cut = listWords(v.partial_render.cut);
     parts.push(`${cut[0].toUpperCase()}${cut.slice(1)} start a new render baseline; ${listWords(v.partial_render.kept)} keep theirs.`);
   }
-  return parts.length ? parts.join(" ") : "Measures alike; no baseline cut.";
+  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) {
@@ -5601,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)
@@ -5609,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;
@@ -5642,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 = [
@@ -5654,10 +6235,16 @@ var setupLine = (h) => {
 var keyHeader = (t) => ({ "x-keepsnappy-key": t.key });
 async function createRunSet(t, body) {
   const r = await call(t.fetch ?? fetch, t.url, "/v1/run-sets", keyHeader(t), body);
-  return { run_set_id: String(r.run_set_id), dashboard_url: String(r.dashboard_url) };
+  if (typeof r.run_set_id !== "string" || !r.run_set_id)
+    throw new UploadError("POST /v1/run-sets: response has no run_set_id (is the URL the KeepSnappy API?)");
+  return { run_set_id: r.run_set_id, dashboard_url: String(r.dashboard_url ?? "") };
 }
 async function completeRunSet(t, id, verdicts) {
-  return await call(t.fetch ?? fetch, t.url, `/v1/run-sets/${encodeURIComponent(id)}/complete`, keyHeader(t), { verdicts });
+  const path = `/v1/run-sets/${encodeURIComponent(id)}/complete`;
+  const r = await call(t.fetch ?? fetch, t.url, path, keyHeader(t), { verdicts });
+  if (!r.run_set_id)
+    throw new UploadError(`POST ${path}: response has no run_set_id`);
+  return r;
 }
 async function createIngestRun(t, body) {
   const r = await call(t.fetch ?? fetch, t.url, "/v1/runs", keyHeader(t), body);
@@ -5672,26 +6259,32 @@ async function finishIngestRun(t, runId, invalidReason, farmSession) {
   });
 }
 async function getRunSetRuns(t, id) {
-  return await call(t.fetch ?? fetch, t.url, `/v1/run-sets/${encodeURIComponent(id)}/runs`, keyHeader(t), undefined, "GET");
+  const path = `/v1/run-sets/${encodeURIComponent(id)}/runs`;
+  const r = await call(t.fetch ?? fetch, t.url, path, keyHeader(t), undefined, "GET");
+  if (!Array.isArray(r.runs))
+    throw new UploadError(`GET ${path}: response has no runs`);
+  return r;
 }
 var FEW_RUNS = "Few runs — result may be noisy";
-var word = (s, server, h) => {
-  const w = server || stateWord(s ?? "inconclusive");
-  return h?.blocking === false && h.measured_differently?.length && (w === STATE_WORDS.worse || s === "worse") ? `${w} (${NOT_BLOCKING})` : w;
-};
+var word = (s, server, blocking) => badgedWord(server || stateWord(s ?? "inconclusive"), blocking);
+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 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 = [];
   const where = `${s.branch}${s.commit_sha ? ` @ ${s.commit_sha.slice(0, 7)}` : ""}`;
   const v = s.verdicts;
-  lines.push(`KeepSnappy result for ${where}: ${word(v?.state ?? null, v?.word, v?.headline)}`);
+  lines.push(`KeepSnappy result for ${where}: ${setWord(v)}`);
   if (setupLine(v?.headline))
     lines.push(`  ${setupLine(v?.headline)}`);
   if (v?.low_data)
@@ -5705,20 +6298,22 @@ function formatRunSet(s, top = 5) {
     const dev = sc.device ? `${sc.device.model}${sc.device.os ? ` (${sc.device.os})` : ""}` : "no device";
     const what = sc.role === "comparison" ? "compared with the baseline branch" : sc.role === "history" ? "latest runs compared with earlier ones" : "not judged (no branch or flow name)";
     lines.push("");
-    lines.push(`${sc.scenario ?? "(no flow name)"} on ${dev}, ${what}: ${word(sc.state, sc.word, sc.headline)}`);
+    lines.push(`${sc.scenario ?? "(no flow name)"} on ${dev}, ${what}: ${scenarioWord(sc)}`);
     if (setupLine(sc.headline) && (v?.scenarios.length ?? 0) > 1)
       lines.push(`  ${setupLine(sc.headline)}`);
     if (sc.low_data && (v?.scenarios.length ?? 0) > 1)
       lines.push(`  ${FEW_RUNS}`);
     if (sc.role !== "adhoc" && !noCounts(movedCounts(sc)))
       lines.push(`  ${countsLine(movedCounts(sc))}`);
+    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`);
@@ -5735,33 +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 rows = v.scenarios.map((sc) => {
-    const c = movedCounts(sc);
-    return `| ${sc.scenario ?? "-"} | ${sc.device ? sc.device.model : "-"} | ${word(sc.state, sc.word, sc.headline)}${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: ${word(v.state, v.word, v.headline)}`,
-    "",
-    ...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,
-    ...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
@@ -9137,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() };
   });
 }
@@ -9147,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_"))
@@ -9161,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, "");
@@ -9207,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 = [];
@@ -9307,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(`
 `)) {
@@ -9327,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(`
 `) + `
 `);
@@ -9341,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];
@@ -9375,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);
@@ -9429,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)
@@ -9468,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 };
@@ -9513,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)
@@ -9532,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) }),
@@ -9591,11 +10201,21 @@ ${outcome.summary}`);
     ...api.fetch ? { fetch: api.fetch } : {}
   }).catch(infra(`results are saved in ${out}, but the upload failed`));
   rt.print(`uploaded ${up.uploaded} runs to ${api.url}${up.skipped.length ? ` (${up.skipped.length} skipped: ${up.skipped.map((x) => `${x.run_id} ${x.why}`).join(", ")})` : ""}`);
+  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"));
+    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;
+  }
   if (!runSet)
     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 {
@@ -9607,6 +10227,9 @@ ${formatRunSet(summary)}`);
     rt.print(`--fail-on-worse: a journey is ${STATE_WORDS.worse.toLowerCase()} than its baseline and blocks (exit 3)`);
     return EXIT.worse;
   }
+  const unchecked = o["fail-on-worse"] && summary ? uncheckedGate(summary) : null;
+  if (unchecked)
+    rt.print(unchecked);
   return EXIT.ok;
 }
 async function replayFlow(config, scenario) {
@@ -9623,13 +10246,13 @@ var infra = (what) => (e) => {
     throw new Error(`${what}: ${e.message}`);
   throw e;
 };
-async function writeResult(deps, out, rt, runSet, summary, branch) {
+async function writeResult(deps, out, rt, runSet, summary, branch, blocked = false) {
   const url = summary?.dashboard_url ?? runSet.dashboard_url;
-  await deps.fs.writeFile(join9(out, "keepsnappy-result.json"), `${JSON.stringify({ run_set_id: runSet.run_set_id, dashboard_url: url, state: summary?.verdicts?.state ?? null, summary }, null, 2)}
+  await deps.fs.writeFile(join9(out, "keepsnappy-result.json"), `${JSON.stringify({ run_set_id: runSet.run_set_id, dashboard_url: url, state: blocked ? "blocked" : summary?.verdicts?.state ?? null, summary }, null, 2)}
 `);
   const step = rt.env.GITHUB_STEP_SUMMARY;
   if (step)
-    await deps.fs.appendFile(step, 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
@@ -10091,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.16";
+  const built = "0.1.0-alpha.18";
   if (built)
     return built;
   let dir = dirname2(fileURLToPath(import.meta.url));
@@ -10146,8 +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/appium-driver/dist/src/gestures.js
-var densities = new WeakMap;
+// 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";
@@ -10226,172 +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 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}: ${INFO_WORDS.heat}`;
-      const blocks = [section(`*${head}*`), ...heat, ...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}*`)];
-    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`)];
-  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 {
@@ -10409,17 +11438,23 @@ var LINKS_USAGE = `keepsnappy activation-link --scheme <app://> --token <run tok
   flush-link --scheme <app://>
   gc-link    --scheme <app://> [--n 1]`;
 function linksCommand(cmd, argv, rt) {
-  const { values: o } = parseArgs({
-    args: [...argv],
-    options: {
-      scheme: { type: "string" },
-      token: { type: "string" },
-      n: { type: "string" },
-      "no-diag": { type: "boolean" },
-      "no-profile": { type: "boolean" },
-      set: { type: "string", multiple: true }
+  const { values: o } = (() => {
+    try {
+      return parseArgs({
+        args: [...argv],
+        options: {
+          scheme: { type: "string" },
+          token: { type: "string" },
+          n: { type: "string" },
+          "no-diag": { type: "boolean" },
+          "no-profile": { type: "boolean" },
+          set: { type: "string", multiple: true }
+        }
+      });
+    } catch (e) {
+      throw new UsageError([e.message, LINKS_USAGE]);
     }
-  });
+  })();
   if (!o.scheme)
     throw new ConfigError([`--scheme is required (the app's URL scheme, e.g. myapp://)`]);
   if (cmd === "flush-link") {
@@ -10470,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()) {
@@ -10557,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");
@@ -10585,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,
@@ -10706,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;
 };
@@ -10728,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;
 }
@@ -10767,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));
@@ -10821,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) {
@@ -10842,42 +11883,23 @@ 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: nothing to report (${STATE_WORDS["no-change"].toLowerCase()})` : "Slack: skipped, the message needs --wait");
-    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)) {
     rt.print(`--fail-on-worse: a journey is ${STATE_WORDS.worse.toLowerCase()} than its baseline and blocks (exit 3)`);
     return EXIT.worse;
   }
+  const unchecked = f["fail-on-worse"] ? uncheckedGate(summary) : null;
+  if (unchecked)
+    rt.print(unchecked);
   return EXIT.ok;
 }
 
@@ -11181,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) {
@@ -11191,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")
@@ -11200,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)
@@ -11297,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");
+  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) {
@@ -11400,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(","),
@@ -11729,7 +12751,8 @@ var SHORT_FORM_NOTES = {
   main_vs_previous: `the movers after the first ${SHORT_PLACES} (every new, gone or multi-device place stays)`,
   place_trend: `the sessions older than the newest ${SHORT_SESSIONS} and the history restarts among them (unknown restarts always stay)`,
   window_history: `the runs older than the newest ${SHORT_POINTS}`,
-  pr_status: "the per-journey dashboard links and the heat note"
+  pr_status: "the per-journey dashboard links and the heat note",
+  list_problems: `the work and component lines, the dashboard links and the problems after the first ${SHORT_PLACES}`
 };
 var andList = (xs) => xs.length < 2 ? xs[0] ?? "" : `${xs.slice(0, -1).join(", ")} and ${xs[xs.length - 1]}`;
 
@@ -11748,9 +12771,20 @@ class Rows {
   full(...texts) {
     return this.add(false, ...texts);
   }
+  detail(...texts) {
+    for (const text of texts)
+      for (const line of text.split(`
+`))
+        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) {
@@ -11762,7 +12796,7 @@ class Rows {
     }
     if (kept[kept.length - 1] === "")
       kept.pop();
-    if (this.rows.some((r) => !r.short && r.text.trim() !== ""))
+    if (this.rows.some((r) => !r.short && r.notice !== false && r.text.trim() !== ""))
       kept.push(`Short form: ${andList(left.length ? left : ["other lines"])} left out; the full form shows them.`);
     return kept.join(`
 `);
@@ -11770,19 +12804,22 @@ class Rows {
 }
 var LABEL_W = 14;
 var line = (label, text) => `  ${label.padEnd(LABEL_W)}${text}`;
-var plural = (n, w) => `${n} ${w}${n === 1 ? "" : "s"}`;
+var plural2 = (n, w) => `${n} ${w}${n === 1 ? "" : "s"}`;
 var promptText = (f) => f.what_to_do.prompt ?? "No prompt: this finding is an improvement.";
 function formatFinding(f, opts = {}) {
   const r = new Rows;
   r.both(f.answer.headline, line("What changed", f.answer.what_changed), line("Where", f.answer.where), line("How sure", f.answer.how_sure));
+  if (f.lane)
+    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", ""));
-    for (const c of f.why.components) {
-      r.full(`    ${c.component}: ${c.self_ms_before ?? "–"} → ${c.self_ms_after} ms own time, renders ${c.renders_before ?? "–"} → ${c.renders_after ?? "–"}${c.cause ? `; ${c.cause}` : ""}${c.flagged ? "" : " (not certain)"}`);
+    const names = componentReadNames(f.why.components.map((c) => ({ key: c.key, name: c.component, ...c.file ? { file: c.file } : {} })));
+    for (const [i, c] of f.why.components.entries()) {
+      r.full(`    ${names[i]}${opts.verbose && c.file ? ` (${c.file})` : ""}: ${c.self_ms_before ?? "–"} → ${c.self_ms_after} ms ${c.key ? READ_WORDS.componentTime : READ_WORDS.ownTime}, renders ${c.renders_before ?? "–"} → ${c.renders_after ?? "–"}${c.cause ? `; ${c.cause}` : ""}${c.flagged ? "" : " (not certain)"}`);
     }
   }
   const memory = f.why.memory ?? [];
@@ -11797,15 +12834,15 @@ function formatFinding(f, opts = {}) {
     r.full("", promptText(f));
   return r.render(opts.form, [
     "the why, seen and layer lines",
-    ...f.why.components.length ? [plural(f.why.components.length, "component line")] : [],
-    ...memory.some((m) => m.metric !== f.what.metric) ? [plural(memory.filter((m) => m.metric !== f.what.metric).length, "memory evidence line")] : [],
+    ...f.why.components.length ? [plural2(f.why.components.length, "component line")] : [],
+    ...memory.some((m) => m.metric !== f.what.metric) ? [plural2(memory.filter((m) => m.metric !== f.what.metric).length, "memory evidence line")] : [],
     ...opts.prompt ? ["the prompt"] : []
   ]);
 }
 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" };
-function measuredLines(l, r) {
+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(" · ");
   const m = l.measured;
@@ -11813,7 +12850,7 @@ function measuredLines(l, r) {
   if (!n) {
     const on = f.branch ? f.branch === l.baseline_branch ? f.branch : `branch ${f.branch}` : "any branch";
     const narrow = [f.journey, f.phone ? `phone “${f.phone}”` : null].filter(Boolean).join(", ");
-    r.both(m.run_sets ? `${scope}: ${plural(m.run_sets, "run set")} measured, but no verdict yet: nothing is known about its performance.` : `No KeepSnappy measurement on ${on}${narrow ? ` for ${narrow}` : ""}: nothing is known about its performance.`);
+    r.both(m.run_sets ? `${scope}: ${plural2(m.run_sets, "run set")} measured, but no verdict yet: nothing is known about its performance.` : `No KeepSnappy measurement on ${on}${narrow ? ` for ${narrow}` : ""}: nothing is known about its performance.`);
     return [];
   }
   const lane = (x) => {
@@ -11821,31 +12858,40 @@ function measuredLines(l, r) {
     return `${x.commit?.sha ? `commit ${x.commit.sha.slice(0, 7)}` : "commit not recorded"} (${when(x.at)}): ${x.word}${runs}${x.waiting_for_reprocess ? `; ${waitingWords(x.waiting_for_reprocess)}` : ""}`;
   };
   if (m.lanes.length === 1) {
-    r.both(`${scope}: newest measured ${f.branch ? "" : `on ${n.branch}, `}${lane(n)}; ${plural(m.run_sets, "run set")} measured.`);
+    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 [];
   }
   const shown = m.lanes.slice(0, LANES_SHOWN);
-  const unjudged = shown.filter((x) => !x.judged);
-  r.add(unjudged.length > 0, `${scope}: ${plural(m.run_sets, "run set")} measured; the newest of each journey × phone:`);
-  for (const x of shown)
-    r.add(!x.judged, `  ${x.journey} on ${x.phone_name}${f.branch ? "" : ` (${x.branch})`}: ${lane(x)}`);
+  r.add(shown.some((x) => !x.judged || !!x.context), `${scope}: ${plural2(m.run_sets, "run set")} measured; the newest of each journey × phone:`);
+  for (const x of shown) {
+    const keep = !x.judged || !!x.context;
+    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)`);
-  return [...shown.length > unjudged.length ? [plural(shown.length - unjudged.length, "judged lane")] : [], ...m.lanes.length > shown.length ? [plural(m.lanes.length - shown.length, "lane") + " beyond the eighth"] : []];
+  const judgedLeft = shown.filter((x) => x.judged && !x.context).length;
+  return [
+    ...judgedLeft ? [plural2(judgedLeft, "judged lane")] : [],
+    ...m.lanes.length > shown.length ? [plural2(m.lanes.length - shown.length, "lane") + " beyond the eighth"] : []
+  ];
 }
 function countsLine2(l) {
   const c = l.counts;
   const parts = [
-    c.worse ? `${c.worse} ${STATE_WORDS.worse.toLowerCase()}${c.not_blocking ? ` (${c.not_blocking} not blocking)` : ""}` : "",
+    c.worse ? `${c.worse} ${STATE_WORDS.worse.toLowerCase()}${c.not_blocking ? ` (${c.not_blocking} ${NOT_BLOCKING})` : ""}` : "",
     c.warn ? `${c.warn} ${STATE_WORDS.warning.toLowerCase()}` : "",
     c.better ? `${c.better} ${STATE_WORDS.better.toLowerCase()}` : ""
   ].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 ${plural(heated, "run")} (run health, layer 3)` : "",
+    heated ? `${INFO_WORDS.heat.toLowerCase()} in ${plural2(heated, "run")} (run health, layer 3)` : "",
     state === "present" && l.states.not_judged ? `${l.states.not_judged} more not judged in the newest run set (state not-judged)` : ""
   ].filter(Boolean);
   const line = `${head}${more.length ? `; ${more.join("; ")}` : ""}.`;
@@ -11853,7 +12899,7 @@ function countsLine2(l) {
 }
 function formatFindingList(l, opts = {}) {
   const r = new Rows;
-  const lanesLeft = measuredLines(l, r);
+  const lanesLeft = measuredLines(l, r, opts);
   if (l.measured.newest || l.total)
     r.both(countsLine2(l));
   l.findings.forEach((f, i) => {
@@ -11870,11 +12916,7 @@ function formatFindingList(l, opts = {}) {
   if (l.findings.length)
     r.both("", "One finding with its evidence and a prompt: keepsnappy finding <id> --prompt");
   const notWorse = l.findings.filter((f) => !isWorseState(f.state)).length;
-  return r.render(opts.form, [
-    ...l.findings.length ? [plural(l.findings.length, "how-sure line")] : [],
-    ...notWorse ? [plural(notWorse, "place line")] : [],
-    ...lanesLeft
-  ]);
+  return r.render(opts.form, [...l.findings.length ? [plural2(l.findings.length, "how-sure line")] : [], ...notWorse ? [plural2(notWorse, "place line")] : [], ...lanesLeft]);
 }
 var STATUS_LEAD = {
   ok: "ok",
@@ -11890,9 +12932,11 @@ function formatBranchStatus(s, opts = {}) {
   if (s.lanes.length)
     r.both("");
   for (const l of s.lanes) {
-    const badge = l.result === "blocks" ? " (blocks)" : l.word === STATE_WORDS.worse ? ` (${NOT_BLOCKING})` : "";
+    const shown = l.result === "blocks" ? `${l.word} (blocks)` : badgedWord(l.word, l.blocking);
     const sha = l.commit?.sha?.slice(0, 7);
-    r.both(`  ${l.journey_title ?? l.journey} on ${l.phone_name}: ${l.word}${badge} · ${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(`  ${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)
@@ -11903,8 +12947,13 @@ function formatBranchStatus(s, opts = {}) {
   const links = s.lanes.filter((l) => l.link).length;
   const heated = s.counts.heat_runs ?? 0;
   const more = [
-    [false, heated ? `${INFO_WORDS.heat.toLowerCase()} in ${plural(heated, "run")} (information, never blocks)` : ""],
-    [true, s.not_judged_findings ? `${plural(s.not_judged_findings, "finding")} not judged in the newest run set; they may still be there: keepsnappy findings --branch ${s.branch} --state not-judged` : ""],
+    [false, heated ? `${INFO_WORDS.heat.toLowerCase()} in ${plural2(heated, "run")} (information, never blocks)` : ""],
+    [
+      true,
+      s.not_judged_findings ? `${plural2(s.not_judged_findings, "finding")} not judged in the newest run set; they may still be there: keepsnappy findings --branch ${s.branch} --state not-judged` : ""
+    ],
+    [true, statusProblemsLine(s)],
+    [true, s.problems?.unread_lanes ? `${unreadWords(s.problems.unread_lanes)} for problems: ${staleResult(s.problems.unread_lanes)}` : ""],
     [true, s.links.overview ? `Dashboard: ${s.links.overview}` : ""],
     [true, s.worst.length ? "One finding with its evidence and a prompt: keepsnappy finding <id> --prompt" : ""]
   ];
@@ -11913,10 +12962,65 @@ function formatBranchStatus(s, opts = {}) {
     r.both("");
   for (const [short, text] of shownMore)
     r.add(short, text);
-  return r.render(opts.form, [...links ? [plural(links, "dashboard link")] : [], ...heated ? ["the heat note"] : []]);
+  return r.render(opts.form, [...links ? [plural2(links, "dashboard link")] : [], ...heated ? ["the heat note"] : []]);
+}
+function statusProblemsLine(s) {
+  const p = s.problems;
+  if (!p?.count)
+    return "";
+  return `${plural2(p.places, "place")} over budget in this branch’s own runs (${p.far_count ? `${p.far_count} far over budget; ` : ""}not a regression, never blocks): list_problems, or keepsnappy problems --branch ${s.branch}`;
+}
+var unreadWords = (n) => `${n} journey × phone not read`;
+var staleResult = (n) => `${n === 1 ? "its stored result is" : "their stored results are"} not current`;
+function formatProblemList(l, opts = {}) {
+  const r = new Rows;
+  const b = l.filters.branch;
+  const c = l.counts;
+  const unread = c.unread_lanes ?? 0;
+  const read = l.lanes.length - unread;
+  if (!l.measured.run_sets) {
+    r.both(`No KeepSnappy measurement on ${b === l.baseline_branch ? b : `branch ${b}`}: nothing is known about its problems.`);
+    return r.render(opts.form);
+  }
+  if (!l.lanes.length) {
+    r.both(`${b}: ${plural2(l.measured.run_sets, "run set")} measured, but no judgement yet to read problems from.`);
+    return r.render(opts.form);
+  }
+  if (c.count)
+    r.both(`${b}: ${plural2(c.places, "place")} over budget in ${b === l.baseline_branch ? "main’s" : "this branch’s"} own runs${c.far_count ? ` (${c.far_count} far over budget)` : ""}`);
+  else if (read)
+    r.both(`${b}: no problem over budget in the newest run set (${read} journey × phone read)`);
+  else
+    r.both(`${b}: no problem could be read: ${unread} journey × phone has a stored result that is not current, so nothing is known about its problems.`);
+  r.both(l.note);
+  if (read && unread)
+    r.both(`${unreadWords(unread)}: ${staleResult(unread)}, so nothing is known about ${unread === 1 ? "its" : "their"} problems.`);
+  l.problems.forEach((p, i) => {
+    const keep = i < SHORT_PLACES;
+    r.add(keep, "", `${l.offset + i + 1}. ${p.text}: ${p.place_name}${opts.verbose ? ` (${p.place})` : ""}${p.intermittent ? ` — ${p.note}, not counted` : ""}`);
+    r.add(keep, `   ${p.journey_title ?? p.journey} on ${p.phone_name}, ${p.runs_text}${p.tag_word ? `, ${p.tag_word}` : ""}`);
+    const top = p.top_components[0];
+    const topName = componentReadNames(p.top_components)[0];
+    const detail = [p.work, top ? `heaviest ${topName}${opts.verbose && top.key ? ` (${top.key})` : ""} ${top.self_text}` : null, p.new_component ? NEW_IN_PR_CHIP : null, p.range_text ? `${p.range_text} between runs` : null].filter(Boolean);
+    if (detail.length)
+      r.full(`   ${detail.join("; ")}`);
+    if (p.url)
+      r.full(`   ${p.url}`);
+  });
+  const shown = l.problems.length ? `Showing ${l.offset + 1}–${l.offset + l.problems.length} of ${l.total}` : "";
+  if (l.next_offset !== null)
+    r.both("", `${shown || `Showing none of ${l.total}`}; the rest from offset ${l.next_offset} (--offset ${l.next_offset}).`);
+  else if (l.offset > 0)
+    r.both("", shown ? `${shown}.` : `Offset ${l.offset} is past the last of ${l.total}.`);
+  const detailLines = l.problems.some((p) => p.work || p.top_components.length || p.new_component || p.range_text);
+  return r.render(opts.form, [
+    ...detailLines ? ["the work and component lines"] : [],
+    ...l.problems.some((p) => p.url) ? ["the dashboard links"] : [],
+    ...l.problems.length > SHORT_PLACES ? [`${plural2(l.problems.length - SHORT_PLACES, "problem")} beyond the fifth`] : []
+  ]);
 }
 var commitText = (c) => !c ? "commit not recorded" : c.title ? `“${c.title}”${c.author ? ` by ${c.author}` : ""}${c.sha ? ` (${c.sha.slice(0, 7)})` : ""}` : c.sha ? c.sha.slice(0, 7) : "commit not recorded";
-function formatCompare(r) {
+function formatCompare(r, opts = {}) {
   const out = [
     `Run A: ${r.a.external_id} on ${r.a.branch ?? "?"}, ${commitText(r.a.commit ? { sha: r.a.commit_sha, ...r.a.commit } : { sha: r.a.commit_sha, title: null, author: null })}`,
     `Run B: ${r.b.external_id} on ${r.b.branch ?? "?"}, ${commitText(r.b.commit ? { sha: r.b.commit_sha, ...r.b.commit } : { sha: r.b.commit_sha, title: null, author: null })}`,
@@ -11926,9 +13030,42 @@ function formatCompare(r) {
     out.push(`Measured differently: ${r.setup_differs.map((d) => `${d.field} ${JSON.stringify(d.a)} → ${JSON.stringify(d.b)}`).join(", ")}`);
   for (const w of r.windows) {
     const ms = w.metrics.filter((m) => m.a !== null || m.b !== null);
-    if (!ms.length)
+    const c = w.component_page ?? w.components;
+    if (!ms.length && !c)
       continue;
-    out.push("", w.window_name);
+    out.push("", `${w.window_name}${opts.verbose ? ` (${w.window})` : ""}`);
+    const singles = [...c?.added ?? [], ...c?.removed ?? [], ...w.component_page?.uncompared?.a ?? [], ...w.component_page?.uncompared?.b ?? []];
+    const components = [...c?.rows ?? [], ...singles];
+    const names = componentReadNames(components.map((row) => ({ key: row.key, name: row.component })));
+    const shown = new Map(components.map((row, i) => [row.key, names[i]]));
+    for (const row of c?.rows ?? [])
+      out.push(`  ${shown.get(row.key)}: ${row.self_ms_a === null ? "–" : exactComponentMs(row.self_ms_a)} → ${row.self_ms_b === null ? "–" : exactComponentMs(row.self_ms_b)}${opts.verbose ? ` (${row.key})` : ""}`);
+    for (const [label, rows] of [
+      [READ_WORDS.onlyB, c?.added ?? []],
+      [READ_WORDS.onlyA, c?.removed ?? []]
+    ]) {
+      for (const row of rows)
+        out.push(`  ${shown.get(row.key)}: ${label}; ${row.self_ms === null ? "–" : exactComponentMs(row.self_ms)}${opts.verbose ? ` (${row.key})` : ""}`);
+    }
+    const page = w.component_page;
+    if (page) {
+      for (const side of ["a", "b"]) {
+        if (!page.measured[side])
+          out.push(`  ${notMeasuredText(side)}`);
+        for (const row of page.uncompared?.[side] ?? [])
+          out.push(`  ${shown.get(row.key)}: ${side === "a" ? READ_WORDS.runA : READ_WORDS.runB} ${row.self_ms === null ? "–" : exactComponentMs(row.self_ms)}${opts.verbose ? ` (${row.key})` : ""}`);
+      }
+      out.push(`  ${componentPageText(page.page, components.length)}`);
+    } else if (c?.totals)
+      out.push(`  ${componentListsText(c.totals, { rows: c.rows.length, added: c.added?.length ?? 0, removed: c.removed?.length ?? 0 })}`);
+    if (c?.omissions)
+      for (const side of ["a", "b"]) {
+        if (page && !page.measured[side])
+          continue;
+        const o = c.omissions[side];
+        if (o.sdkOmitted === null || o.omitted === null || o.sdkOmitted > 0 || o.omitted > 0)
+          out.push(`  ${omissionText({ run_id: side === "a" ? READ_WORDS.runA : READ_WORDS.runB, ...o })}`);
+      }
     for (const m of ms)
       out.push(`  ${m.label.padEnd(28)}${m.a_text.padStart(10)} → ${m.b_text}`);
   }
@@ -11937,22 +13074,35 @@ function formatCompare(r) {
 }
 function formatHistory(h, opts = {}) {
   const r = new Rows;
-  r.both(`${h.window_name} in ${h.journey_title ?? h.journey} on ${h.branch}: ${h.points.length ? `${plural(h.points.length, "run")}, oldest first` : h.note ?? "no runs"}`);
+  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 ? [plural(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 [
-    `${plural(c.commits.length, "measured commit")} (${plural(c.sessions, "session")}) on ${c.branch}, oldest first:`,
+    `${plural2(c.commits.length, "measured commit")} (${plural2(c.sessions, "session")}) on ${c.branch}, oldest first:`,
     ...c.commits.map((x) => `  ${when(x.first_measured_at)}  ${commitText(x)}${x.pull_request?.number ? `, PR #${x.pull_request.number}` : ""}${x.sessions > 1 ? `; ${x.sessions} sessions, the last ${when(x.last_measured_at)}` : ""}`),
     c.note
   ].join(`
@@ -11994,8 +13144,39 @@ function formatSessionPlaces(p, opts = {}) {
   p.places.forEach((place, i) => {
     const m = place.measures.find((x) => x.measure === by);
     const value = m ? `${fieldValueText(by, m.median)} (p90 ${fieldValueText(by, m.p90)}, n ${m.n})` : `no ${by}`;
-    const comps = place.components.map((c) => `${c.name} ${valueText("self_ms", c.self_ms.median)} (p90 ${valueText("self_ms", c.self_ms.p90)}${c.renders_median !== null ? `, ${plural(c.renders_median, "render")}` : ""})`);
-    r.both(`${p.offset + i + 1}. ${place.window_name}: ${value}`);
+    const names = componentReadNames(place.components);
+    const comps = place.components.map((c, i) => `${names[i]}${opts.verbose && c.file ? ` (${c.file})` : ""} ${valueText("self_ms", c.self_ms.median)} (p90 ${valueText("self_ms", c.self_ms.p90)}${c.renders_median !== null ? `, ${plural2(c.renders_median, "render")}` : ""})`);
+    r.both(`${p.offset + i + 1}. ${place.window_name}${opts.verbose ? ` (${place.window})` : ""}: ${value}`);
+    if (place.components_page)
+      r.detail(`   ${componentPageText(place.components_page, place.components.length)}`);
+    for (const o of (place.omissions ?? []).filter((o) => o.sdkOmitted === null || o.omitted === null || o.sdkOmitted > 0 || o.omitted > 0))
+      r.detail(`   ${omissionText(o)}`);
+    const slowest = place.measures.find((m) => m.measure === "commit_max_ms");
+    if (by !== "commit_max_ms" && slowest)
+      r.detail(`   ${READ_WORDS.slowest}: ${fieldValueText("commit_max_ms", slowest.median)}`);
+    for (const detail of place.details ?? []) {
+      if (detail.slowestCommit)
+        r.detail(`   ${detail.run_id}: ${READ_WORDS.slowest}: ${exactComponentMs(detail.slowestCommit.ms)}`);
+      r.detail(`   ${detail.run_id}: ${OUTSIDE_APP_NAME}: ${detail.outside ? exactComponentMs(detail.outside.selfMs) : "–"}; ${OTHER_RENDER_WORK_NAME}: ${detail.remainderMs === null ? "–" : exactComponentMs(detail.remainderMs)}`);
+      for (const l of detail.outside?.rolledUp ?? [])
+        r.detail(`     ${libraryLineText(l)}`);
+      if (detail.outside?.rolledUpRest)
+        r.detail(`     ${rolledUpRestText(detail.outside.rolledUpRest)}`);
+    }
+    for (const [ci, c] of place.components.entries()) {
+      if (c.detail === "ms-only" && !c.runs?.length)
+        r.detail(`   ${names[ci]}: ${READ_WORDS.detailUnavailable}`);
+      for (const d of c.runs ?? [])
+        if (d.detail === "ms-only")
+          r.detail(`   ${names[ci]} · ${d.run_id}: ${d.selfMs === null ? "–" : exactComponentMs(d.selfMs)}; ${READ_WORDS.detailUnavailable}`);
+      for (const d of c.runs ?? [])
+        if (d.detail === "full") {
+          if (d.parent)
+            r.detail(`   ${names[ci]} · ${d.run_id}: ${READ_WORDS.parent} ${componentReadName({ key: d.parent, name: d.parent })}`);
+          if (d.rolledUpMs !== undefined && d.selfMs !== null)
+            r.detail(`   ${names[ci]} · ${d.run_id}: ${rolledUpText(d.rolledUpMs, d.selfMs)}`, ...(d.rolledUp ?? []).map((l) => `     ${libraryLineText(l)}`), ...d.rolledUpRest ? [`     ${rolledUpRestText(d.rolledUpRest)}`] : []);
+        }
+    }
     if (comps.length) {
       r.full(`   Components: ${list(comps)}`);
       componentLines++;
@@ -12005,7 +13186,7 @@ function formatSessionPlaces(p, opts = {}) {
     r.both(p.total ? `Offset ${p.offset} is past the last of ${p.total} places.` : "No place with stored statistics in this session matches.");
   else if (p.next_offset !== null)
     r.both("", `Showing ${p.offset + 1}–${p.offset + p.places.length} of ${p.total}; the rest from offset ${p.next_offset} (--offset ${p.next_offset}).`);
-  return r.render(opts.form, componentLines ? [plural(componentLines, "component line")] : []);
+  return r.render(opts.form, componentLines ? [plural2(componentLines, "component line")] : []);
 }
 function formatLayers(l) {
   return [
@@ -12027,7 +13208,7 @@ function formatMainSessions(h, opts = {}) {
   let otherChanges = 0;
   for (const s of h.sessions) {
     const k = recent.has(s);
-    r.add(k, `${when(s.at)}  ${s.run_set_id}  ${commitText(s.commit ? { ...s.commit, author: null } : null)} (${plural(s.runs, "run")})`);
+    r.add(k, `${when(s.at)}  ${s.run_set_id}  ${commitText(s.commit ? { ...s.commit, author: null } : null)} (${plural2(s.runs, "run")})`);
     if (!s.places)
       r.add(k, `  ${MAIN_SUMMARY_PENDING}${s.summary_reason ? ` (${s.summary_reason})` : ""}`);
     else
@@ -12037,15 +13218,35 @@ 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: ${c.place} ${c.ref}, ${c.before_median ?? "–"} → ${c.after_median ?? "–"}`);
+      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)
         otherChanges++;
     }
   }
   const older = h.sessions.length - recent.size;
-  return r.render(opts.form, [...older ? [plural(older, "older session")] : [], ...otherChanges ? [plural(otherChanges, "main change") + " of the other recent sessions"] : []]);
+  return r.render(opts.form, [
+    ...older ? [plural2(older, "older session")] : [],
+    ...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;
@@ -12054,29 +13255,45 @@ 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", `  ${x.place} ${x.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 ? [plural(inNorm, "place") + " in norm"] : []);
+  return r.render(opts.form, inNorm ? [plural2(inNorm, "place") + " in norm"] : []);
 }
 var signed = (n) => `${n > 0 ? "+" : ""}${Number(n.toFixed(3))}`;
-var previousLine = (p) => `  ${p.place} ${p.ref}${p.devices ? ` [devices ${p.devices.before.join(", ") || "–"} → ${p.devices.after.join(", ") || "–"}]` : ""}: ${p.status === "compared" ? "" : `${p.status}; `}${p.before ?? "–"} → ${p.after ?? "–"}; delta ${p.delta === null ? "–" : signed(p.delta)}; ${p.percent_change === null ? "change undefined" : `${signed(p.percent_change)}%`}; n ${p.n.before ?? "–"} → ${p.n.after ?? "–"}`;
+var previousLine = (p, verbose = false, peers = []) => `  ${windowQualified(p.place)}${verbose ? ` (${p.place}; ${p.ref})` : ""} ${storedRefWords(p.ref, peers)}${p.devices ? ` [devices ${p.devices.before.join(", ") || "–"} → ${p.devices.after.join(", ") || "–"}]` : ""}: ${p.status === "compared" ? "" : `${p.status === "gone" ? p.ref.startsWith("b:component:") ? JOURNEY_ROW_WORDS.removed : JOURNEY_ROW_WORDS.notInRun : p.status === "new" ? JOURNEY_ROW_WORDS.new : p.status}; `}${p.before ?? "–"} → ${p.after ?? "–"}; delta ${p.delta === null ? "–" : signed(p.delta)}; ${p.percent_change === null ? "change undefined" : `${signed(p.percent_change)}%`}; n ${p.n.before ?? "–"} → ${p.n.after ?? "–"}`;
 function formatMainVsPrevious(m, opts = {}) {
   const r = new Rows().both(`Information only: main session ${m.run_set_id} vs ${m.previous_run_set_id ?? "no previous session"}.`, `Measure: ${m.measure}; ${m.status}.`);
   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)
     r.both(`stale: ${m.stale.join(", ")}`);
   if (m.journey)
-    r.both("Whole journey:", previousLine(m.journey));
-  m.places.forEach((p, i) => r.add(i < SHORT_PLACES || p.status !== "compared", previousLine(p)));
+    r.both("Whole journey:", previousLine(m.journey, opts.verbose));
+  m.places.forEach((p, i) => r.add(i < SHORT_PLACES || p.status !== "compared", previousLine(p, opts.verbose, m.places.filter((row) => row.place === p.place).map((row) => row.ref))));
   if (m.next_offset !== null)
     r.both(`Showing ${m.offset + 1}–${m.offset + m.places.length} of ${m.total}; next offset ${m.next_offset}.`);
   const smaller = m.places.filter((p, i) => i >= SHORT_PLACES && p.status === "compared").length;
-  return r.render(opts.form, smaller ? [plural(smaller, "smaller mover")] : []);
+  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`);
@@ -12089,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++;
     }
@@ -12099,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"} · ${place.window} · ${place.label} (${place.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)
@@ -12108,7 +13327,10 @@ function formatPlaceTrend(t, opts = {}) {
     r.both(`Not computed: ${t.not_computed.join(", ")}`);
   if (t.stale.length)
     r.both(`Stale: ${t.stale.join(", ")}`);
-  return r.render(opts.form, [...olderSessions.size ? [plural(olderSessions.size, "older session")] : [], ...olderRestarts ? [plural(olderRestarts, "older restart marker")] : []]);
+  return r.render(opts.form, [
+    ...olderSessions.size ? [plural2(olderSessions.size, "older session")] : [],
+    ...olderRestarts ? [plural2(olderRestarts, "older restart marker")] : []
+  ]);
 }
 
 // packages/mcp/dist/src/client.js
@@ -12133,7 +13355,13 @@ async function get(t, path, query = {}) {
   }
   const r = await (t.fetch ?? fetch)(u, { headers: { "x-keepsnappy-key": t.key, accept: "application/json" } });
   const text = await r.text();
-  const body = text ? JSON.parse(text) : {};
+  let body;
+  try {
+    body = text ? JSON.parse(text) : {};
+  } catch {
+    const page = text.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim().slice(0, 120);
+    throw new ApiError(r.status, "not_json", `the API answered ${r.status} with a body that is not JSON${page ? `: ${page}` : ""}`);
+  }
   if (!r.ok) {
     const code = typeof body.error === "string" ? body.error : String(r.status);
     const message = typeof body.message === "string" ? body.message : code;
@@ -12144,8 +13372,9 @@ async function get(t, path, query = {}) {
 }
 var listFindings = (t, f = {}) => get(t, "v1/findings", { branch: f.branch, main: f.main ? "true" : undefined, journey: f.journey, phone: f.phone, state: f.state, limit: f.limit, offset: f.offset || undefined });
 var branchStatus = (t, branch) => get(t, "v1/branches/status", { branch });
+var listProblems = (t, f = {}) => get(t, "v1/problems", { branch: f.branch, main: f.main ? "true" : undefined, journey: f.journey, phone: f.phone, limit: f.limit, offset: f.offset || undefined });
 var getFinding = (t, id) => get(t, `v1/findings/${encodeURIComponent(id)}`);
-var compareRuns = (t, a, b) => get(t, "v1/compare", { a, b });
+var compareRuns = (t, a, b, page = {}) => get(t, "v1/compare", { a, b, ...page });
 var windowHistory = (t, q) => get(t, "v1/history", q);
 var commitsBetween = (t, q) => get(t, "v1/commits", q);
 var layers = (t) => get(t, "v1/layers");
@@ -12159,10 +13388,14 @@ var sessionPlaces = (t, f) => get(t, "v1/sessions/places", {
   window: f.window,
   limit: f.limit,
   offset: f.offset || undefined,
-  top_components: f.top_components
+  top_components: f.top_components,
+  detail: f.detail,
+  component_offset: f.component_offset,
+  component_limit: f.component_limit
 });
 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;
@@ -12173,6 +13406,8 @@ var placeTrend = (t, q) => get(t, "v1/places/trend", { ...q });
 // apps/agent/src/findings.ts
 var FINDINGS_USAGE = `keepsnappy findings [--branch NAME | --main] [--journey KEY] [--phone MODEL] [--state present|not-judged|resolved|all] [--limit N] [--offset N] [--short] [--json]
   status   --branch NAME [--short] [--json]                        (is my PR ok? one answer: blocked / nothing blocks / ok, per journey × phone the word, the ids of the worst findings, dashboard links; never measured and not judged are not ok)
+  problems --branch NAME | --main [--journey KEY] [--phone MODEL] [--limit N] [--offset N] [--short] [--json]
+           (the single problems "Over budget" / "Far over budget" in the branch's own runs, whatever main does: not a regression, never blocking)
   finding  <id> [--prompt] [--short] [--json]                      (--prompt: only the hand-off for a coding agent; with --json the whole finding)
   compare  <runA> <runB> [--json]                                  (run ids or external ids; one run against one, no statistics)
   history  <journey> <window> [--phone MODEL] [--short] [--json]   (exact window id, e.g. "press:live.chat.send")
@@ -12180,23 +13415,18 @@ 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)
-  --short  (findings, status, finding, history, places, main, trend: what decides, without the evidence detail; the same as the MCP tools' form short; --json is unchanged)
+${READ_USAGE.components}
+${READ_USAGE.verbose}
+${READ_USAGE.detailFlag}
+  --short  (findings, status, problems, finding, history, places, main, trend: what decides, without the evidence detail; the same as the MCP tools' form short; --json is unchanged)
   (key: KEEPSNAPPY_KEY or --key-env NAME; API: --api URL or KEEPSNAPPY_API)`;
-
-class UsageError extends ConfigError {
-  constructor(lines) {
-    super(lines);
-    this.message = lines.join(`
-`);
-    this.name = "UsageError";
-  }
-}
 var STATES = ["present", "not-judged", "resolved", "all"];
-var SHORT_COMMANDS = new Set(["findings", "status", "finding", "history", "places", "main", "trend"]);
-var FINDINGS_COMMANDS = new Set(["findings", "status", "finding", "compare", "history", "commits", "places", "layers", "main", "trend"]);
+var SHORT_COMMANDS = new Set(["findings", "status", "problems", "finding", "history", "places", "main", "trend"]);
+var FINDINGS_COMMANDS = new Set(["findings", "status", "problems", "finding", "compare", "history", "commits", "places", "layers", "main", "trend"]);
 async function findingsCommand(cmd, argv, rt) {
   const args = (() => {
     try {
@@ -12204,6 +13434,10 @@ async function findingsCommand(cmd, argv, rt) {
         args: argv,
         allowPositionals: true,
         options: {
+          verbose: { type: "boolean" },
+          detail: { type: "boolean" },
+          page: { type: "string" },
+          all: { type: "boolean" },
           branch: { type: "string" },
           main: { type: "boolean" },
           journey: { type: "string" },
@@ -12211,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" },
@@ -12237,7 +13472,7 @@ async function findingsCommand(cmd, argv, rt) {
   if (!key)
     throw new ConfigError([`a project key with read scope is needed: set the environment variable ${keyEnv}`]);
   const t = { url: o.api ?? envValue(rt.env, "API") ?? DEFAULT_API_URL, key, ...rt.fetch ? { fetch: rt.fetch } : {} };
-  const answerForm = { form: o.short ? "short" : "full" };
+  const answerForm = { form: o.short ? "short" : "full", verbose: o.verbose };
   const out = (v, text) => {
     rt.print(o.json ? JSON.stringify(v, null, 2) : text(v, answerForm));
     return 0;
@@ -12254,6 +13489,11 @@ async function findingsCommand(cmd, argv, rt) {
   const offset = o.offset === undefined ? undefined : Number(o.offset);
   if (offset !== undefined && (!Number.isInteger(offset) || offset < 0))
     throw new UsageError(["--offset must be a whole number >= 0"]);
+  const page = o.page === undefined ? undefined : Number(o.page);
+  if (page !== undefined && (!["places", "compare"].includes(cmd) || !Number.isInteger(page) || page < 1))
+    throw new UsageError([READ_USAGE.page]);
+  if (o.all && (!["places", "compare"].includes(cmd) || page !== undefined || o.offset !== undefined || o.short))
+    throw new UsageError([READ_USAGE.all]);
   switch (cmd) {
     case "main": {
       if (!o.journey)
@@ -12266,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)
@@ -12292,6 +13537,19 @@ async function findingsCommand(cmd, argv, rt) {
       if (!o.branch)
         throw new UsageError(["keepsnappy status needs --branch NAME", FINDINGS_USAGE]);
       return out(await branchStatus(t, o.branch), formatBranchStatus);
+    case "problems":
+      if (!o.branch && !o.main)
+        throw new UsageError(["keepsnappy problems needs --branch NAME or --main", FINDINGS_USAGE]);
+      if (o.branch && o.main)
+        throw new UsageError(["give --branch or --main, not both"]);
+      return out(await listProblems(t, {
+        ...o.branch ? { branch: o.branch } : {},
+        ...o.main ? { main: true } : {},
+        ...o.journey ? { journey: o.journey } : {},
+        ...o.phone ? { phone: o.phone } : {},
+        ...limit ? { limit } : {},
+        ...offset ? { offset } : {}
+      }), formatProblemList);
     case "finding": {
       need(1, "<id>");
       const f = await getFinding(t, p[0]);
@@ -12301,9 +13559,15 @@ async function findingsCommand(cmd, argv, rt) {
       }
       return out(f, formatFinding);
     }
-    case "compare":
+    case "compare": {
       need(2, "<runA> <runB>");
-      return out(await compareRuns(t, p[0], p[1]), formatCompare);
+      const size = o["top-components"] === undefined ? 12 : Number(o["top-components"]);
+      if (!Number.isInteger(size) || size < 1 || size > 200)
+        throw new UsageError([READ_USAGE.compareTop]);
+      const query = page || o.all || o["top-components"] !== undefined ? { component_offset: ((page ?? 1) - 1) * size, component_limit: size } : {};
+      const compared = await compareRuns(t, p[0], p[1], query);
+      return out(o.all ? await allCompare(t, compared, size) : compared, formatCompare);
+    }
     case "history":
       need(2, "<journey> <window>");
       return out(await windowHistory(t, { journey: p[0], window: p.slice(1).join(" "), ...o.phone ? { phone: o.phone } : {}, ...limit ? { limit } : {} }), formatHistory);
@@ -12315,9 +13579,12 @@ async function findingsCommand(cmd, argv, rt) {
       if (sort && !SESSION_SORTS.includes(sort))
         throw new UsageError([`--sort is ${SESSION_SORTS.join(", ")}`]);
       const top = o["top-components"] === undefined ? undefined : Number(o["top-components"]);
-      if (top !== undefined && (!Number.isInteger(top) || top < 0 || top > 20))
-        throw new UsageError(["--top-components must be a whole number from 0 to 20"]);
-      return out(await sessionPlaces(t, {
+      if (top !== undefined && (!Number.isInteger(top) || top < (page || o.all ? 1 : 0) || top > (page || o.all ? 200 : 20)))
+        throw new UsageError([READ_USAGE.top]);
+      if ((o.window?.length ?? 0) > 1)
+        throw new UsageError(["keepsnappy places takes one --window (more windows: keepsnappy trend)", FINDINGS_USAGE]);
+      const query = {
+        ...o.verbose || o.detail ? { detail: true } : {},
         ...o["run-set"] ? { run_set: o["run-set"] } : {},
         ...o.journey ? { journey: o.journey } : {},
         ...o.phone ? { phone: o.phone } : {},
@@ -12327,8 +13594,9 @@ async function findingsCommand(cmd, argv, rt) {
         ...o.window?.length ? { window: o.window[0] } : {},
         ...limit ? { limit } : {},
         ...offset ? { offset } : {},
-        ...top !== undefined ? { top_components: top } : {}
-      }), formatSessionPlaces);
+        ...page || o.all ? { component_offset: ((page ?? 1) - 1) * (top ?? 5), component_limit: top ?? 5 } : top !== undefined ? { top_components: top } : {}
+      };
+      return out(o.all ? await allSessionPlaces(t, query) : await sessionPlaces(t, query), formatSessionPlaces);
     }
     case "layers":
       return out(await layers(t), formatLayers);
@@ -12347,6 +13615,100 @@ async function findingsCommand(cmd, argv, rt) {
       throw new UsageError([FINDINGS_USAGE]);
   }
 }
+async function allSessionPlaces(target, query) {
+  let first = await sessionPlaces(target, query);
+  if (first.places.some((p) => !p.components_page))
+    throw new UsageError([READ_USAGE.paging]);
+  if (first.session.not_computed || first.session.stale)
+    return first;
+  const result = { ...first, places: [], offset: 0, next_offset: null };
+  const pinned = { ...query, run_set: first.session.run_set_id, branch: undefined };
+  const visited = new Set;
+  for (;; ) {
+    const places = first.places.map((p) => ({ ...p, components: [...p.components] }));
+    let response = first;
+    for (;; ) {
+      const next = response.places.flatMap((p) => p.components_page?.next_offset ?? []);
+      if (!next.length)
+        break;
+      const component_offset = Math.min(...next);
+      const mark = `${first.offset}:${component_offset}`;
+      if (visited.has(mark))
+        throw new UsageError([READ_USAGE.paging]);
+      visited.add(mark);
+      response = await sessionPlaces(target, { ...pinned, offset: first.offset, component_offset });
+      for (const p of places) {
+        const more = response.places.find((x) => x.window === p.window);
+        if (!more?.components_page)
+          throw new UsageError([READ_USAGE.paging]);
+        const keys = new Set(p.components.map((c) => c.key));
+        p.components.push(...more.components.filter((c) => !keys.has(c.key)));
+        p.components_page = more.components_page;
+      }
+    }
+    result.places.push(...places.map((p) => ({ ...p, ...p.components_page ? { components_page: { ...p.components_page, offset: 0, limit: p.components.length, next_offset: null } } : {} })));
+    if (places.some((p) => p.components_page && p.components.length !== p.components_page.total))
+      throw new UsageError([READ_USAGE.paging]);
+    if (first.next_offset === null) {
+      if (result.places.length !== result.total)
+        throw new UsageError([READ_USAGE.paging]);
+      return result;
+    }
+    const mark = `places:${first.next_offset}`;
+    if (visited.has(mark))
+      throw new UsageError([READ_USAGE.paging]);
+    visited.add(mark);
+    first = await sessionPlaces(target, { ...pinned, offset: first.next_offset, component_offset: 0 });
+  }
+}
+async function allCompare(target, result, size) {
+  let response = result;
+  const visited = new Set;
+  for (;; ) {
+    if (response.windows.some((w) => w.components && !w.component_page))
+      throw new UsageError([READ_USAGE.paging]);
+    const offsets = response.windows.flatMap((w) => w.component_page?.page.next_offset ?? []);
+    if (!offsets.length)
+      break;
+    const offset = Math.min(...offsets);
+    if (visited.has(offset))
+      throw new UsageError([READ_USAGE.paging]);
+    visited.add(offset);
+    response = await compareRuns(target, result.a.id, result.b.id, { component_offset: offset, component_limit: size });
+    for (const w of result.windows) {
+      const c = w.component_page;
+      if (!c && !w.components)
+        continue;
+      const more = response.windows.find((x) => x.window === w.window)?.component_page;
+      if (!c || !more)
+        throw new UsageError([READ_USAGE.paging]);
+      const keys = new Set(c.rows.map((row) => row.key));
+      c.rows.push(...more.rows.filter((row) => !keys.has(row.key)));
+      for (const field of ["added", "removed"]) {
+        const existing = c[field] ?? [];
+        const known = new Set(existing.map((row) => row.key));
+        c[field] = [...existing, ...(more[field] ?? []).filter((row) => !known.has(row.key))];
+      }
+      for (const side of ["a", "b"]) {
+        if (!c.uncompared || !more.uncompared)
+          continue;
+        const known = new Set(c.uncompared[side].map((row) => row.key));
+        c.uncompared[side].push(...more.uncompared[side].filter((row) => !known.has(row.key)));
+      }
+      c.page = more.page;
+    }
+  }
+  for (const w of result.windows) {
+    const c = w.component_page;
+    if (!c)
+      continue;
+    const count = c.rows.length + (c.added?.length ?? 0) + (c.removed?.length ?? 0) + (c.uncompared?.a.length ?? 0) + (c.uncompared?.b.length ?? 0);
+    if (count !== c.page.total)
+      throw new UsageError([READ_USAGE.paging]);
+    c.page = { ...c.page, offset: 0, limit: count, next_offset: null };
+  }
+  return result;
+}
 
 // apps/agent/src/cli.ts
 var USAGE = `keepsnappy <command>
@@ -12354,6 +13716,8 @@ var USAGE = `keepsnappy <command>
           [--upload [--wait] [--fail-on-worse] [--ingest-url URL] [--commit SHA] [--branch NAME] [--base-commit SHA]]
           [--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: "${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]
@@ -12366,6 +13730,7 @@ var USAGE = `keepsnappy <command>
              [--driver appium --journey-module FILE] [--driver-version V] [--app-build-id ID] [--harness-version V] [--journey-version V] [--flag-set LABEL]   (setup fingerprint, plan 51)
              [--sdk-args k=v&...]   (over the run defaults profile=1 diag=1; tokens.js carries them to the flows' activation link)
   farm close --state <file> [--wait [--fail-on-worse]] [--bs-build browserstack.ios.json] [--settle-seconds 60] [--max-wait-seconds 300] [--out DIR]
+             (--fail-on-worse as for run: with no verdict computed on the run set it checks nothing)
   farm run   --app <eas:ID|file.ipa|file.apk|bs://ID|custom_id:ID> --journeys a,b [--repeat 5] --device "iPhone 15 Pro-17" [--platform ios|android] [--driver maestro|appium]
              [--tunnel-for localhost:PORT ...] [--env KEY=VALUE ...] (values may use {tunnel:PORT} {run_id} {out} {tokens_js} {run_set_id})
              maestro: --suite-dir DIR --execute FLOW [--tokens-path flows/keepsnappy/tokens.js] [--maestro-version V]
@@ -12382,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`]);
@@ -12408,74 +13773,80 @@ async function main2(argv) {
   if (cmd && LINK_COMMANDS.has(cmd))
     return linksCommand(cmd, rest, { print: console.log });
   const deps = nodeDeps();
-  const { values: o, positionals } = parseArgs4({
-    args: rest,
-    allowPositionals: true,
-    options: {
-      repeat: { type: "string" },
-      arms: { type: "string" },
-      "arm-env": { type: "string", multiple: true },
-      platform: { type: "string" },
-      device: { type: "string" },
-      out: { type: "string" },
-      "bundle-id": { type: "string" },
-      timeout: { type: "string" },
-      reps: { type: "string" },
-      boot: { type: "string" },
-      "ri-capture": { type: "string" },
-      "mem-window": { type: "string" },
-      "clock-offset-ms": { type: "string" },
-      "no-markers": { type: "boolean" },
-      config: { type: "string" },
-      upload: { type: "boolean" },
-      "ingest-url": { type: "string" },
-      commit: { type: "string" },
-      branch: { type: "string" },
-      "base-commit": { type: "string" },
-      wait: { type: "boolean" },
-      "fail-on-worse": { type: "boolean" },
-      scenario: { type: "string" },
-      "device-model": { type: "string" },
-      "device-os": { type: "string" },
-      "device-id": { type: "string" },
-      replay: { type: "string", multiple: true },
-      api: { type: "string" },
-      "key-env": { type: "string" },
-      "device-provider": { type: "string" },
-      journeys: { type: "string" },
-      "tokens-js": { type: "string" },
-      state: { type: "string" },
-      "ttl-seconds": { type: "string" },
-      "bs-build": { type: "string" },
-      "settle-seconds": { type: "string" },
-      "max-wait-seconds": { type: "string" },
-      flows: { type: "string" },
-      "completion-marker": { type: "boolean" },
-      "driver-version": { type: "string" },
-      "app-build-id": { type: "string" },
-      "harness-version": { type: "string" },
-      "journey-version": { type: "string" },
-      "flag-set": { type: "string" },
-      app: { type: "string" },
-      driver: { type: "string" },
-      "tunnel-for": { type: "string", multiple: true },
-      env: { type: "string", multiple: true },
-      "driver-script": { type: "string" },
-      "journey-module": { type: "string" },
-      "driver-arg": { type: "string", multiple: true },
-      "suite-dir": { type: "string" },
-      execute: { type: "string" },
-      "tokens-path": { type: "string" },
-      "maestro-version": { type: "string" },
-      "timeout-minutes": { type: "string" },
-      "kill-after-seconds": { type: "string" },
-      "poll-seconds": { type: "string" },
-      "custom-id": { type: "string" },
-      "run-id": { type: "string" },
-      "dry-run": { type: "boolean" },
-      "sdk-args": { type: "string" }
+  const { values: o, positionals } = (() => {
+    try {
+      return parseArgs4({
+        args: rest,
+        allowPositionals: true,
+        options: {
+          repeat: { type: "string" },
+          arms: { type: "string" },
+          "arm-env": { type: "string", multiple: true },
+          platform: { type: "string" },
+          device: { type: "string" },
+          out: { type: "string" },
+          "bundle-id": { type: "string" },
+          timeout: { type: "string" },
+          reps: { type: "string" },
+          boot: { type: "string" },
+          "ri-capture": { type: "string" },
+          "mem-window": { type: "string" },
+          "clock-offset-ms": { type: "string" },
+          "no-markers": { type: "boolean" },
+          config: { type: "string" },
+          upload: { type: "boolean" },
+          "ingest-url": { type: "string" },
+          commit: { type: "string" },
+          branch: { type: "string" },
+          "base-commit": { type: "string" },
+          wait: { type: "boolean" },
+          "fail-on-worse": { type: "boolean" },
+          scenario: { type: "string" },
+          "device-model": { type: "string" },
+          "device-os": { type: "string" },
+          "device-id": { type: "string" },
+          replay: { type: "string", multiple: true },
+          api: { type: "string" },
+          "key-env": { type: "string" },
+          "device-provider": { type: "string" },
+          journeys: { type: "string" },
+          "tokens-js": { type: "string" },
+          state: { type: "string" },
+          "ttl-seconds": { type: "string" },
+          "bs-build": { type: "string" },
+          "settle-seconds": { type: "string" },
+          "max-wait-seconds": { type: "string" },
+          flows: { type: "string" },
+          "completion-marker": { type: "boolean" },
+          "driver-version": { type: "string" },
+          "app-build-id": { type: "string" },
+          "harness-version": { type: "string" },
+          "journey-version": { type: "string" },
+          "flag-set": { type: "string" },
+          app: { type: "string" },
+          driver: { type: "string" },
+          "tunnel-for": { type: "string", multiple: true },
+          env: { type: "string", multiple: true },
+          "driver-script": { type: "string" },
+          "journey-module": { type: "string" },
+          "driver-arg": { type: "string", multiple: true },
+          "suite-dir": { type: "string" },
+          execute: { type: "string" },
+          "tokens-path": { type: "string" },
+          "maestro-version": { type: "string" },
+          "timeout-minutes": { type: "string" },
+          "kill-after-seconds": { type: "string" },
+          "poll-seconds": { type: "string" },
+          "custom-id": { type: "string" },
+          "run-id": { type: "string" },
+          "dry-run": { type: "boolean" },
+          "sdk-args": { type: "string" }
+        }
+      });
+    } catch (e) {
+      throw new UsageError([e.message, "keepsnappy --help lists the commands and their flags"]);
     }
-  });
+  })();
   if (cmd === "doctor") {
     console.log(formatChecks(await doctor(deps.spawner, process.version)));
     return 0;
@@ -12495,12 +13866,12 @@ async function main2(argv) {
   if (cmd === "measure") {
     const repeat = Number(o.repeat);
     if (!Number.isInteger(repeat) || repeat < 1)
-      throw new Error("--repeat N (>= 1) is required");
+      throw new ConfigError(["--repeat N (>= 1) is required"]);
     const platform = o.platform ?? "ios-sim";
     if (platform !== "ios-sim" && platform !== "ios-device")
-      throw new Error(`unknown --platform ${platform}`);
+      throw new ConfigError([`unknown --platform ${platform}`]);
     if (platform === "ios-device" && !o.device)
-      throw new Error("--device <udid> is required for ios-device");
+      throw new ConfigError(["--device <udid> is required for ios-device"]);
     const arms = parseArmEnv(o["arm-env"], parseArms(o.arms));
     const out = resolve8(o.out ?? `keepsnappy-${new Date().toISOString().replace(/[:.]/g, "-")}`);
     const udid = o.device ?? "booted";
@@ -12534,7 +13905,7 @@ async function main2(argv) {
   if (cmd === "extract") {
     const dir = positionals[0];
     if (!dir)
-      throw new Error("extract needs <out-dir>");
+      throw new ConfigError(["extract needs <out-dir>"]);
     const ri = o["ri-capture"] ? new FileRiSource(deps, resolve8(o["ri-capture"])) : undefined;
     const rows = await extract(deps, resolve8(dir), ri, o["mem-window"], o["clock-offset-ms"] ? Number(o["clock-offset-ms"]) : undefined);
     console.log(`${rows.length} rows -> ${resolve8(dir, "metrics.csv")}`);
@@ -12543,7 +13914,7 @@ async function main2(argv) {
   if (cmd === "aa") {
     const dir = positionals[0];
     if (!dir)
-      throw new Error("aa needs <out-dir>");
+      throw new ConfigError(["aa needs <out-dir>"]);
     const config = { ...o.reps ? { reps: Number(o.reps) } : {}, ...o.boot ? { nBoot: Number(o.boot) } : {} };
     console.log((await aa(deps, resolve8(dir), { config })).table);
     return 0;