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

package/dist/keepsnappy.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // apps/agent/src/cli.ts
-import { resolve as resolve8 } from "node:path";
+import { resolve as resolve9 } from "node:path";
 import { parseArgs as parseArgs4 } from "node:util";
 
 // apps/agent/src/config.ts
@@ -1953,6 +1953,16 @@ var MEASURES = {
     decimals: 1,
     what: "The part of the slowest screen update that React spent outside every component's own render, in its own bookkeeping"
   },
+  jank_ms: {
+    unit: "ms",
+    worse: "higher",
+    at: ["screen", "launch", "press", "drag", "step", "other", "background"],
+    producer: "tracesift",
+    label: "Jank time",
+    short: "jank time",
+    decimals: 1,
+    what: "The time the window's screen updates spent past one 60 Hz frame, added up, read from the full React export"
+  },
   commits_over_2_frames: {
     unit: "count",
     worse: "higher",
@@ -3598,6 +3608,7 @@ function occurrence(windows, budgetMs, idleNeutral = false, frameMs, upper = fal
     ...upper ? { timerCarriedMs: carried, renderMsUpper: renderMs === undefined || carried === undefined ? undefined : renderMs + carried } : {}
   };
 }
+var SAME_COMMIT_MS = 0.01;
 var UPDATERS_KEPT = 5;
 var CPU_FUNCTIONS_KEPT = 10;
 var UNTIMED_COMPONENTS_KEPT = 10;
@@ -3736,7 +3747,9 @@ function profileMetrics(windows, steps, options = {}) {
     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`) && 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 } : {} });
+    const streamed = identity ? options.commitTops?.get(identity.seq) : undefined;
+    const tops = identity && streamed && Math.abs(streamed.ms - identity.ms) <= SAME_COMMIT_MS ? streamed : undefined;
+    profiles.push({ ...profile, ...identity ? { slowestCommit: { ...identity, ...tops?.top ? { top: tops.top } : {}, ...tops?.updater ? { updater: tops.updater } : {} } } : {}, ...openedBy ? { openedBy } : {} });
   }
   return { metrics, profiles };
 }
@@ -5012,7 +5025,7 @@ function samplerFrameBudgetMs(samples) {
   }
   return hz > 1 ? frameBudgetMs(Math.round(hz)) : undefined;
 }
-function profileOptions(windows, version, processWindows = windows) {
+function profileOptions(windows, version, processWindows = windows, commitStreams = []) {
   if (version < 26)
     return {};
   const processes = new Set(processWindows.map((w) => w.raw.react?.causes?.process).filter((p) => typeof p === "string"));
@@ -5026,7 +5039,9 @@ function profileOptions(windows, version, processWindows = windows) {
     if (opener)
       openedBy.set(screen, opener.name);
   }
-  return { fullRowMs: FULL_ROW_MS, commitIdentity: processes.size <= 1, openedBy };
+  const [only] = processes.size === 1 ? processes : [];
+  const commitTops = new Map(commitStreams.filter((s) => s.process === only).flatMap((s) => s.commits.map((c) => [c.seq, c])));
+  return { fullRowMs: FULL_ROW_MS, commitIdentity: processes.size <= 1, ...commitTops.size ? { commitTops } : {}, openedBy };
 }
 function deriveRun(input) {
   const { run, markers = [], ri, clockOffsetMs, clockErrorMs, samples = [], memWindow } = input;
@@ -5049,7 +5064,7 @@ function deriveRun(input) {
     return { rows, steps, run: final, profiles: [], derivationVersion: version };
   const budget = input.frameBudgetMs ?? (version >= 6 ? samplerFrameBudgetMs(samplesInRun(samples, final.t0, final.t1)) : undefined);
   const compareMs = version >= 20 ? LIMIT_FRAME_MS : budget ?? frameBudgetMs();
-  const allComponents = profileOptions(windows, version, input.windows);
+  const allComponents = profileOptions(windows, version, input.windows, input.commitStreams);
   const prof = profileMetrics(windows, steps, {
     ...allComponents,
     frameBudgetMs: version >= 11 ? compareMs : Number(compareMs.toFixed(1)),
@@ -5203,6 +5218,26 @@ var markerEnv = (url, runId) => ({
 
 // packages/present/dist/src/capital.js
 var upperFirst = (s) => s ? s.charAt(0).toUpperCase() + s.slice(1) : s;
+var lowerFirst = (s) => s ? s.charAt(0).toLowerCase() + s.slice(1) : s;
+
+// packages/present/dist/src/names.js
+var textPart = (text) => ({ text });
+var componentPart = (text) => ({ text, component: true });
+var namePartsText = (parts) => parts.map((p) => p.text).join("");
+var plainParts = (text) => [textPart(text)];
+function nameParts(parts) {
+  const out = [];
+  for (const p of parts) {
+    if (!p.text)
+      continue;
+    const last = out.at(-1);
+    if (last && !last.component && !p.component)
+      out[out.length - 1] = textPart(last.text + p.text);
+    else
+      out.push(p);
+  }
+  return out;
+}
 
 // packages/present/dist/src/placeWords.js
 var GENERIC_GROUPS = new Set(["app", "tabs", "root"]);
@@ -5239,6 +5274,7 @@ var STATE_WORDS = {
   "no-change": "No change",
   "cant-tell": "Can’t tell"
 };
+var STATE_ORDER = ["worse", "warning", "cant-tell", "better", "no-change"];
 var INFO_WORDS = { heat: "Phone heated up" };
 var isWorseState = (state) => state === "worse";
 var NOT_BLOCKING = "not blocking";
@@ -5247,6 +5283,7 @@ var notBlockingBadge = (word, blocking) => word === STATE_WORDS.worse && blockin
 var BLOCKED_WORD = "Blocked";
 var NOT_COMPUTED_WORD = "Verdict not computed yet (computed on demand)";
 var NO_BASELINE_WORD = "Waiting for main";
+var NOT_COMPARED_WORD = "Not compared with main";
 var NOT_JUDGED_WORD = "Not judged";
 
 // packages/present/dist/src/values.js
@@ -5310,6 +5347,13 @@ function fieldValueText(field, v) {
   const def = fieldDef(field.split(KEY_SEPARATOR)[0]);
   return format(def?.unit, def?.decimals ?? FALLBACK_DECIMALS, v);
 }
+function timeMove(field, a, b) {
+  if (a === null || b === null || !(a > 0))
+    return null;
+  const breakdown = breakdownMeasure(field);
+  const unit = breakdown ? BREAKDOWN_MEASURES[breakdown].unit : fieldDef(field.split(KEY_SEPARATOR)[0])?.unit;
+  return unit === "ms" ? Math.abs(b - a) / a : null;
+}
 
 // packages/present/dist/src/rowWords.js
 var GONE_TAILS = {
@@ -5364,16 +5408,19 @@ function leadBody(subject, measure, main, pr) {
 var screenLeadText = (tier, subject, measure, main, pr) => `${STATE_WORDS[TIER_STATE[tier]]}: ${leadBody(subject, measure, main, pr)}`;
 var FOR_INFORMATION = "For information";
 var informationLeadText = (subject, measure, main, pr) => `${FOR_INFORMATION}: ${leadBody(subject, measure, main, pr)}`;
-function foldedText(n, rows, page) {
-  return `${n} ${GONE_TAILS[page][rows === "components" ? "removed" : "notInRun"]}`;
-}
 function placeShownName(p, o = {}) {
-  const target = p.target ? componentShownName(p.target.name, p.target.file) : libraryViewName(p.kind, p.host ?? "");
-  const named = p.target && p.parent ? `${target} in ${componentShownName(p.parent.name, p.parent.file)}${p.k ? `, ${ordinal(p.k)}` : ""}` : target;
-  return o.onScreen ? `${named} on ${o.onScreen}` : named;
+  return namePartsText(placeShownNameParts(p, o));
+}
+function placeShownNameParts(p, o = {}) {
+  const target = p.target ? componentNameParts(p.target.name, p.target.file) : plainParts(libraryViewName(p.kind, p.host ?? ""));
+  const named = p.target && p.parent ? [...target, textPart(" in "), ...componentNameParts(p.parent.name, p.parent.file), textPart(p.k ? `, ${ordinal(p.k)}` : "")] : target;
+  const screen = typeof o.onScreen === "string" ? plainParts(o.onScreen) : o.onScreen;
+  return nameParts(screen?.length && namePartsText(screen) ? [...named, textPart(" on "), ...screen] : named);
 }
 var libraryViewName = (kind, hostType) => `${kind === "drag" ? "Scroll" : "Tap"} outside app components (${hostType})`;
-function componentShownName(name, file) {
+var componentShownName = (name, file) => componentFileName(name, file);
+var componentNameParts = (name, file) => [componentPart(componentFileName(name, file))];
+function componentFileName(name, file) {
   if (name !== "default" || !file)
     return name;
   const path = file.replace(/\.[^.\/]+$/, "");
@@ -5427,21 +5474,49 @@ var placeOpenWord = (id) => {
   const open = placeOpen(id);
   return open ? OPEN_WORDS[open] : null;
 };
-function placeIdShownName(id, o = {}) {
+var TWIN2 = /\+3s$/;
+function foldTwins(rows, placeOf, also = () => "") {
+  const seen = new Set;
+  const out = rows.filter((r) => {
+    const key = `${placeOf(r).replace(TWIN2, "")}\x00${also(r)}`;
+    if (seen.has(key))
+      return false;
+    seen.add(key);
+    return true;
+  });
+  return { rows: out, folded: rows.length - out.length };
+}
+var foldedTwinsText = (n) => `${n} “${PLACE_KIND_WORDS.after3s}” ${n === 1 ? "twin" : "twins"} folded into ${n === 1 ? "its place" : "their places"}`;
+function placeIdShownNameParts(id, o = {}) {
   const p = placeParts(id);
   if (!p)
     return null;
   const component = (part) => ({ name: part.name, file: part.file ?? "" });
-  const screen = p.screen.name === "(no screen)" ? "" : p.screen.name === "(outside app components)" ? screenName(p.screen.file ?? "") : componentShownName(p.screen.name, p.screen.file ?? "");
+  const screen = p.screen.name === "(no screen)" ? [] : p.screen.name === "(outside app components)" ? [textPart(screenName(p.screen.file ?? ""))] : componentNameParts(p.screen.name, p.screen.file ?? "");
   if (p.kind === "screen" || p.kind === "launch")
-    return screen + (p.kind === "screen" && typeof p.visit === "number" && p.visit > 1 ? ` (${ordinal(p.visit)} visit)` : "");
-  return placeShownName({ kind: p.kind, target: p.outsideHost === null ? component(p.target) : null, parent: p.parent ? component(p.parent) : null, k: p.k, ...p.outsideHost === null ? {} : { host: p.outsideHost } }, { onScreen: o.onScreen === false ? undefined : screen });
+    return nameParts([...screen, textPart(p.kind === "screen" && typeof p.visit === "number" && p.visit > 1 ? ` (${ordinal(p.visit)} visit)` : "")]);
+  return placeShownNameParts({ kind: p.kind, target: p.outsideHost === null ? component(p.target) : null, parent: p.parent ? component(p.parent) : null, k: p.k, ...p.outsideHost === null ? {} : { host: p.outsideHost } }, { onScreen: o.onScreen === false ? undefined : screen });
 }
 var isLibraryPlace = (id) => placeParts(id)?.outsideHost != null;
-function stemName(stem, kind) {
-  const shown = placeIdShownName(stem);
+function dropTail(parts, n) {
+  const out = [];
+  for (const p of [...parts].reverse()) {
+    if (n >= p.text.length) {
+      n -= p.text.length;
+      continue;
+    }
+    out.unshift({ ...p, text: p.text.slice(0, p.text.length - n) });
+    n = 0;
+  }
+  return out;
+}
+function stemNameParts(stem, kind) {
+  const shown = placeIdShownNameParts(stem);
   if (shown !== null)
-    return isLibraryPlace(stem) ? shown : `${KIND_WORD[kind]}: ${shown}`;
+    return nameParts(isLibraryPlace(stem) ? shown : [textPart(`${KIND_WORD[kind]}: `), ...shown]);
+  return plainParts(stemText(stem, kind));
+}
+function stemText(stem, kind) {
   if (kind === "journey")
     return PLACE_KIND_WORDS.journey;
   if (kind === "other")
@@ -5457,12 +5532,13 @@ function stemName(stem, kind) {
   const visit = visitMark ? Number(visitMark[2]) : 1;
   return `${PLACE_KIND_WORDS.screen}: ${screenName(visitMark ? visitMark[1] : rest)}${visit > 1 ? ` (${ordinal(visit)} visit)` : ""}`;
 }
-function windowName(id) {
+var windowName = (id) => namePartsText(windowNameParts(id));
+function windowNameParts(id) {
   if (id === "flow")
-    return PLACE_KIND_WORDS.journey;
+    return plainParts(PLACE_KIND_WORDS.journey);
   const ref = placeRef(id);
-  const name = stemName(ref.stem, ref.kind);
-  return ref.segment === "after3s" ? `${name} · ${PLACE_KIND_WORDS.after3s}` : name;
+  const name = stemNameParts(ref.stem, ref.kind);
+  return ref.segment === "after3s" ? nameParts([...name, textPart(` · ${PLACE_KIND_WORDS.after3s}`)]) : name;
 }
 function placeKindWord(id) {
   if (id === "flow")
@@ -5470,31 +5546,33 @@ function placeKindWord(id) {
   const { kind } = placeRef(id);
   return kind === "other" ? "Window" : KIND_WORD[kind];
 }
-function windowQualified(id) {
+var windowQualified = (id) => namePartsText(windowQualifiedParts(id));
+function windowQualifiedParts(id) {
   const word = placeOpenWord(id);
-  const label = placeLabel(id);
+  const label = placeLabelParts(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}`;
+  return nameParts([...after ? dropTail(label, after.length) : label, textPart(` (${word})${after}`)]);
 }
 var ELEMENT_SEPARATORS = /(?<!\d)\.|\.(?!\d)|[_-]+/g;
 var elementWords = (testId) => testId.replace(ELEMENT_SEPARATORS, " ").replace(/\s+/g, " ").trim();
-function placeLabel(id, screen) {
+var placeLabel = (id, screen) => namePartsText(placeLabelParts(id, screen));
+function placeLabelParts(id, screen) {
   if (id === "flow")
-    return PLACE_KIND_WORDS.journey;
+    return plainParts(PLACE_KIND_WORDS.journey);
   const ref = placeRef(id);
   const after = ref.segment === "after3s" ? ` · ${PLACE_KIND_WORDS.after3s}` : "";
-  const shown = placeIdShownName(ref.stem);
+  const shown = placeIdShownNameParts(ref.stem);
   if (shown !== null)
-    return isLibraryPlace(ref.stem) ? `${shown}${after}` : `${KIND_WORD[ref.kind]} · ${shown}${after}`;
+    return nameParts([...isLibraryPlace(ref.stem) ? [] : [textPart(`${KIND_WORD[ref.kind]} · `)], ...shown, textPart(after)]);
   if (ref.kind === "press" || ref.kind === "drag" || ref.kind === "step") {
     const element = elementWords(ref.stem.slice(ref.stem.indexOf(":") + 1).replace(OPEN_MARK, ""));
-    return `${KIND_WORD[ref.kind]} · “${element}”${screen ? ` · ${screen}` : ""}${after}`;
+    return plainParts(`${KIND_WORD[ref.kind]} · “${element}”${screen ? ` · ${screen}` : ""}${after}`);
   }
   const name = windowName(ref.stem);
   const colon = name.indexOf(": ");
-  return `${colon > 0 && ref.kind !== "other" ? `${name.slice(0, colon)} · ${name.slice(colon + 2)}` : name}${after}`;
+  return plainParts(`${colon > 0 && ref.kind !== "other" ? `${name.slice(0, colon)} · ${name.slice(colon + 2)}` : name}${after}`);
 }
 // packages/present/dist/src/placeNames.js
 function shortestPaths(files) {
@@ -5513,6 +5591,28 @@ function shortestPaths(files) {
   }
   return out;
 }
+// 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/shown.js
+var feltGainText = (ms) => ms && ms > 0 ? `felt gain −${fieldValueText("jank_ms", ms)}` : null;
+var feltCostText = (ms) => ms && ms > 0 ? `felt cost +${fieldValueText("jank_ms", ms)}` : null;
+
 // packages/present/dist/src/stability.js
 var UNSTABLE_WORDS = {
   short: "main varies too much here",
@@ -5619,8 +5719,6 @@ function resultContextLines(c, verbose = false, short = false) {
   for (const [screen, rows] of screens) {
     const line = notInRunRowsText({ screens: rows.filter((p) => p.kind === "screen").length, places: rows.filter((p) => p.kind !== "screen").length }, c.page);
     out.push(`${screen ? `${screen}: ` : ""}${line.lead}${line.rest}`);
-    if (rows.length > 3)
-      out.push(`  ${foldedText(rows.length, "places", c.page)}`);
     if (!short || rows.length <= 3)
       out.push(...rows.map((p) => `  ${windowQualified(p.place)}`));
   }
@@ -5630,8 +5728,6 @@ function resultContextLines(c, verbose = false, short = false) {
   for (const [place, rows] of removed) {
     const line = removedRowsText(rows.length, c.page);
     out.push(`${windowQualified(place)}: ${line.lead}${line.rest}`);
-    if (rows.length > 3)
-      out.push(`  ${foldedText(rows.length, "components", c.page)}`);
     if (!short || rows.length <= 3)
       out.push(...rows.map((r) => `  ${r.ref.kind === "breakdown" ? componentReadName({ key: r.ref.key, name: r.ref.name }) : measureWords(r.ref.measure)}`));
   }
@@ -5663,7 +5759,7 @@ var READ_USAGE = {
   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.",
+  detail: "Include recorded per-run component and window detail: an opt-in diagnostic that reads the runs' recorded profiles (slower); ranking places never needs it.",
   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.",
@@ -5673,23 +5769,119 @@ var READ_USAGE = {
 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"
+// packages/present/dist/src/problems.js
+var FAR_OVER_BUDGET_WORD = "Far over budget";
+var heaviestWords = (name, value) => [textPart(`${HEAVIEST_WORD}: `), componentPart(name), ...value ? [textPart(` ${value}`)] : []];
+var HEAVIEST_WORD = "heaviest";
+var PROBLEM_TAG_WORDS = { new: NEW_IN_PR_CHIP, main: "Also on main", none: NOT_COMPARED_WORD };
+var PROBLEM_TAG_LINE_WORDS = { new: "new in this PR", main: "also on main", none: "not compared with main" };
+var problems = (n) => `${n.toLocaleString("en-US")} ${n === 1 ? "problem" : "problems"}`;
+var places = (n) => `${n.toLocaleString("en-US")} ${n === 1 ? "place" : "places"}`;
+var problemsAtPlaces = (n, at) => `${problems(n)} at ${places(at)}`;
+function problemCountsText(c, own) {
+  const tags = c.tags;
+  const split = tags ? `: ${[`${tags.new} ${PROBLEM_TAG_LINE_WORDS.new}`, ...["main", "none"].filter((t) => tags[t]).map((t) => `${tags[t]} ${PROBLEM_TAG_LINE_WORDS[t]}`)].join(", ")}` : "";
+  return `${problemsAtPlaces(c.count, c.places)} in ${own} own runs${split}${c.far_count ? `; ${c.far_count} of them ${FAR_OVER_BUDGET_WORD.toLowerCase()}` : ""}`;
+}
+var newProblems = (n) => `${n.toLocaleString("en-US")} new ${n === 1 ? "problem" : "problems"}`;
+var PROBLEMS_BLOCK_WORDS = {
+  branch: {
+    heading: "New problems in this branch",
+    sub: "too slow on their own, whatever main does; they don’t block the merge",
+    seeAll: (n) => `See all ${newProblems(n)}`,
+    alsoLine: (n, at) => `${PROBLEM_TAG_WORDS.main}: ${problemsAtPlaces(n, at)}`,
+    notComparedLine: (n, at) => `${PROBLEM_TAG_WORDS.none}: ${problemsAtPlaces(n, at)}`,
+    choices: { new: PROBLEM_TAG_WORDS.new, also: PROBLEM_TAG_WORDS.main, not_compared: PROBLEM_TAG_WORDS.none },
+    panelTitle: "Problems in this branch",
+    panelNote: "Each one is too slow in this branch’s own runs, whatever main does. Problems never block.",
+    filter: "Which problems"
+  },
+  main: {
+    heading: "New problems in this session",
+    sub: "too slow on their own, whatever earlier sessions did",
+    seeAll: (n) => `See all ${newProblems(n)}`,
+    alsoLine: (n, at) => `Also in earlier sessions: ${problemsAtPlaces(n, at)}`,
+    notComparedLine: (n, at) => `Not compared with earlier sessions: ${problemsAtPlaces(n, at)}`,
+    choices: { new: "New in this session", also: "Also in earlier sessions", not_compared: "Not compared with earlier sessions" },
+    panelTitle: "Problems in this session",
+    panelNote: "Each one is too slow in this session’s own runs, whatever earlier sessions did. Problems never block.",
+    filter: "Which problems"
+  }
 };
-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/place-tier.js
+var slowerCountsText = (n, sep = " · ") => [n.worse ? `${n.worse} ${STATE_WORDS.worse.toLowerCase()}` : "", n.slight ? `${n.slight} ${STATE_WORDS.warning.toLowerCase()}` : ""].filter(Boolean).join(sep);
+// packages/present/dist/src/verdict-section.js
+var places2 = (n) => `${n.toLocaleString("en-US")} ${n === 1 ? "place" : "places"}`;
+var of = (n, total) => `${n.toLocaleString("en-US")} of ${places2(total)}`;
+var runs = (n) => `${n} valid ${n === 1 ? "run" : "runs"}`;
+var VERDICT_SECTION_WORDS = {
+  slower: (n, total, slight) => `${slight ? "A little slower" : "Slower"} at ${of(n, total)}`,
+  blocksMerge: "blocks the merge",
+  faster: (n, total) => `Faster at ${of(n, total)}, slower at none`,
+  mixed: (slower, faster, total) => `Slower at ${of(slower, total)}, faster at ${faster.toLocaleString("en-US")}`,
+  unpublishedSdk: "ran an unpublished SDK build",
+  noneMoved: (total, judged = total) => judged < total ? `No place moved out of its normal range (${judged.toLocaleString("en-US")} of ${total.toLocaleString("en-US")} judged)` : `No place moved out of its normal range (${places2(total)})`,
+  noneMovedMeasured: (measured, same) => same ? `Nothing moved at ${of(same, same + measured)}; ${measured} measured differently` : `Nothing moved; ${measured} ${measured === 1 ? "place was" : "places were"} measured differently`,
+  tooFewRuns: (valid, needed) => `Not compared: ${runs(valid)} of ${needed} needed`,
+  tooFewMainRuns: (valid, needed) => `Not compared: main has ${runs(valid)} of ${needed} needed`,
+  tooFewBefore: (valid) => `Not compared: the sessions before have only ${runs(valid)}`,
+  noBaseline: { branch: "Nothing to compare with: no main runs on this phone yet", main: "Nothing to compare with: no earlier sessions on this phone" },
+  noisy: "Not judged: main’s own runs vary too much at every place here",
+  versionMismatch: "Not compared: the sides were computed with different analysis versions",
+  unconfirmed: (n) => `Can’t confirm ${places2(n)}: a run has no value there`,
+  notCompared: (reason) => `Not compared: ${reason}`,
+  notJudgedYet: (why) => `Not judged yet: ${why} on this phone`,
+  collecting: (collected, baseline, after) => after ? `Main is collecting a new baseline after ${after}: ${collected} of ${baseline} sessions` : `Main is collecting its baseline: ${collected} of ${baseline} sessions`,
+  doesNotBlock: "doesn’t block",
+  fixes: {
+    branch: {
+      "no-baseline": "Add this journey on this phone to main’s nightly runs.",
+      "too-few-runs": "Run this branch again on this phone.",
+      "judged-measures-missing": "Record the judged measures, then run again.",
+      "runs-unknown": "Run this branch again; a full set of runs decides it.",
+      "facts-version-mismatch": "Recompute both sides in Setup; no new runs are needed.",
+      "platforms-differ": "Add this phone’s platform to main’s nightly runs."
+    },
+    main: {
+      "no-baseline": "Nothing to do: main’s next 3 nightly sessions make a result possible.",
+      "too-few-runs": "Main’s next nightly session decides it.",
+      "runs-unknown": "Main’s next nightly session decides it.",
+      "judged-measures-missing": "Record the judged measures on main; its next nightly session is compared.",
+      "facts-version-mismatch": "Recompute both sides in Setup; no new runs are needed."
+    }
+  },
+  waitForMain: { branch: "Nothing to do on this branch; main’s next nightly session decides it.", main: "Main’s next nightly session decides it." },
+  sides: {
+    branch: { left: "Main", right: "This branch", rightShort: "Branch" },
+    main: { left: "Sessions before", right: "Newest session", rightShort: "Newest" },
+    runSet: { left: "Main", right: "This run set", rightShort: "Run set" }
+  },
+  branchSides: (name) => ({ left: "Main", right: name || "This branch", rightShort: "Branch" }),
+  inProgress: (arrived, expected) => `${arrived} of ${expected} runs arrived; the result comes with the last one`,
+  whatChangedLabel: "What changed",
+  moreSlower: (n) => `+${n.toLocaleString("en-US")} more slower`,
+  slowerPanel: (n) => `${places2(n)} slower`,
+  forInformation: "for information",
+  allFilter: "All",
+  filter: {
+    label: "Show places",
+    choice: (tierWord) => upperFirst(tierWord),
+    showing: (choice, n) => `Showing ${choice.toLowerCase()}: ${n}`
+  },
+  countsLabel: "Places by result",
+  links: {
+    openChart: "Open chart",
+    seeAll: (n) => `See all ${places2(n)}`,
+    whichPlaces: "Which places",
+    whichChanges: "Which changes",
+    howToFix: "How to fix",
+    whatDiffers: "What differs",
+    whatChanged: "What changed",
+    openSetup: "Open setup",
+    openScreen: "Open screen"
+  }
+};
+
 // packages/present/dist/src/main-history.js
 var MAIN_TIER_WORDS = {
   same: "In norm",
@@ -5706,11 +5898,13 @@ var MAIN_TIER_RESULT_WORDS = {
   worse: STATE_WORDS.worse
 };
 var MAIN_TIER_RANK = { worse: 0, slight: 1, cant: 2, better: 3, same: 4 };
+var earlierWords = (sessions, since, config) => `main has ${sessions}${config.baseline.sessions === undefined ? "" : ` of ${config.baseline.sessions}`} earlier sessions${since ? ` on ${since}` : ""}`;
 function mainCantWords(reason, config) {
   if (!reason)
     return "";
-  return reason.kind === "noisy_main" ? "main’s runs vary too much there" : `main has ${reason.earlier_sessions}${config.baseline.sessions === undefined ? "" : ` of ${config.baseline.sessions}`} earlier sessions${reason.since_label ? ` on ${reason.since_label}` : ""}`;
+  return reason.kind === "noisy_main" ? "main’s runs vary too much there" : earlierWords(String(reason.earlier_sessions), reason.since_label, config);
 }
+var mainCantRangeWords = (r, config) => earlierWords(`${r.min}–${r.max}`, r.since_label, config);
 var waitingSessionsWords = (sessions) => `${sessions} older main ${sessions === 1 ? "session waits" : "sessions wait"} for a reprocess`;
 function mainPlaceReasonWords(reason, config) {
   switch (reason.kind) {
@@ -5740,9 +5934,11 @@ var SHORT_ASPECT_WORDS = {
   driverVersion: "Driver",
   journeyVersion: "Journey"
 };
+var cantAt = (places) => `${STATE_WORDS["cant-tell"]} at ${places} place${places === 1 ? "" : "s"}`;
 function mainSessionCantWords(places, reason, config) {
-  return `${STATE_WORDS["cant-tell"]} at ${places} place${places === 1 ? "" : "s"}: ${mainCantWords(reason, config)}`;
+  return `${cantAt(places)}: ${mainCantWords(reason, config)}`;
 }
+var mainSessionCantRangeWords = (places, r, config) => `${cantAt(places)}: ${mainCantRangeWords(r, config)}`;
 var KIND_PLURAL = {
   screen: "screens",
   press: "taps",
@@ -5767,56 +5963,12 @@ function mainCutWords(v) {
   return parts.length ? parts.join(" ") : "Measures alike; no baseline cut.";
 }
 var BY_RANK = Object.keys(MAIN_TIER_RANK).sort((a, b) => MAIN_TIER_RANK[a] - MAIN_TIER_RANK[b]);
-// packages/present/dist/src/verdict-section.js
-var places = (n) => `${n.toLocaleString("en-US")} ${n === 1 ? "place" : "places"}`;
-var of = (n, total) => `${n.toLocaleString("en-US")} of ${places(total)}`;
-var runs = (n) => `${n} valid ${n === 1 ? "run" : "runs"}`;
-var VERDICT_SECTION_WORDS = {
-  slower: (n, total, slight) => `${slight ? "A little slower" : "Slower"} at ${of(n, total)}`,
-  blocksMerge: "blocks the merge",
-  faster: (n, total) => `Faster at ${of(n, total)}, slower at none`,
-  mixed: (slower, faster, total) => `Slower at ${of(slower, total)}, faster at ${faster.toLocaleString("en-US")}`,
-  unpublishedSdk: "ran an unpublished SDK build",
-  noneMoved: (total, judged = total) => judged < total ? `No place moved out of its normal range (${judged.toLocaleString("en-US")} of ${total.toLocaleString("en-US")} judged)` : `No place moved out of its normal range (${places(total)})`,
-  noneMovedMeasured: (measured, same) => same ? `Nothing moved at ${of(same, same + measured)}; ${measured} measured differently` : `Nothing moved; ${measured} ${measured === 1 ? "place was" : "places were"} measured differently`,
-  tooFewRuns: (valid, needed) => `Not compared: ${runs(valid)} of ${needed} needed`,
-  tooFewMainRuns: (valid, needed) => `Not compared: main has ${runs(valid)} of ${needed} needed`,
-  tooFewBefore: (valid) => `Not compared: the sessions before have only ${runs(valid)}`,
-  noBaseline: { branch: "Nothing to compare with: no main runs on this phone yet", main: "Nothing to compare with: no earlier sessions on this phone" },
-  noisy: "Not judged: main’s own runs vary too much at every place here",
-  versionMismatch: "Not compared: the sides were computed with different analysis versions",
-  unconfirmed: (n) => `Can’t confirm ${places(n)}: a run has no value there`,
-  notCompared: (reason) => `Not compared: ${reason}`,
-  notJudgedYet: (why) => `Not judged yet: ${why} on this phone`,
-  collecting: (collected, baseline, after) => after ? `Main is collecting a new baseline after ${after}: ${collected} of ${baseline} sessions` : `Main is collecting its baseline: ${collected} of ${baseline} sessions`,
-  doesNotBlock: "doesn’t block",
-  sides: {
-    branch: { left: "Main", right: "This branch", rightShort: "Branch" },
-    main: { left: "Sessions before", right: "Newest session", rightShort: "Newest" },
-    runSet: { left: "Main", right: "This run set", rightShort: "Run set" }
-  },
-  branchSides: (name) => ({ left: "Main", right: name || "This branch", rightShort: "Branch" }),
-  inProgress: (arrived, expected) => `${arrived} of ${expected} runs arrived; the result comes with the last one`,
-  whatChangedLabel: "What changed",
-  forInformation: "for information",
-  allFilter: "All",
-  filter: {
-    label: "Show places",
-    choice: (tierWord) => upperFirst(tierWord),
-    showing: (choice, n) => `Showing ${choice.toLowerCase()}: ${n}`
-  },
-  countsLabel: "Places by result",
-  links: {
-    openChart: "Open chart",
-    seeAll: (n) => `See all ${places(n)}`,
-    whichPlaces: "Which places",
-    whichChanges: "Which changes",
-    howToFix: "How to fix",
-    whatDiffers: "What differs",
-    whatChanged: "What changed",
-    openSetup: "Open setup",
-    openScreen: "Open screen"
-  }
+var MEMORY_HELD_WORDS = { head: "Memory", rest: "still held after the journey", text: "Memory still held after the journey" };
+var MAIN_CHART_TITLES = {
+  renders: "Places vs their normal range",
+  rendersTip: (baseline) => `Share of the journey’s places per session, by result against main’s ${baseline} sessions before it. Dashed: not judged yet, while main collects ${baseline} sessions on the setup (after main’s start or a change).`,
+  memory: `${MEMORY_HELD_WORDS.text} · MB`,
+  memoryTip: "Memory kept by the journey: what it still holds after the clean-up at its end. Line: the median of a session; band: the spread inside it."
 };
 // packages/present/dist/src/summary-message.js
 var SUMMARY_WORDS = {
@@ -5832,39 +5984,62 @@ var SUMMARY_WORDS = {
   fewRuns: "few runs",
   measuredDifferently: "measured differently",
   namesChanged: (sdk, mainSessions, needed) => `Main: ${mainSessions} of ${needed} sessions on SDK ${sdkTag(sdk)}`,
+  morePlaces: (n) => `+${n} more ${n === 1 ? "place" : "places"} changed`,
+  slowerPlaces: (n, split) => `${n} ${n === 1 ? "place" : "places"} slower${split && slowerCountsText(split) ? `: ${slowerCountsText(split, ", ")}` : ""}`,
+  noPlaceSlower: "no place slower",
+  toCheck: (n) => `${n} ${n === 1 ? "component" : "components"} to check`,
+  compared: {
+    branch: (sessions, days) => `vs main’s last ${sessions}${days}`,
+    main: (sessions, days) => `newest session vs main’s ${sessions} before${days}`,
+    mainSlower: (sessions, days) => `newest session slower than main’s ${sessions} before${days}`
+  },
+  sessions: (n) => `${n} ${n === 1 ? "session" : "sessions"}`,
+  days: (days) => days ? ` (${days})` : "",
+  runs: (runs, each) => each ? `${each} ${each === 1 ? "run" : "runs"} each` : `${runs} ${runs === 1 ? "run" : "runs"}`,
+  unblock: (why, fix) => `${why} → ${fix}`,
   link: {
-    lane: (journey, phone) => `Open ${journey} on ${phone}`,
-    phone: (phone) => `Open on ${phone}`,
+    comparison: "See the comparison",
+    session: "See the session",
     branch: (branch) => `Open ${branch}`,
     runSet: "Open the run set"
   }
 };
-var ORDER = ["worse", "warning", "cant-tell", "not-computed", "better", "no-change"];
+var ORDER = [...STATE_ORDER.slice(0, 3), "not-computed", ...STATE_ORDER.slice(3)];
 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 NAME = { name: 32, button: 30 };
+var TOP2 = 3;
+var MAX_LINES = 5;
 var upper = (s) => s ? `${s[0].toUpperCase()}${s.slice(1)}` : s;
 var fromTo = (a, b) => {
   const unit = (v) => / [^\d\s]+$/.exec(v)?.[0];
   return unit(a) && unit(a) === unit(b) ? `${a.slice(0, -unit(a).length)} → ${b}` : `${a} → ${b}`;
 };
-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 days = (labels) => {
+  const a = labels[0], b = labels.at(-1);
+  if (!a || !b || a === b)
+    return a ?? "";
+  const [ma] = a.split(" ");
+  const [mb, db] = b.split(" ");
+  return ma === mb ? `${a}–${db}` : `${a}–${b}`;
 };
+var changeLine = (c, tier) => {
+  const values = c.main !== null && c.now !== null ? `${fromTo(c.main, c.now)}${c.change ? ` (${c.change})` : ""}` : c.change;
+  return [c.place ?? upper(c.measure), ...c.place ? [c.measure] : [], values, WORD[c.tier ?? tier]].filter(Boolean).join(" · ");
+};
+function tierSplit(l) {
+  const worse = new Set, all = new Set;
+  for (const c of l.changes) {
+    const key = c.key ?? c.place ?? c.measure;
+    all.add(key);
+    if ((c.tier ?? l.state) === "worse")
+      worse.add(key);
+  }
+  const split = { worse: worse.size, slight: all.size - worse.size };
+  return l.state === "worse" && !split.slight || l.state === "warning" && !split.worse ? undefined : split;
+}
 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) {
@@ -5880,19 +6055,30 @@ function why(l) {
     return upper(SUMMARY_WORDS.placesOnPage);
   return upper(wordReason(l.word) ?? (l.word === NO_BASELINE_WORD ? l.word : REASON_WORDS["judged-measures-missing"]));
 }
+function unblock(l, pr) {
+  const page = pr ? "branch" : "main";
+  const reason = l.namesChanged ? "not-enough-main" : l.reason;
+  if (!reason)
+    return null;
+  const fix = reason === "not-enough-main" ? VERDICT_SECTION_WORDS.waitForMain[page] : VERDICT_SECTION_WORDS.fixes[page][reason];
+  return fix ? lowerFirst(fix.replace(/\.$/, "")) : null;
+}
 var noneMoved = VERDICT_SECTION_WORDS.noneMoved(1).replace(/ \(.*\)$/, "");
 function conditions(l, pr) {
   const moved = l.state === "worse" || l.state === "warning";
-  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)
-  };
+  return [
+    pr && l.state === "worse" ? l.blocking ? VERDICT_SECTION_WORDS.blocksMerge : NOT_BLOCKING : "",
+    moved && l.measuredDifferently ? SUMMARY_WORDS.measuredDifferently : "",
+    (moved || l.state === "better") && l.fewRuns ? SUMMARY_WORDS.fewRuns : ""
+  ].filter(Boolean);
+}
+function compared(l, pr, slower) {
+  const judged = l.state === "worse" || l.state === "warning" || l.state === "better" || l.state === "no-change";
+  if (!judged || !l.main?.sessions)
+    return null;
+  const args = [SUMMARY_WORDS.sessions(l.main.sessions), SUMMARY_WORDS.days(days(l.main.labels))];
+  const what = pr ? SUMMARY_WORDS.compared.branch(...args) : slower ? SUMMARY_WORDS.compared.mainSlower(...args) : SUMMARY_WORDS.compared.main(...args);
+  return `${what} · ${SUMMARY_WORDS.runs(l.main.runs, l.main.each)}`;
 }
 function summaryMessage(input) {
   const l = shownLane(input.lanes);
@@ -5901,37 +6087,84 @@ function summaryMessage(input) {
       state: "not-computed",
       newestSlower: false,
       lead: `${SUMMARY_WORDS.notComputed} · ${clip(input.branch, NAME.name)}`,
-      detail: upper(SUMMARY_WORDS.notComputedWhy),
+      ...withLines([upper(SUMMARY_WORDS.notComputedWhy)]),
       link: { label: SUMMARY_WORDS.link.branch(clip(input.branch, NAME.button - 5)), url: input.url }
     };
   }
   const journeys = new Set(input.lanes.map((x) => x.journey ?? "-")).size;
+  const phones = new Set(input.lanes.map((x) => x.phone ?? "-")).size;
   const single = input.lanes.length === 1;
-  const 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 } };
+  const lead = [
+    notJudgedWhy(l) ? NOT_JUDGED_WORD : WORD[l.state],
+    ...input.app ? [input.app] : [],
+    journeys === 1 ? l.journey ?? "journey" : SUMMARY_WORDS.journeys(journeys),
+    input.pr && input.prNumber ? `${input.branch} (#${input.prNumber})` : input.branch,
+    phones === 1 ? l.phone ?? "unknown phone" : SUMMARY_WORDS.phones(phones)
+  ].join(" · ");
+  const label = input.pr ? SUMMARY_WORDS.link.comparison : SUMMARY_WORDS.link.session;
+  const link = { label, url: (single ? l.url : null) ?? input.url };
+  if (!input.slack)
+    return { state: l.state, newestSlower, lead, ...withLines(changeLines(l, input.pr, newestSlower)), link };
+  const lines = [];
+  if (l.state === "worse" || l.state === "warning") {
+    const n = l.places || l.changes.length;
+    lines.push(upper([...n ? [SUMMARY_WORDS.slowerPlaces(n, tierSplit(l))] : [], feltCostText(l.feltCostMs)].filter(Boolean).join(" · ") || why(l)));
+  } else if (l.state === "no-change")
+    lines.push(upper(SUMMARY_WORDS.noPlaceSlower));
+  else if (l.state === "cant-tell") {
+    const fix = unblock(l, input.pr);
+    lines.push(fix ? SUMMARY_WORDS.unblock(why(l), fix) : why(l));
+  } else if (l.state === "better")
+    lines.push([why(l), feltGainText(l.feltGainMs)].filter(Boolean).join(" · "));
+  else
+    lines.push(why(l));
+  if (l.toCheckCount)
+    lines.push(upper(SUMMARY_WORDS.toCheck(l.toCheckCount)));
+  const basis = compared(l, input.pr, false);
+  const extra = conditions(l, input.pr).join(", ");
+  const heat = l.heatedRuns ? SUMMARY_WORDS.heated(l.heatedRuns, l.runs) : null;
+  const context = [basis ? `${basis}${extra ? `; ${extra}` : ""}` : extra, heat].filter(Boolean).join(" · ");
+  if (context)
+    lines.push(basis ? context : upper(context));
+  return { state: l.state, newestSlower, lead, ...withLines(lines), link };
+}
+function changeLines(l, pr, newestSlower) {
+  const lines = [];
+  const basis = compared(l, pr, newestSlower);
+  const extra = conditions(l, pr).join(", ");
+  const heat = l.heatedRuns ? upper(SUMMARY_WORDS.heated(l.heatedRuns, l.runs)) : null;
+  const felt = l.state === "worse" || l.state === "warning" ? feltCostText(l.feltCostMs) : l.state === "better" ? feltGainText(l.feltGainMs) : null;
+  const sums = upper([felt, l.toCheckCount ? SUMMARY_WORDS.toCheck(l.toCheckCount) : null].filter(Boolean).join(" · "));
+  const tail = [...sums ? [sums] : [], ...basis || extra ? [basis ? `${basis}${extra ? `; ${extra}` : ""}` : upper(extra)] : [], ...heat ? [heat] : []];
+  if (l.state === "worse" || l.state === "warning" || l.state === "better") {
+    const seen = new Set;
+    const places = l.changes.filter((c) => {
+      const key = c.key ?? c.place ?? c.measure;
+      return seen.has(key) ? false : (seen.add(key), true);
+    });
+    const room = MAX_LINES - tail.length;
+    const top = places.length > room ? places.slice(0, Math.min(TOP2, room - 1)) : places.slice(0, TOP2);
+    lines.push(...top.map((c) => changeLine(c, l.state)));
+    if (!top.length)
+      lines.push(why(l));
+    const more = l.places - top.length;
+    if (top.length && more > 0)
+      lines.push(SUMMARY_WORDS.morePlaces(more));
+  } else {
+    const fix = l.state === "cant-tell" ? unblock(l, pr) : null;
+    lines.push(fix ? SUMMARY_WORDS.unblock(why(l), fix) : why(l));
+  }
+  lines.push(...tail);
+  return lines;
 }
+var withLines = (lines) => ({ lines, detail: lines.join(`
+`) });
 function pendingMessage(branch, url) {
-  return { state: "not-computed", newestSlower: false, lead: `${SUMMARY_WORDS.notComputed} · ${clip(branch, NAME.name)}`, detail: upper(SUMMARY_WORDS.notComputedWhy), link: { label: SUMMARY_WORDS.link.runSet, url } };
+  return { state: "not-computed", newestSlower: false, lead: `${SUMMARY_WORDS.notComputed} · ${clip(branch, NAME.name)}`, ...withLines([upper(SUMMARY_WORDS.notComputedWhy)]), link: { label: SUMMARY_WORDS.link.runSet, url } };
 }
 function noResultMessage(branch, reason, url) {
-  return { state: "not-computed", newestSlower: false, lead: `${SUMMARY_WORDS.noResult} · ${clip(branch, NAME.name)}`, detail: reason.replace(/\.$/, ""), link: url ? { label: SUMMARY_WORDS.link.runSet, url } : null };
+  return { state: "not-computed", newestSlower: false, lead: `${SUMMARY_WORDS.noResult} · ${clip(branch, NAME.name)}`, ...withLines([reason.replace(/\.$/, "")]), link: url ? { label: SUMMARY_WORDS.link.runSet, url } : null };
 }
 // packages/present/dist/src/run-set-message.js
 var midLine = (label, metric) => !metric.startsWith("component:") && /^[A-Z][a-z]*(\s|$)/.test(label) ? `${label[0].toLowerCase()}${label.slice(1)}` : label;
@@ -6006,6 +6239,8 @@ function laneOf(v, sc, set) {
     changes: shown.map((i) => ({
       place: placeOf(i.step),
       measure: measureWord(i),
+      key: i.finding ?? placeRef(i.step ?? "*").stem,
+      tier: i.state === "better" ? "better" : i.grade === "warn" ? "warning" : "worse",
       main: i.baseline === null ? null : atMost(fieldValueText(i.metric, i.baseline), i.baseline_is_bound),
       now: i.candidate === null ? null : fieldValueText(i.metric, i.candidate),
       change: changeWords(i)
@@ -6017,17 +6252,23 @@ function laneOf(v, sc, set) {
     heatedRuns: sc.heated_runs ?? 0,
     runs: sc.runs.valid + sc.runs.invalid,
     namesChanged: sc.context?.namesChanged ?? null,
-    url: linkOf(sc, set)
+    url: linkOf(sc, set),
+    main: sc.main ?? null,
+    reason: sc.headline?.reason ?? sc.headline?.reasons?.[0] ?? null,
+    feltCostMs: sc.headline?.felt_cost_ms ?? null,
+    feltGainMs: sc.headline?.felt_gain_ms ?? null,
+    toCheckCount: sc.headline?.to_check_count ?? null
   };
 }
 var isPending = (s) => lanesOf(s).every((l) => l.state === "not-computed" && !l.word?.startsWith(`${NOT_JUDGED_WORD}: `));
 var lanesOf = (s) => s.verdicts ? s.verdicts.scenarios.map((sc) => laneOf(s.verdicts, sc, s)) : [];
 var isPr = (s) => !!s.verdicts?.scenarios.some((sc) => sc.role === "comparison");
-var runSetMessage = (s) => summaryMessage({ branch: s.branch, pr: isPr(s), lanes: lanesOf(s), url: linkOf(s) ?? s.dashboard_url });
+var runSetMessage = (s, o = {}) => summaryMessage({ branch: s.branch, pr: isPr(s), lanes: lanesOf(s), url: linkOf(s) ?? s.dashboard_url, app: s.app ?? null, prNumber: s.pull_request?.number ?? null, slack: o.slack });
 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))
+  const pr = !!s && isPr(s);
+  if (lanes.some((l) => l.state === "worse" && (l.blocking || !pr)))
     return { mark: "\uD83D\uDD34", color: MESSAGE_COLORS.error };
   if (lanes.some((l) => l.state === "warning"))
     return { mark: "\uD83D\uDFE1", color: MESSAGE_COLORS.warn };
@@ -6062,25 +6303,50 @@ function resultSlackPayload(s, o = {}) {
   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)
+  if (!isPr(s) && !moved && !improved && !heat && !o.always)
     return null;
-  return slackPayload(runSetMessage(s), messageTone(s));
+  return slackPayload(runSetMessage(s, { slack: true }), 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.lines.join(`  
+`)}
 ${m.link ? `
 [${m.link.label} ›](${m.link.url})
 ` : ""}`;
 var resultMarkdown = (s) => markdown(runSetMessage(s), messageTone(s).mark);
 var noResultMarkdown = (branch, reason, url) => markdown(noResultMessage(branch, reason, url), "⚪");
 var pendingMarkdown = (branch, url) => markdown(pendingMessage(branch, url), "⚪");
+// packages/present/dist/src/stale.js
+function staleNoteText(why) {
+  const newer = why.includes("newer-run-set");
+  const rules = why.some((w) => w === "core-version" || w === "config");
+  if (newer && rules)
+    return "Result from an older run set and older rules.";
+  if (newer)
+    return "Result from an older run set; a newer one has arrived.";
+  if (rules)
+    return "Result from older rules; it is not recomputed yet.";
+  return "Result from older inputs.";
+}
+var staleFlagText = (why) => {
+  const note = staleNoteText(why).replace(/\.$/, "");
+  return `${note.charAt(0).toLowerCase()}${note.slice(1)}`;
+};
+var STALE_MARK = "stale result";
 // apps/agent/src/upload.ts
 import { join as join4 } from "node:path";
 var MAX_RATE_RETRIES = 5;
 var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var pause = (ms) => sleep(ms);
+
 class UploadError extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+  }
 }
 async function call(f, base, path, headers, body, method = "POST") {
   let res;
@@ -6092,7 +6358,7 @@ async function call(f, base, path, headers, body, method = "POST") {
         ...method === "POST" ? { body: JSON.stringify(body ?? {}) } : {}
       });
     } catch (e) {
-      throw new UploadError(`${method} ${path}: ${e.message}`);
+      throw new UploadError(`${method} ${path}: ${e.message}`, 0);
     }
     if (res.status !== 429 || attempt >= MAX_RATE_RETRIES)
       break;
@@ -6102,7 +6368,7 @@ async function call(f, base, path, headers, body, method = "POST") {
   }
   const text = await res.text();
   if (res.status < 200 || res.status >= 300)
-    throw new UploadError(`${method} ${path} -> ${res.status} ${text.slice(0, 200)}`);
+    throw new UploadError(`${method} ${path} -> ${res.status} ${text.slice(0, 200)}`, res.status);
   try {
     return text ? JSON.parse(text) : {};
   } catch {
@@ -6239,13 +6505,35 @@ async function createRunSet(t, body) {
     throw new UploadError("POST /v1/run-sets: response has no run_set_id (is the URL the KeepSnappy API?)");
   return { run_set_id: r.run_set_id, dashboard_url: String(r.dashboard_url ?? "") };
 }
+var UNKNOWN_OUTCOME = new Set([0, 502, 503, 504]);
+var CONFIRM_READS = 6;
+var CONFIRM_WAIT_MS = 1e4;
 async function completeRunSet(t, id, verdicts) {
   const path = `/v1/run-sets/${encodeURIComponent(id)}/complete`;
-  const r = await call(t.fetch ?? fetch, t.url, path, keyHeader(t), { verdicts });
+  let r;
+  try {
+    r = await call(t.fetch ?? fetch, t.url, path, keyHeader(t), { verdicts });
+  } catch (e) {
+    const closed = e instanceof UploadError && UNKNOWN_OUTCOME.has(e.status ?? -1) ? await confirmedClose(t, id) : null;
+    if (closed)
+      return closed;
+    throw e;
+  }
   if (!r.run_set_id)
     throw new UploadError(`POST ${path}: response has no run_set_id`);
   return r;
 }
+async function confirmedClose(t, id) {
+  const path = `/v1/run-sets/${encodeURIComponent(id)}`;
+  for (let i = 0;i < CONFIRM_READS; i++) {
+    if (i)
+      await pause(CONFIRM_WAIT_MS);
+    const s = await call(t.fetch ?? fetch, t.url, path, keyHeader(t), undefined, "GET").catch(() => null);
+    if (s?.run_set_id && (s.status === "processed" || s.status === "failed"))
+      return s;
+  }
+  return null;
+}
 async function createIngestRun(t, body) {
   const r = await call(t.fetch ?? fetch, t.url, "/v1/runs", keyHeader(t), body);
   if (!r.run_id || !r.run_token)
@@ -10188,8 +10476,14 @@ ${outcome.summary}`);
   const info = { device, ...git.branch ? { branch: git.branch } : {}, ...git.commit ? { commit: git.commit } : {} };
   await deps.fs.writeFile(join9(out, RUN_INFO), `${JSON.stringify({ ...info, ...runSet ? { run_set_id: runSet.run_set_id } : {} }, null, 2)}
 `);
-  if (!api)
+  if (!api) {
+    if (!runs.some((run) => run.valid)) {
+      const reasons = [...new Set(runs.map((run) => run.invalid_reason).filter(Boolean))];
+      rt.print(`No valid run was recorded: ${runs.length === 0 ? "no runs were attempted" : `${runs.length} ${runs.length === 1 ? "run" : "runs"} invalid${reasons.length ? ` (${reasons.join(", ")})` : ""}`}.`);
+      return EXIT.infra;
+    }
     return EXIT.ok;
+  }
   const up = await uploadRuns(deps, out, runs, {
     ingestUrl: api.url,
     key: api.key,
@@ -10410,7 +10704,7 @@ async function aa(deps, outDir, opts = {}) {
 }
 
 // apps/agent/src/farm.ts
-import { dirname as dirname3, join as join13, resolve as resolve5 } from "node:path";
+import { dirname as dirname4, join as join13, resolve as resolve6 } from "node:path";
 
 // packages/appium-driver/dist/src/links.js
 var ALERT_POLL_MS = 250;
@@ -10714,7 +11008,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.18";
+  const built = "0.1.0-alpha.20";
   if (built)
     return built;
   let dir = dirname2(fileURLToPath(import.meta.url));
@@ -10769,6 +11063,11 @@ var SDK_FLUSH_WORST_CASE_MS = 315000;
 var FLUSH_MARGIN_MS = 30000;
 var FLUSH_WAIT_MS = SDK_FLUSH_WORST_CASE_MS + FLUSH_MARGIN_MS;
 var FLUSH_STATUSES = new Set(["ok", "error", "off"]);
+// packages/verdict-core/dist/src/version.generated.js
+var CORE_FINGERPRINT = "1c8a7ed82956dae0";
+
+// packages/verdict-core/dist/src/version.js
+var CORE_VERSION = parseInt(CORE_FINGERPRINT.slice(0, 7), 16);
 // 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;
@@ -10795,6 +11094,9 @@ var CLAUSES = {
     commit: { c: 0.8326, k95: 1.7675, k99: 2.8108 },
     component: { c: 0.6481, k95: 1.8075, k99: 2.6648 }
   }),
+  "T-NOISE-JANK": row("T-NOISE-JANK", "The judged `jank` rule: the no-change noise curve of jank time, as T-WARN-NOISE; at a main median of 0, Slightly worse past zeroWarn and Worse past zeroError.", "ms", ">", "W8 option A, Arek 2026-10-26 [ctl-arek-jank-time]; fitted by the 2026-10-16 method (dedup-nomi, PR 3x3 vs main 3x3, every split) on pack v3 aa-ni (S23 TapIn, 10 sessions, 4200 splits, 19 places with a median above 0, R² -0.27; the 10-16 S23 and iPhone sessions are no longer stored); zeroWarn = the largest d99 at a median of 0 over the A/A pools with an export (farm16 Pixel 7), zeroError = zeroWarn x k99 / k95", true, {
+    jank: { c: 0.9159, k95: 2.5757, k99: 3.2072, zeroWarn: 10.38, zeroError: 12.92 }
+  }),
   "T-REL": row("T-REL", "The relative part of both tiers when a rule has no noise curve; the deciding config's tiers cap it at the error ms, so no input reaches it.", "share", ">", "REQ-MET-26, controller 2026-10-16", false, { rel: 0.3 }),
   "J-MEMORY-RETAINED": row("J-MEMORY-RETAINED", "Memory the journey kept after the end GC: Slightly worse past max(warn MB, warn % of main), Worse past max(error MB, error % of main), on every device.", "MB", ">", "REQ-MET-4, Arek 2026-10-20 ~08:00, pair B (standing-rulings.md); provisional", true, { warn: { abs: 20, rel: 0.1 }, error: { abs: 150, rel: 0.3 } }),
   "E-REACT-COUNTS": row("E-REACT-COUNTS", "Commit and render counts are evidence past max(floor, +50 % of main).", "count", ">", "REQ-MET-13, Arek 2026-10-20 (morning rulings, Layer 2); provisional", true, { commits: { rel: 0.5, abs: 2 }, renders: { rel: 0.5, abs: 10 } }),
@@ -10802,6 +11104,7 @@ var CLAUSES = {
   "E-BACKGROUND": row("E-BACKGROUND", "Background places are evidence past max(floor, % of main).", "ms", ">", "REQ-MEAS-32; the number has no ruling", true, { background_commit: FLOOR, background_render: FLOOR, background_component: FLOOR }),
   "E-LAUNCH": row("E-LAUNCH", "The launch screen is evidence past max(5 ms, +30 % of main).", "ms", ">", "REQ-VER-15; floor adopted 2026-10-21 from config.ts F-13, [ctl-stab-noold-1625]", true, { launch_commit: FLOOR, launch_render: FLOOR, launch_component: FLOOR }),
   "E-STEP": row("E-STEP", "A declared step is evidence past max(5 ms, +30 % of main).", "ms", ">", "REQ-MET-14; floor adopted 2026-10-21 from config.ts F-13, [ctl-stab-noold-1625]", true, { step_commit: FLOOR, step_render: FLOOR, step_component: FLOOR }),
+  "E-COMMIT-MAX": row("E-COMMIT-MAX", "The slowest commit at a judged window is evidence past max(5 ms, +30 % of main) while jank time is judged.", "ms", ">", "W8 option A, Arek 2026-10-26 [ctl-arek-jank-time]: commit_max_ms stays shown as evidence", true, { commit_max: FLOOR }),
   "E-TOUCH": row("E-TOUCH", "Touch response is evidence past max(10 ms, +20 % of main).", "ms", ">", 'ruling "touch response is not judged" (REQ-MET-24)', true, { touch: { rel: 0.2, abs: 10 } }),
   "E-FREEZE": row("E-FREEZE", "The longest freeze (window, journey) is evidence past max(17 ms, +50 % of main).", "ms", ">", NO_RULING, true, { freeze: { rel: 0.5, abs: 17 }, freeze_journey: { rel: 0.5, abs: 17 } }),
   "E-MEMORY-PLACE": row("E-MEMORY-PLACE", "Memory added at a place is evidence past this many MB (screens have their own), on every device.", "MB", ">", 'REQ-MET-4 amendment 2026-10-18 ~21:10 and ~22:20 ("abs 2 MB, screens 10 MB")', true, { memory_added: { abs: 2 }, memory_added_screen: { abs: 10 } }),
@@ -10857,7 +11160,8 @@ var REACT_MEASURES = [
   "self_ms_top",
   "component_ms",
   "dimension:component",
-  "dimension:updater"
+  "dimension:updater",
+  "jank_ms"
 ];
 var WINDOW_MODEL_AFFECTS = [
   "commits",
@@ -10882,7 +11186,8 @@ var WINDOW_MODEL_AFFECTS = [
   "memory_left_mb",
   "retained_mb_per_cycle",
   "dimension:component",
-  "dimension:updater"
+  "dimension:updater",
+  "jank_ms"
 ];
 var MEASURES_AT = (kind) => [...Object.keys(MEASURES).filter((id) => MEASURES[id].at.includes(kind)), "dimension:component", "dimension:updater"];
 var SPLIT_AFFECTS = [
@@ -11040,7 +11345,7 @@ var DRIVER_RELEASES = [
       { 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)."
+    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 are told apart by the `capture` measured-with aspect (run setup.capture, #344, #426). Screens and taps stay compared (REQ-FARM-35)."
   },
   {
     version: "0.1.0-alpha.18",
@@ -11048,8 +11353,31 @@ var DRIVER_RELEASES = [
     declares: [{ affects: DRAG_TIME_AND_CPU, places: ["drag"], platforms: ["ios"] }],
     uncalibrated: false,
     source: "R-SCROLL-BUILD (#355 one scroll primitive and the counted gesture retry, #356 the scroll fault matrix). Android declares nothing: on a phone that takes every gesture the driver sends the same requests, bodies and waits as alpha.17 (the whole command stream is pinned). iOS: each checked drag (every to-top drag of flingUntilShown/passChecked and the first drag of each scrollToEnd pass) gains two frame reads of the held row, one right before and one right after it, so a drag window's time and CPU can change; its React render, commits and memory stay compared. A phone that drops a gesture (BrowserStack Galaxy S23, S25 Ultra) gets that gesture once more, as a counted harness defect (REQ-FARM-35)."
+  },
+  {
+    version: "0.1.0-alpha.19",
+    previous: "0.1.0-alpha.18",
+    declares: [
+      { affects: MEASURES_AT("drag"), places: ["drag"], platforms: ["ios"] },
+      { affects: MEASURES_AT("step"), places: ["step"], platforms: ["ios"] }
+    ],
+    uncalibrated: false,
+    source: "#393 (fix/keepsnappy-clamped-row-drag-travel, appium-driver CHANGELOG 2026-10-27): on iOS a row-to-top drag whose end safeBottomY clamps (chat history on every iPhone with a home indicator) starts 33 pt higher, so it travels 33 pt further in the same 400 ms (a faster release, a longer coast), with one list lookup and two frame reads right before it. Every measure of that drag window can move, React work included (more rows scroll by), and so can the step whose scroll steps contain it. Android and unclamped drags send the same requests as alpha.18 (pinned): declares nothing there (REQ-FARM-35)."
+  },
+  {
+    version: "0.1.0-alpha.20",
+    previous: "0.1.0-alpha.19",
+    declares: [
+      { affects: MEASURES_AT("drag"), places: ["drag"] },
+      { affects: MEASURES_AT("step"), places: ["step"] },
+      { affects: MEASURES_AT("journey"), places: ["journey"] }
+    ],
+    uncalibrated: false,
+    source: '#417 (plan 84 step 2.1, D1, appium-driver CHANGELOG "release alpha.20", 2026-10-27): one gesture definition for every list and screen scroll on both platforms, one touch held 150 ms over 60 % of the list frame (at least 250 dp or pt). Android list and screen flings 12 000 / 3000 dp/s -> that contact (a shorter coast, about 1000-1600 dp in place of about 7000, so fewer momentum frames and possibly one more gesture per page pass); iOS list drags 75 % (end) / 65 % (top) -> 60 %, iOS drawn-row (inverted list) drags 400 -> 150 ms; touches reaching a system zone move whole. Every other request, body and wait is pinned unchanged against alpha.19. The CHANGELOG states "changes Android and iOS list/scroll places; compare only within alpha.20 on both platforms", so both platforms are declared at drag, step and journey places (REQ-FARM-35): the journey holds the whole-run measures the judge reads (memory kept, memory at launch, end and peak, whole-run CPU, the longest freeze), and a shorter coast and one more gesture per page pass move them too.'
   }
 ];
+var JOURNEY_RELEASES = {};
+var CAPTURE_MEASURED_WITH = { aspect: "capture", affects: LOADED_MEMORY, marks: true };
 var UNSTABLE_NOISY = {
   reason: "noisy",
   spread: "sessions",
@@ -11063,7 +11391,6 @@ var UNSTABLE_NOISY = {
   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) {
@@ -11075,7 +11402,7 @@ class ConfigError2 extends Error {
 var noRow = (id) => {
   throw new ConfigError2([`${id}: no row in the clause table`]);
 };
-var NOISE_FITS = CLAUSES["T-WARN-NOISE"].value;
+var NOISE_FITS = { ...CLAUSES["T-WARN-NOISE"].value, ...CLAUSES["T-NOISE-JANK"].value };
 var TIER_REL = 0.3;
 var TIER_UPDATE_MS = { warnMs: 5, errorMs: 15 };
 var TIER_WORK_MS = { warnMs: 10, errorMs: 30 };
@@ -11107,17 +11434,16 @@ function withClauseValues(base) {
     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 };
+    const n = { a: 0, b: fit.c, power: 0.5, lift: fit.k95, ...fit.zeroWarn !== undefined ? { atZero: fit.zeroWarn } : {} };
     return {
       ...r,
       threshold: [{ abs: warnMs.update, noise: n }],
       thresholdByWork: { entry: [{ abs: warnMs.work, noise: n }], mount: [{ abs: warnMs.work, noise: n }] },
-      errorNoise: { ...n, lift: fit.k99 },
-      uncalibrated: noise.uncalibrated
+      errorNoise: { a: 0, b: fit.c, power: 0.5, lift: fit.k99, ...fit.zeroError !== undefined ? { atZero: fit.zeroError } : {} },
+      uncalibrated: (r.id in CLAUSES["T-NOISE-JANK"].value ? CLAUSES["T-NOISE-JANK"] : CLAUSES["T-WARN-NOISE"]).uncalibrated
     };
   };
   const evidence = (r) => {
@@ -11125,11 +11451,18 @@ function withClauseValues(base) {
     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) => {
+  const valued = (r) => {
     if (r.id === "memory_retained")
       return { ...r, threshold: [part(memory.value.warn)], uncalibrated: memory.uncalibrated };
-    return r.role === "judged" ? judgedByNoise(r) : evidence(r);
-  });
+    if (r.role === "judged")
+      return judgedByNoise(r);
+    if (r.id in NOISE_FITS) {
+      const { errorNoise: _error, ...shown } = judgedByNoise(r);
+      return shown;
+    }
+    return evidence(r);
+  };
+  const rules = base.rules.map(valued);
   const frames = (id) => ({ above: { frames: CLAUSES[id].value.frames }, uncalibrated: CLAUSES[id].uncalibrated });
   const entry = CLAUSES["P-HEAVY-ENTRY"];
   const unstable = CLAUSES["U-NOISY"];
@@ -11171,12 +11504,38 @@ function withClauseValues(base) {
       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]))
+      curve: Object.fromEntries(Object.keys(u.curve).map((id) => [id, (NOISE_FITS[id] ?? noRow(`unstable curve ${id}`)).c])),
+      ...u.reads ? { reads: u.reads.map(valued) } : {}
     }))
   };
 }
+var COMMIT_MAX_JUDGED = noiseJudged("commit", { measure: "commit_max_ms" });
+var RENDER_JUDGED = noiseJudged("render", { measure: "render_ms" });
+var COMPONENT_JUDGED = noiseJudged("component", { dimension: "component", measure: "self_ms" });
+var MEMORY_RETAINED = {
+  id: "memory_retained",
+  role: "judged",
+  on: { measure: "mem.retained_growth_mb" },
+  places: JOURNEY,
+  devices: ANY_DEVICE,
+  threshold: [{ rel: 0.1, abs: 20 }],
+  uncalibrated: true,
+  source: MEMORY_PAIR_SOURCE
+};
+var FELT_SOURCE = 'Arek 2026-10-27 ~08:00 ("Ok", [ctl-arek-felt-cost], amends decision 0005 / Q-5): component self time explains, never decides; every component past its noise is listed "to check", also on a green verdict';
+var JANK_SOURCE = `W8 option A, Arek 2026-10-26 ("Opcja A jest git", [ctl-arek-jank-time]): jank time (the window's commit times past one 60 Hz frame, added up) is judged in place of the slowest commit, so one spike no longer decides and jitter below a frame counts 0; curve T-NOISE-JANK; deciding since simple-4.26 after the pack v3 replay (A/A Slightly worse 58 -> 46 of 840 on aa-ni, doses 54 of 54)`;
+var NOISY_WIDEN = {
+  noisyFrom: 1,
+  lineMultiplier: 1,
+  sd: "aa-loo",
+  excludeAbove: null,
+  excludeReturnBelow: null,
+  excludeAboveMs: null,
+  uncalibrated: false,
+  source: `Arek 2026-10-27 ~19:45 [ctl-arek-noisy-widen]: noisy places judged with a widened line, tunable down to the old exclusion (excludeAbove 1.0 / 0.75 with the within-session spread); amendment ~19:40 ("Szum z 3 sesji main powinniśmy liczyć tak samo jak A/A"): one main session against the others, between-session shift included, plus the PR's run-to-run spread; ctl 19:45: ×1, k never raised to pass; start position: never left out (ctl 22:20, the Pixel 7 no longer counts). Pack v4 replay against simple-4.27 without the Pixel 7: A/A false Worse 1 / 1 of 1070 splits, doses caught Reference night 166 / 166, Reference PR 93 / 93, farm iPhone ms 4863 -> 5012 of 6580 (Worse 3107 -> 3167), places left out 9.8 % -> 0 %. Footnote Pixel 7 (21 splits): A/A Worse 0 -> 4`
+};
 var SHAPE = {
-  id: "simple-4.25+noise95-99",
+  id: "simple-4.28+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" },
@@ -11198,13 +11557,15 @@ var SHAPE = {
     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,
+    ...Object.keys(JOURNEY_RELEASES).length ? { journeyReleases: JOURNEY_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" }),
+    { ...COMMIT_MAX_JUDGED, id: "jank", on: { measure: "jank_ms" }, source: JANK_SOURCE },
+    evidenceRule("commit_max", { measure: "commit_max_ms" }, JUDGED_WINDOWS, [], "W8 option A: the slowest commit is shown, jank time is judged", { devices: ANY_DEVICE }),
+    RENDER_JUDGED,
+    { ...COMPONENT_JUDGED, role: "evidence", source: FELT_SOURCE },
     { ...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"),
@@ -11230,16 +11591,7 @@ var SHAPE = {
     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
-    }
+    MEMORY_RETAINED
   ],
   problems: [
     {
@@ -11281,13 +11633,20 @@ var SHAPE = {
     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)"
   },
+  feltCost: {
+    reads: ["jank", "render"],
+    uncalibrated: false,
+    source: 'Arek 2026-10-27 ~08:00 ("Ok", [ctl-arek-felt-cost]) after giga2-scratch/analysis/2026-10-27-verdict-scale.md option C; B4 replay on the jank pack v3 (676d7453a39c) against simple-4.26: A/A Worse / Slightly worse over 16 pools 2 / 68 -> 1 / 34, doses 52 of 54 (in-screen-mount 1.1x and slow-commit 0.5x lose one case each), golden 10 of 10, corpus 0 moves'
+  },
   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`
+    reads: [COMMIT_MAX_JUDGED, RENDER_JUDGED, COMPONENT_JUDGED, MEMORY_RETAINED],
+    source: `${UNSTABLE_NOISY.source}; Arek 2026-10-26 ("A wygląda kusząco. Oddaj do impl.", ctl-arek-met29-own-step): the step is the place's own work kind's (entry and in-screen mount 10 ms, update 5 ms), the smallest only when the kind is unknown; ctl-arek-jank-time: noisiness still reads the slowest commit, so a place is unstable exactly when it was before jank time was judged`
   }],
+  noisy: NOISY_WIDEN,
   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 },
@@ -11296,7 +11655,8 @@ var SHAPE = {
     { 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 }
+    { aspect: "endGc", affects: MEMORY_MEASURES },
+    CAPTURE_MEASURED_WITH
   ],
   tiers: {
     rel: TIER_REL,
@@ -11320,15 +11680,6 @@ var SHAPE = {
   }
 };
 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`,
@@ -11339,6 +11690,51 @@ var P3_COMMIT = withClauseValues({
   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/flow-version.ts
+import { createHash as createHash2 } from "node:crypto";
+import { dirname as dirname3, relative as relative3, resolve as resolve5, sep as sep2 } from "node:path";
+var REFERENCE = /^\s*(?:-\s*)?(?:runFlow|runScript|file)\s*:\s*['"]?([^'"\s#{}$]+\.(?:ya?ml|js))['"]?\s*$/gm;
+var commonDir = (paths) => {
+  let dir = dirname3(paths[0]);
+  while (!paths.every((p) => p === dir || p.startsWith(dir.endsWith(sep2) ? dir : dir + sep2)))
+    dir = dirname3(dir);
+  return dir;
+};
+async function flowsVersion(files, read, skip = []) {
+  if (files.length === 0)
+    return null;
+  const roots = files.map((f) => resolve5(f));
+  const skipped = new Set(skip.map((s) => resolve5(s)));
+  const seen = new Map;
+  const visit = async (file, root) => {
+    if (seen.has(file) || skipped.has(file))
+      return true;
+    const text = await read(file).then((t) => t.replace(/\r\n?/g, `
+`), () => null);
+    if (text === null)
+      return !root;
+    seen.set(file, text);
+    for (const m of text.matchAll(REFERENCE))
+      await visit(resolve5(dirname3(file), m[1]), false);
+    return true;
+  };
+  for (const r of roots)
+    if (!await visit(r, true))
+      return null;
+  const base = commonDir(roots);
+  const keyed = [...seen].map(([file, text]) => [relative3(base, file).split(sep2).join("/"), text]);
+  const hash = createHash2("sha256");
+  for (const [key, text] of keyed.sort((a, b) => a[0] < b[0] ? -1 : 1))
+    hash.update(key).update("\x00").update(text).update("\x00");
+  return hash.digest("hex").slice(0, 12);
+}
+async function maestroCliVersion(deps) {
+  const r = await deps.spawner.run("maestro", ["--version"], { timeoutMs: 30000, killAfterMs: 5000 });
+  if (r.code !== 0)
+    return;
+  return /^\s*v?(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)\s*$/m.exec(r.stdout)?.[1];
+}
+
 // apps/agent/src/device-model.ts
 import { tmpdir } from "node:os";
 import { join as join12 } from "node:path";
@@ -11481,6 +11877,19 @@ var maestroLinkFields = (sdkArgs = "") => ({ keepsnappyLinkArgs: linkArgs(sdkArg
 
 // apps/agent/src/farm.ts
 var STATE_VERSION = 1;
+function plantOf(raw) {
+  let v;
+  try {
+    v = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  const ok = (p) => {
+    const x = p;
+    return !!x && typeof x.place === "string" && !!x.place && typeof x.kind === "string" && !!x.kind && typeof x.factor === "number" && Number.isFinite(x.factor) && x.factor > 0 && (x.unit === "budget" || x.unit === "MB");
+  };
+  return Array.isArray(v) && v.length > 0 && v.length <= 200 && v.every(ok) ? v : null;
+}
 var COMPLETION_MARKER = "run:complete";
 var SETUP_FLAGS = [
   ["driver-version", "driver_version"],
@@ -11489,19 +11898,26 @@ var SETUP_FLAGS = [
   ["journey-version", "journey_version"],
   ["flag-set", "flag_set"]
 ];
-function instrumentFlags(f) {
-  if (!f["journey-module"] && f.driver !== "appium")
-    return {};
+var LOCAL_PROVIDERS = ["local", "usb", "customer", "simulator", "emulator"];
+var COMMIT_ID = /^[0-9a-f]{40}$/i;
+function instrumentFlags(f, maestro = {}) {
+  const given = f["journey-version"]?.trim();
+  const named = given && !COMMIT_ID.test(given) ? given : undefined;
+  if (!f["journey-module"] && f.driver !== "appium") {
+    const driver = f["driver-version"] ?? maestro.maestroVersion;
+    const journey = maestro.flowsVersion ?? named;
+    return { ...driver ? { "driver-version": driver } : {}, ...journey ? { "journey-version": journey } : {} };
+  }
   let hash;
   if (f["journey-module"]) {
     try {
-      hash = journeyVersion(resolve5(f["journey-module"]));
+      hash = journeyVersion(resolve6(f["journey-module"]));
     } catch {
       hash = undefined;
     }
   }
   const driver = f["driver-version"] ?? driverVersion() ?? undefined;
-  const journey = f["journey-version"] ?? hash;
+  const journey = hash ?? named;
   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";
@@ -11562,7 +11978,8 @@ async function farmJourneys(deps, f, rt, journeys) {
       if (!byName.has(j))
         rt.print(`journey ${j}: no flow file named ${j}.yaml in --config/--flows; sent without a title`);
   }
-  return journeysFor(journeys.map((j) => ({ name: j, ...byName.get(j) ?? {} })), { readFile: (p) => deps.fs.readFile(p), root: files.length ? await repoRoot(deps) : null });
+  const info = await journeysFor(journeys.map((j) => ({ name: j, ...byName.get(j) ?? {} })), { readFile: (p) => deps.fs.readFile(p), root: files.length ? await repoRoot(deps) : null });
+  return { journeys: info, files: files.map((x) => x.file) };
 }
 async function farmOpen(deps, f, rt) {
   const problems = [];
@@ -11579,7 +11996,7 @@ async function farmOpen(deps, f, rt) {
     provider = "simulator";
     model = model ? withSimulatorWord(model) : simulator;
   }
-  if (!model && ["local", "usb", "customer", "simulator", "emulator"].includes(provider)) {
+  if (!model && LOCAL_PROVIDERS.includes(provider)) {
     model = await detectDeviceModel(deps, { platform: f.platform, deviceId: f["device-id"]?.trim() }) ?? undefined;
     if (model)
       rt.print(`device model read from the device: ${model}`);
@@ -11606,18 +12023,29 @@ async function farmOpen(deps, f, rt) {
     problems.push("--tokens-js <path> is required (the file the suite overlay puts at flows/keepsnappy/tokens.js)");
   if (!f.state)
     problems.push("--state <path> is required (read by keepsnappy farm close)");
+  const plant = f.plant === undefined ? undefined : plantOf(f.plant);
+  if (plant === null)
+    problems.push('--plant must be a JSON list of { place, kind, factor > 0, unit: "budget" | "MB" }');
   if (problems.length)
     throw new ConfigError(problems);
-  const statePath = resolve5(f.state);
-  const tokensPath = resolve5(f["tokens-js"]);
+  const statePath = resolve6(f.state);
+  const tokensPath = resolve6(f["tokens-js"]);
   if (await deps.fs.exists(statePath)) {
     throw new ConfigError([`${statePath} already exists: close that run set first (keepsnappy farm close --state ${f.state}) or remove the file`]);
   }
   const api = apiTarget(url, f, rt);
   const now = rt.now ?? Date.now;
   const device = { model, os: f["device-os"] ?? null, provider };
-  const journeyInfo = await farmJourneys(deps, f, rt, journeys);
-  const withInstrument = { ...f, ...instrumentFlags(f) };
+  const { journeys: journeyInfo, files: flowFiles } = await farmJourneys(deps, f, rt, journeys);
+  const { "driver-version": _driver, "journey-version": given, ...rest } = f;
+  const maestro = !f["journey-module"] && f.driver !== "appium";
+  const flows = maestro ? await flowsVersion(flowFiles, (p) => deps.fs.readFile(p), [tokensPath]) : null;
+  const asked = maestro && !f["driver-version"] && LOCAL_PROVIDERS.includes(provider) ? await maestroCliVersion(deps) : undefined;
+  const instrument = instrumentFlags(f, { ...flows ? { flowsVersion: flows } : {}, ...asked ? { maestroVersion: asked } : {} });
+  if (given?.trim() && given.trim() !== instrument["journey-version"]) {
+    rt.print(`--journey-version ${given.trim()} ignored: ${instrument["journey-version"] ? `the journey version is the hash of what runs, ${instrument["journey-version"]}` : "a commit id names the checkout, not the journey; the run records no journey version"}`);
+  }
+  const withInstrument = { ...rest, ...instrument };
   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 });
@@ -11634,7 +12062,13 @@ async function farmOpen(deps, f, rt) {
     journeys: journeyInfo,
     repetitions: repeat,
     source: "farm",
-    ...f["completion-marker"] || Object.keys(setup).length ? { meta: { ...f["completion-marker"] ? { completion_marker: COMPLETION_MARKER } : {}, ...Object.keys(setup).length ? { setup } : {} } } : {}
+    ...f["completion-marker"] || Object.keys(setup).length || plant ? {
+      meta: {
+        ...f["completion-marker"] ? { completion_marker: COMPLETION_MARKER } : {},
+        ...Object.keys(setup).length ? { setup } : {},
+        ...plant ? { plant } : {}
+      }
+    } : {}
   }).catch(infra2(`cannot open a run set at ${api.url}`));
   const prefix = `${git.commit ? git.commit.slice(0, 12) : "farm"}-${rs.run_set_id.slice(0, 8)}`;
   const runs = [];
@@ -11665,7 +12099,7 @@ async function farmOpen(deps, f, rt) {
   if (rt.env.GITHUB_ACTIONS === "true")
     for (const t of Object.values(tokens).flat())
       rt.print(`::add-mask::${t}`);
-  await deps.fs.mkdir(dirname3(tokensPath));
+  await deps.fs.mkdir(dirname4(tokensPath));
   await deps.fs.writeFile(tokensPath, tokensJs(api.url, rs.run_set_id, tokens, maestroLinkFields(f["sdk-args"] ?? "")));
   const state = {
     version: STATE_VERSION,
@@ -11685,7 +12119,7 @@ async function farmOpen(deps, f, rt) {
     closed_at: null,
     result: null
   };
-  await deps.fs.mkdir(dirname3(statePath));
+  await deps.fs.mkdir(dirname4(statePath));
   await deps.fs.writeFile(statePath, `${JSON.stringify(state, null, 2)}
 `);
   await githubOutputs(deps, rt, {
@@ -11791,7 +12225,7 @@ async function farmClose(deps, f, rt) {
     throw new ConfigError(["--state <path> is required (written by keepsnappy farm open)"]);
   if (f["fail-on-worse"] && !f.wait)
     throw new ConfigError(["--fail-on-worse needs --wait"]);
-  const statePath = resolve5(f.state);
+  const statePath = resolve6(f.state);
   let state;
   try {
     state = JSON.parse(await deps.fs.readFile(statePath));
@@ -11818,10 +12252,10 @@ async function closeRunSet(deps, f, rt, state, statePath) {
   const api = apiTarget(f.api ?? f["ingest-url"] ?? state.api, f, rt);
   const now = rt.now ?? Date.now;
   const sleep = rt.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
-  const out = resolve5(f.out ?? dirname3(statePath));
+  const out = resolve6(f.out ?? dirname4(statePath));
   let bsText = null;
   if (f["bs-build"])
-    bsText = await deps.fs.readFile(resolve5(f["bs-build"])).catch(() => null);
+    bsText = await deps.fs.readFile(resolve6(f["bs-build"])).catch(() => null);
   const session = sessionOutcome(bsText);
   const where = `${state.branch}${state.commit ? ` @ ${state.commit.slice(0, 7)}` : ""}`;
   rt.print(`KeepSnappy run set ${state.run_set_id} (${where}): closing`);
@@ -11906,7 +12340,7 @@ async function closeRunSet(deps, f, rt, state, statePath) {
 // apps/agent/src/farm-run.ts
 import { existsSync as existsSync2 } from "node:fs";
 import { createRequire } from "node:module";
-import { dirname as dirname4, join as join16, resolve as resolve6 } from "node:path";
+import { dirname as dirname5, join as join16, resolve as resolve7 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // apps/agent/src/app-source.ts
@@ -12179,10 +12613,10 @@ ${r.stderr}`;
 // apps/agent/src/farm-run.ts
 function appiumDriverEntry(o = {}) {
   const exists = o.exists ?? existsSync2;
-  const bundled = join16(o.selfDir ?? dirname4(fileURLToPath2(import.meta.url)), "appium-driver.js");
+  const bundled = join16(o.selfDir ?? dirname5(fileURLToPath2(import.meta.url)), "appium-driver.js");
   if (exists(bundled))
     return bundled;
-  const pkgDir = dirname4(o.packageJson ? o.packageJson() : createRequire(import.meta.url).resolve("@keepsnappy/appium-driver/package.json"));
+  const pkgDir = dirname5(o.packageJson ? o.packageJson() : createRequire(import.meta.url).resolve("@keepsnappy/appium-driver/package.json"));
   const built = join16(pkgDir, "dist", "src", "cli.js");
   return exists(built) ? built : join16(pkgDir, "src", "cli.ts");
 }
@@ -12281,7 +12715,7 @@ function planFarmRun(f) {
     ports,
     env,
     driverArgs: f["driver-arg"] ?? [],
-    out: resolve6(f.out ?? "farm-run"),
+    out: resolve7(f.out ?? "farm-run"),
     timeoutMinutes,
     killAfterSeconds,
     pollSeconds
@@ -12330,7 +12764,7 @@ async function runDriver2(deps, rt, f, p, ports, ctx) {
       device: p.device,
       app: ctx.app,
       ...f["custom-id"] ? { customId: f["custom-id"] } : {},
-      suiteDir: resolve6(f["suite-dir"]),
+      suiteDir: resolve7(f["suite-dir"]),
       tokensPath: f["tokens-path"] ?? "flows/keepsnappy/tokens.js",
       tokensJs: ctx.tokensJs,
       execute: f.execute,
@@ -12356,7 +12790,7 @@ async function runDriver2(deps, rt, f, p, ports, ctx) {
     throw new Error("no Appium driver entry: pass --driver-script");
   const args = [
     entry,
-    ...f["journey-module"] ? ["--journey-module", resolve6(f["journey-module"])] : [],
+    ...f["journey-module"] ? ["--journey-module", resolve7(f["journey-module"])] : [],
     "--platform",
     p.platform,
     "--device",
@@ -12433,7 +12867,8 @@ async function farmRun(deps, f, rt, ports) {
       driver: p.driver,
       "tokens-js": tokensJs,
       state: statePath,
-      ...commit ? { commit } : {}
+      ...commit ? { commit } : {},
+      ...p.driver !== "appium" && !f["driver-version"] && f["maestro-version"] ? { "driver-version": f["maestro-version"] } : {}
     }, rt);
     if (openCode !== EXIT.ok)
       return openCode;
@@ -12476,15 +12911,15 @@ async function farmRun(deps, f, rt, ports) {
 }
 
 // apps/agent/src/sourcemaps.ts
-import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash3, randomUUID as randomUUID2 } from "node:crypto";
 import { access, readFile as readFile4, readdir as readdir2, rename, rm, writeFile as writeFile2 } from "node:fs/promises";
-import { basename as basename3, join as join17, resolve as resolve7 } from "node:path";
+import { basename as basename3, join as join17, resolve as resolve8 } from "node:path";
 import { parseArgs as parseArgs2 } from "node:util";
 import { gzipSync } from "node:zlib";
 var MAX_COMPLETE_ROUNDS = 20;
 var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 async function prepareComponents(projectRoot, options = {}) {
-  const root = resolve7(projectRoot);
+  const root = resolve8(projectRoot);
   const directory = join17(root, ".keepsnappy", "components");
   const configurations = await readdir2(directory, { withFileTypes: true }).catch((error) => {
     if (error.code === "ENOENT")
@@ -12525,7 +12960,7 @@ async function prepareComponents(projectRoot, options = {}) {
       throw new ConfigError([`invalid KeepSnappy component fragment ${file}`]);
     if (!hashes.has(fragment.source)) {
       try {
-        hashes.set(fragment.source, createHash2("sha256").update(await readFile4(resolve7(root, fragment.source))).digest("hex"));
+        hashes.set(fragment.source, createHash3("sha256").update(await readFile4(resolve8(root, fragment.source))).digest("hex"));
       } catch (error) {
         if (error.code !== "ENOENT")
           throw error;
@@ -12550,7 +12985,7 @@ async function prepareComponents(projectRoot, options = {}) {
     await rm(temporary, { force: true });
   }
   const gzip = gzipSync(text);
-  return { file, count: components.length, bytes: Buffer.byteLength(text), gzip, sha256: createHash2("sha256").update(gzip).digest("hex") };
+  return { file, count: components.length, bytes: Buffer.byteLength(text), gzip, sha256: createHash3("sha256").update(gzip).digest("hex") };
 }
 function stripSourcesContent(map) {
   if (!isObject(map))
@@ -12604,7 +13039,7 @@ async function uploadSourcemaps(opts) {
     const { map, stripped } = stripSourcesContent(parsed);
     const text = Buffer.from(JSON.stringify(map));
     const gz = gzipSync(text);
-    const sha256 = createHash2("sha256").update(gz).digest("hex");
+    const sha256 = createHash3("sha256").update(gz).digest("hex");
     const name = basename3(file);
     const announced = await call(f, opts.url, `/v1/builds/${encodeURIComponent(opts.build)}/sourcemaps`, headers, {
       platform: opts.platform,
@@ -12743,6 +13178,7 @@ import { parseArgs as parseArgs3 } from "node:util";
 var SHORT_SESSIONS = 3;
 var SHORT_POINTS = 5;
 var SHORT_PLACES = 5;
+var SHORT_COMPARE_MEASURES = 3;
 var SHORT_FORM_NOTES = {
   list_findings: "the how-sure lines, the place lines of findings that are not Worse and the lanes that were judged",
   get_finding: "the why, seen and layer lines, the component lines, the memory evidence lines other than the judged measure and the prompt",
@@ -12752,7 +13188,8 @@ var SHORT_FORM_NOTES = {
   place_trend: `the sessions older than the newest ${SHORT_SESSIONS} and the history restarts among them (unknown restarts always stay)`,
   window_history: `the runs older than the newest ${SHORT_POINTS}`,
   pr_status: "the per-journey dashboard links and the heat note",
-  list_problems: `the work and component lines, the dashboard links and the problems after the first ${SHORT_PLACES}`
+  list_problems: `the work and component lines, the dashboard links and the problems after the first ${SHORT_PLACES}`,
+  compare_runs: `the component lines and the measures beyond each place's ${SHORT_COMPARE_MEASURES} times that moved most`
 };
 var andList = (xs) => xs.length < 2 ? xs[0] ?? "" : `${xs.slice(0, -1).join(", ")} and ${xs[xs.length - 1]}`;
 
@@ -12855,10 +13292,11 @@ function measuredLines(l, r, opts) {
   }
   const lane = (x) => {
     const runs = x.runs.after !== null && x.runs.before !== null ? x.branch === l.baseline_branch ? `, ${x.runs.after} latest runs vs ${x.runs.before} earlier` : `, ${x.runs.after} branch runs vs ${x.runs.before} on ${l.baseline_branch}` : "";
-    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)}` : ""}`;
+    return `${x.commit?.sha ? `commit ${x.commit.sha.slice(0, 7)}` : "commit not recorded"} (${when(x.at)}): ${x.word}${feltWords(x)}${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)}; ${plural2(m.run_sets, "run set")} measured.`);
+    r.both(...(n.comparison_notes ?? []).map((line) => `  ${line}`));
     r.full(...(n.session_speed ?? []).map((line) => `  ${line}`));
     r.both(...laneContextLines(n.context, n.journey, n.phone_name, opts.verbose, opts.form === "short"));
     return [];
@@ -12866,9 +13304,10 @@ function measuredLines(l, r, opts) {
   const shown = m.lanes.slice(0, LANES_SHOWN);
   r.add(shown.some((x) => !x.judged || !!x.context), `${scope}: ${plural2(m.run_sets, "run set")} measured; the newest of each journey × phone:`);
   for (const x of shown) {
-    const keep = !x.judged || !!x.context;
+    const keep = !x.judged || !!x.context || !!x.comparison_notes;
     r.add(keep, `  ${x.journey} on ${x.phone_name}${f.branch ? "" : ` (${x.branch})`}: ${lane(x)}`);
     r.add(keep, ...resultContextLines(x.context, opts.verbose, opts.form === "short").map((line) => `    ${line}`));
+    r.add(keep, ...(x.comparison_notes ?? []).map((line) => `    ${line}`));
     r.full(...(x.session_speed ?? []).map((line) => `    ${line}`));
   }
   if (m.lanes.length > shown.length)
@@ -12879,6 +13318,7 @@ function measuredLines(l, r, opts) {
     ...m.lanes.length > shown.length ? [plural2(m.lanes.length - shown.length, "lane") + " beyond the eighth"] : []
   ];
 }
+var feltWords = (x) => `${x.felt_cost ? ` · ${x.felt_cost}` : ""}${x.to_check ? `; ${SUMMARY_WORDS.toCheck(x.to_check)}` : ""}`;
 function countsLine2(l) {
   const c = l.counts;
   const parts = [
@@ -12932,10 +13372,11 @@ function formatBranchStatus(s, opts = {}) {
   if (s.lanes.length)
     r.both("");
   for (const l of s.lanes) {
-    const shown = l.result === "blocks" ? `${l.word} (blocks)` : badgedWord(l.word, l.blocking);
+    const shown = `${l.result === "blocks" ? `${l.word} (blocks)` : badgedWord(l.word, l.blocking)}${l.stale ? ` (${STALE_FLAG})` : ""}`;
     const sha = l.commit?.sha?.slice(0, 7);
-    r.both(`  ${l.journey_title ?? l.journey} on ${l.phone_name}: ${shown} · ${sha ? `commit ${sha}` : "commit not recorded"} (${when(l.at)})${l.in_newest_run_set ? "" : " · older run set"}${l.waiting_for_reprocess ? `; ${waitingWords(l.waiting_for_reprocess)}` : ""}`);
+    r.both(`  ${l.journey_title ?? l.journey} on ${l.phone_name}: ${shown}${feltWords(l)} · ${sha ? `commit ${sha}` : "commit not recorded"} (${when(l.at)})${l.in_newest_run_set ? "" : " · older run set"}${l.waiting_for_reprocess ? `; ${waitingWords(l.waiting_for_reprocess)}` : ""}`);
     r.both(...resultContextLines(l.context, opts.verbose, opts.form === "short"));
+    r.both(...(l.comparison_notes ?? []).map((line) => `    ${line}`));
     r.full(...(l.session_speed ?? []).map((line) => `    ${line}`));
     for (const f of l.worst)
       r.both(`    ${f.id}  ${f.headline}`);
@@ -12945,6 +13386,7 @@ function formatBranchStatus(s, opts = {}) {
       r.full(`    ${l.link}`);
   }
   const links = s.lanes.filter((l) => l.link).length;
+  const staleLanes = s.problems?.stale_lanes ?? 0;
   const heated = s.counts.heat_runs ?? 0;
   const more = [
     [false, heated ? `${INFO_WORDS.heat.toLowerCase()} in ${plural2(heated, "run")} (information, never blocks)` : ""],
@@ -12953,6 +13395,7 @@ function formatBranchStatus(s, opts = {}) {
       s.not_judged_findings ? `${plural2(s.not_judged_findings, "finding")} not judged in the newest run set; they may still be there: keepsnappy findings --branch ${s.branch} --state not-judged` : ""
     ],
     [true, statusProblemsLine(s)],
+    [true, staleLanes ? `${staleWords(staleLanes)}: ${staleLanes === 1 ? "its word and problems are" : "their words and problems are"} of older rules` : ""],
     [true, s.problems?.unread_lanes ? `${unreadWords(s.problems.unread_lanes)} for problems: ${staleResult(s.problems.unread_lanes)}` : ""],
     [true, s.links.overview ? `Dashboard: ${s.links.overview}` : ""],
     [true, s.worst.length ? "One finding with its evidence and a prompt: keepsnappy finding <id> --prompt" : ""]
@@ -12968,9 +13411,11 @@ function statusProblemsLine(s) {
   const p = s.problems;
   if (!p?.count)
     return "";
-  return `${plural2(p.places, "place")} over budget in this branch’s own runs (${p.far_count ? `${p.far_count} far over budget; ` : ""}not a regression, never blocks): list_problems, or keepsnappy problems --branch ${s.branch}`;
+  return `${problemCountsText(p, "this branch’s")}. Not a regression, never blocks: list_problems, or keepsnappy problems --branch ${s.branch}`;
 }
 var unreadWords = (n) => `${n} journey × phone not read`;
+var STALE_FLAG = staleFlagText(["config"]);
+var staleWords = (n) => `${n} journey × phone from a stale result (${STALE_FLAG})`;
 var staleResult = (n) => `${n === 1 ? "its stored result is" : "their stored results are"} not current`;
 function formatProblemList(l, opts = {}) {
   const r = new Rows;
@@ -12987,7 +13432,7 @@ function formatProblemList(l, opts = {}) {
     return r.render(opts.form);
   }
   if (c.count)
-    r.both(`${b}: ${plural2(c.places, "place")} over budget in ${b === l.baseline_branch ? "main’s" : "this branch’s"} own runs${c.far_count ? ` (${c.far_count} far over budget)` : ""}`);
+    r.both(`${b}: ${problemCountsText(c, b === l.baseline_branch ? "main’s" : "this branch’s")}`);
   else if (read)
     r.both(`${b}: no problem over budget in the newest run set (${read} journey × phone read)`);
   else
@@ -12995,13 +13440,15 @@ function formatProblemList(l, opts = {}) {
   r.both(l.note);
   if (read && unread)
     r.both(`${unreadWords(unread)}: ${staleResult(unread)}, so nothing is known about ${unread === 1 ? "its" : "their"} problems.`);
+  if (c.stale_lanes)
+    r.both(`${staleWords(c.stale_lanes)}: ${c.stale_lanes === 1 ? "its" : "their"} problems are listed, each marked “${STALE_MARK}”.`);
   l.problems.forEach((p, i) => {
     const keep = i < SHORT_PLACES;
-    r.add(keep, "", `${l.offset + i + 1}. ${p.text}: ${p.place_name}${opts.verbose ? ` (${p.place})` : ""}${p.intermittent ? ` — ${p.note}, not counted` : ""}`);
-    r.add(keep, `   ${p.journey_title ?? p.journey} on ${p.phone_name}, ${p.runs_text}${p.tag_word ? `, ${p.tag_word}` : ""}`);
+    r.add(keep, "", `${l.offset + i + 1}. ${p.place_name}${opts.verbose ? ` (${p.place})` : ""}: ${p.text}${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}` : ""}${p.stale ? `, ${STALE_MARK}` : ""}`);
     const top = p.top_components[0];
     const topName = componentReadNames(p.top_components)[0];
-    const detail = [p.work, top ? `heaviest ${topName}${opts.verbose && top.key ? ` (${top.key})` : ""} ${top.self_text}` : null, p.new_component ? NEW_IN_PR_CHIP : null, p.range_text ? `${p.range_text} between runs` : null].filter(Boolean);
+    const detail = [p.work, top ? `${namePartsText(heaviestWords(`${topName}${opts.verbose && top.key ? ` (${top.key})` : ""}`, top.self_ms === null ? null : 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)
@@ -13021,56 +13468,59 @@ function formatProblemList(l, opts = {}) {
 }
 var commitText = (c) => !c ? "commit not recorded" : c.title ? `“${c.title}”${c.author ? ` by ${c.author}` : ""}${c.sha ? ` (${c.sha.slice(0, 7)})` : ""}` : c.sha ? c.sha.slice(0, 7) : "commit not recorded";
 function formatCompare(r, opts = {}) {
-  const out = [
-    `Run A: ${r.a.external_id} on ${r.a.branch ?? "?"}, ${commitText(r.a.commit ? { sha: r.a.commit_sha, ...r.a.commit } : { sha: r.a.commit_sha, title: null, author: null })}`,
-    `Run B: ${r.b.external_id} on ${r.b.branch ?? "?"}, ${commitText(r.b.commit ? { sha: r.b.commit_sha, ...r.b.commit } : { sha: r.b.commit_sha, title: null, author: null })}`,
-    `${r.same_journey ? "Same journey" : "Different journeys"}, ${r.same_phone ? "same phone" : "different phones"}. ${r.note}`
-  ];
+  const rows = new Rows;
+  rows.both(`Run A: ${r.a.external_id} on ${r.a.branch ?? "?"}, ${commitText(r.a.commit ? { sha: r.a.commit_sha, ...r.a.commit } : { sha: r.a.commit_sha, title: null, author: null })}`, `Run B: ${r.b.external_id} on ${r.b.branch ?? "?"}, ${commitText(r.b.commit ? { sha: r.b.commit_sha, ...r.b.commit } : { sha: r.b.commit_sha, title: null, author: null })}`, `${r.same_journey ? "Same journey" : "Different journeys"}, ${r.same_phone ? "same phone" : "different phones"}. ${r.note}`);
   if (r.setup_differs.length)
-    out.push(`Measured differently: ${r.setup_differs.map((d) => `${d.field} ${JSON.stringify(d.a)} → ${JSON.stringify(d.b)}`).join(", ")}`);
+    rows.both(`Measured differently: ${r.setup_differs.map((d) => `${d.field} ${JSON.stringify(d.a)} → ${JSON.stringify(d.b)}`).join(", ")}`);
   for (const w of r.windows) {
     const ms = w.metrics.filter((m) => m.a !== null || m.b !== null);
     const c = w.component_page ?? w.components;
     if (!ms.length && !c)
       continue;
-    out.push("", `${w.window_name}${opts.verbose ? ` (${w.window})` : ""}`);
+    rows.both("", `${w.window_name}${opts.verbose ? ` (${w.window})` : ""}`);
     const singles = [...c?.added ?? [], ...c?.removed ?? [], ...w.component_page?.uncompared?.a ?? [], ...w.component_page?.uncompared?.b ?? []];
     const components = [...c?.rows ?? [], ...singles];
     const names = componentReadNames(components.map((row) => ({ key: row.key, name: row.component })));
     const shown = new Map(components.map((row, i) => [row.key, names[i]]));
     for (const row of c?.rows ?? [])
-      out.push(`  ${shown.get(row.key)}: ${row.self_ms_a === null ? "–" : exactComponentMs(row.self_ms_a)} → ${row.self_ms_b === null ? "–" : exactComponentMs(row.self_ms_b)}${opts.verbose ? ` (${row.key})` : ""}`);
-    for (const [label, rows] of [
+      rows.full(`  ${shown.get(row.key)}: ${row.self_ms_a === null ? "–" : exactComponentMs(row.self_ms_a)} → ${row.self_ms_b === null ? "–" : exactComponentMs(row.self_ms_b)}${opts.verbose ? ` (${row.key})` : ""}`);
+    for (const [label, list] of [
       [READ_WORDS.onlyB, c?.added ?? []],
       [READ_WORDS.onlyA, c?.removed ?? []]
     ]) {
-      for (const row of rows)
-        out.push(`  ${shown.get(row.key)}: ${label}; ${row.self_ms === null ? "–" : exactComponentMs(row.self_ms)}${opts.verbose ? ` (${row.key})` : ""}`);
+      for (const row of list)
+        rows.full(`  ${shown.get(row.key)}: ${label}; ${row.self_ms === null ? "–" : exactComponentMs(row.self_ms)}${opts.verbose ? ` (${row.key})` : ""}`);
     }
     const page = w.component_page;
     if (page) {
       for (const side of ["a", "b"]) {
         if (!page.measured[side])
-          out.push(`  ${notMeasuredText(side)}`);
+          rows.full(`  ${notMeasuredText(side)}`);
         for (const row of page.uncompared?.[side] ?? [])
-          out.push(`  ${shown.get(row.key)}: ${side === "a" ? READ_WORDS.runA : READ_WORDS.runB} ${row.self_ms === null ? "–" : exactComponentMs(row.self_ms)}${opts.verbose ? ` (${row.key})` : ""}`);
+          rows.full(`  ${shown.get(row.key)}: ${side === "a" ? READ_WORDS.runA : READ_WORDS.runB} ${row.self_ms === null ? "–" : exactComponentMs(row.self_ms)}${opts.verbose ? ` (${row.key})` : ""}`);
       }
-      out.push(`  ${componentPageText(page.page, components.length)}`);
+      rows.full(`  ${componentPageText(page.page, components.length)}`);
     } else if (c?.totals)
-      out.push(`  ${componentListsText(c.totals, { rows: c.rows.length, added: c.added?.length ?? 0, removed: c.removed?.length ?? 0 })}`);
+      rows.full(`  ${componentListsText(c.totals, { rows: c.rows.length, added: c.added?.length ?? 0, removed: c.removed?.length ?? 0 })}`);
     if (c?.omissions)
       for (const side of ["a", "b"]) {
         if (page && !page.measured[side])
           continue;
         const o = c.omissions[side];
         if (o.sdkOmitted === null || o.omitted === null || o.sdkOmitted > 0 || o.omitted > 0)
-          out.push(`  ${omissionText({ run_id: side === "a" ? READ_WORDS.runA : READ_WORDS.runB, ...o })}`);
+          rows.full(`  ${omissionText({ run_id: side === "a" ? READ_WORDS.runA : READ_WORDS.runB, ...o })}`);
       }
+    const top = new Set(ms.map((m) => ({ m, by: timeMove(m.metric, m.a, m.b) })).filter((x) => x.by !== null && x.by > 0).sort((x, y) => y.by - x.by).slice(0, SHORT_COMPARE_MEASURES).map((x) => x.m));
     for (const m of ms)
-      out.push(`  ${m.label.padEnd(28)}${m.a_text.padStart(10)} → ${m.b_text}`);
+      rows.add(top.has(m), `  ${m.label.padEnd(28)}${m.a_text.padStart(10)} → ${m.b_text}`);
   }
-  return out.join(`
-`);
+  const p = r.windows_page;
+  if (p) {
+    const order = p.order === "moved" ? ", the ones whose time moved most first" : "";
+    const shownText = r.windows.length ? `Showing places ${p.offset + 1}–${p.offset + r.windows.length} of ${p.total}${order}` : `Showing none of ${p.total} places`;
+    rows.both("", p.next_offset !== null ? `${shownText}; the rest from offset ${p.next_offset} (--offset ${p.next_offset}).` : `${shownText}.`);
+  }
+  return rows.render(opts.form, ["the component lines", `the measures beyond each place's ${SHORT_COMPARE_MEASURES} times that moved most`]);
 }
 function formatHistory(h, opts = {}) {
   const r = new Rows;
@@ -13102,8 +13552,8 @@ function formatHistory(h, opts = {}) {
 }
 function formatCommits(c) {
   return [
-    `${plural2(c.commits.length, "measured commit")} (${plural2(c.sessions, "session")}) on ${c.branch}, oldest first:`,
-    ...c.commits.map((x) => `  ${when(x.first_measured_at)}  ${commitText(x)}${x.pull_request?.number ? `, PR #${x.pull_request.number}` : ""}${x.sessions > 1 ? `; ${x.sessions} sessions, the last ${when(x.last_measured_at)}` : ""}`),
+    `${plural2(c.commits.length, "measured commit")} (${plural2(c.sessions, "session")}) ${c.from_branch ? `from ${c.from_branch} to ${c.branch}` : `on ${c.branch}`}, oldest first:`,
+    ...c.commits.map((x) => `  ${when(x.first_measured_at)}  ${commitText(x)}${c.from_branch && x.branch ? ` on ${x.branch}` : ""}${x.pull_request?.number ? `, PR #${x.pull_request.number}` : ""}${x.sessions > 1 ? `; ${x.sessions} sessions, the last ${when(x.last_measured_at)}` : ""}`),
     c.note
   ].join(`
 `);
@@ -13139,7 +13589,7 @@ function formatSessionPlaces(p, opts = {}) {
     return r.both("Stale: its statistics are of another derivation or stats version and are not served until the next recompute rewrites them; nothing is known about its places (not zero).").render(opts.form);
   const by = p.filters.measure;
   const byLabel = p.places.flatMap((x) => x.measures).find((m) => m.measure === by)?.label ?? by;
-  r.both(`Stored per-session statistics: no verdict, no comparison. Places by ${byLabel} (${p.filters.sort}), highest first${p.filters.window ? `, matching “${p.filters.window}”` : ""}${p.without_measure ? `; ${p.without_measure} of ${p.total} places ${p.without_measure === 1 ? "has" : "have"} no value for it` : ""}.`, "");
+  r.both(`Stored per-session statistics: no verdict, no comparison. Places by ${byLabel} (${p.filters.sort}), highest first${p.filters.window ? `, matching “${p.filters.window}”` : ""}${p.without_measure ? `; ${p.without_measure} of ${p.total} places ${p.without_measure === 1 ? "has" : "have"} no value for it` : ""}${p.folded_twins ? `; ${foldedTwinsText(p.folded_twins)}` : ""}.`, "");
   let componentLines = 0;
   p.places.forEach((place, i) => {
     const m = place.measures.find((x) => x.measure === by);
@@ -13212,7 +13662,7 @@ function formatMainSessions(h, opts = {}) {
     if (!s.places)
       r.add(k, `  ${MAIN_SUMMARY_PENDING}${s.summary_reason ? ` (${s.summary_reason})` : ""}`);
     else
-      r.add(k, `  ${MAIN_TIERS_WORST_FIRST.map((tier) => `${MAIN_TIER_WORDS[tier]}: ${s.places[tier]}`).join("; ")}${s.cant_reason ? `; ${mainSessionCantWords(s.places.cant, s.cant_reason, baseline)}` : ""}`);
+      r.add(k, `  ${MAIN_TIERS_WORST_FIRST.map((tier) => `${MAIN_TIER_WORDS[tier]}: ${s.places[tier]}`).join("; ")}${s.cant_reason ? `; ${mainSessionCantWords(s.places.cant, s.cant_reason, baseline)}` : s.cant_range ? `; ${mainSessionCantRangeWords(s.places.cant, s.cant_range, baseline)}` : ""}`);
     if (s.waiting_sessions)
       r.add(k, `  ${waitingSessionsWords(s.waiting_sessions)}`);
     if (s.memory)
@@ -13254,9 +13704,13 @@ function formatMainSessionPlaces(p, opts = {}) {
     return r.both(`${MAIN_SUMMARY_PENDING}${p.summary_reason ? ` (${p.summary_reason})` : ""}`).render(opts.form);
   const baselineSessions = p.baseline_sessions;
   r.both(`Main session places: tiers are verdicts vs ${p.baseline_sessions === undefined ? "earlier sessions" : `the ${p.baseline_sessions} sessions before`}.`);
-  for (const x of p.places)
-    r.add(x.tier !== "same", `  ${windowQualified(x.place)}${opts.verbose ? ` (${x.place}; ${x.ref})` : ""} ${storedRefWords(x.ref, p.places.filter((row) => row.place === x.place).map((row) => row.ref))}: ${MAIN_TIER_WORDS[x.tier]}${x.reason ? `; ${mainPlaceReasonWords(x.reason, { baseline: { sessions: baselineSessions } })}` : ""}${x.reason && mainUnstableWords(x.reason) ? `. ${mainUnstableWords(x.reason)}` : ""}`);
-  const inNorm = p.places.filter((x) => x.tier === "same").length;
+  const kept = new Set(foldTwins([...p.places].sort((a, b) => MAIN_TIER_RANK[a.tier] - MAIN_TIER_RANK[b.tier]), (x) => x.place, (x) => x.ref).rows);
+  const places = p.places.filter((x) => kept.has(x));
+  for (const x of places)
+    r.add(x.tier !== "same", `  ${windowQualified(x.place)}${opts.verbose ? ` (${x.place}; ${x.ref})` : ""} ${storedRefWords(x.ref, places.filter((row) => row.place === x.place).map((row) => row.ref))}: ${MAIN_TIER_WORDS[x.tier]}${x.reason ? `; ${mainPlaceReasonWords(x.reason, { baseline: { sessions: baselineSessions } })}` : ""}${x.reason && mainUnstableWords(x.reason) ? `. ${mainUnstableWords(x.reason)}` : ""}`);
+  if (places.length < p.places.length)
+    r.both(`  ${foldedTwinsText(p.places.length - places.length)}`);
+  const inNorm = places.filter((x) => x.tier === "same").length;
   return r.render(opts.form, inNorm ? [plural2(inNorm, "place") + " in norm"] : []);
 }
 var signed = (n) => `${n > 0 ? "+" : ""}${Number(n.toFixed(3))}`;
@@ -13295,6 +13749,12 @@ function renamedLines(renamed, places) {
     ...component ? [`  ${componentNotJoinedText(renamed.sdk)}`] : []
   ];
 }
+function storedValueText(ref, v, unit) {
+  const rest = ref.slice(2);
+  const field = ref.startsWith("b:") ? `${rest.slice(0, rest.lastIndexOf(":"))}.${rest.slice(rest.lastIndexOf(":") + 1)}` : rest;
+  const text = fieldValueText(field, v);
+  return unit && !/[^\d.,\s-]/.test(text) ? `${text} ${unit}` : text;
+}
 function formatPlaceTrend(t, opts = {}) {
   const r = new Rows().both(`${t.journey} · ${t.phone.model} · ${t.baseline_branch}: stored per-session statistics`);
   const newest = new Set(t.sessions.slice(-SHORT_SESSIONS).map((s) => s.run_set_id));
@@ -13315,10 +13775,10 @@ function formatPlaceTrend(t, opts = {}) {
       const value = place.sessions.find((s) => s.run_set_id === session.run_set_id);
       if (!value)
         continue;
-      const unit = place.unit ? ` ${place.unit}` : "";
+      const value_ = (v) => storedValueText(place.ref, v, place.unit);
       if (!k)
         olderSessions.add(session.run_set_id);
-      r.add(k, `${session.completed_at?.slice(0, 10) ?? "date unknown"} ${session.commit.sha?.slice(0, 7) ?? "commit unknown"} · ${windowQualified(place.window)}${opts.verbose ? ` (${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}`);
+      r.add(k, `${session.completed_at?.slice(0, 10) ?? "date unknown"} ${session.commit.sha?.slice(0, 7) ?? "commit unknown"} · ${windowQualified(place.window)}${opts.verbose ? ` (${value.window ?? place.window}; ${place.ref})` : ""} · ${place.label} (${storedRefWords(place.ref, t.places.filter((row) => row.window === place.window).map((row) => row.ref))}): median ${value_(value.median)}, MAD ${value_(value.mad)}, n=${value.n}`);
     }
   }
   if (!t.sessions.length)
@@ -13375,6 +13835,8 @@ var branchStatus = (t, branch) => get(t, "v1/branches/status", { branch });
 var listProblems = (t, f = {}) => get(t, "v1/problems", { branch: f.branch, main: f.main ? "true" : undefined, journey: f.journey, phone: f.phone, limit: f.limit, offset: f.offset || undefined });
 var getFinding = (t, id) => get(t, `v1/findings/${encodeURIComponent(id)}`);
 var compareRuns = (t, a, b, page = {}) => get(t, "v1/compare", { a, b, ...page });
+var SHORT_COMPARE_PLACES = 10;
+var compareQuery = (short, page) => short ? { order: "moved", limit: SHORT_COMPARE_PLACES, ...page } : page;
 var windowHistory = (t, q) => get(t, "v1/history", q);
 var commitsBetween = (t, q) => get(t, "v1/commits", q);
 var layers = (t) => get(t, "v1/layers");
@@ -13409,7 +13871,7 @@ var FINDINGS_USAGE = `keepsnappy findings [--branch NAME | --main] [--journey KE
   problems --branch NAME | --main [--journey KEY] [--phone MODEL] [--limit N] [--offset N] [--short] [--json]
            (the single problems "Over budget" / "Far over budget" in the branch's own runs, whatever main does: not a regression, never blocking)
   finding  <id> [--prompt] [--short] [--json]                      (--prompt: only the hand-off for a coding agent; with --json the whole finding)
-  compare  <runA> <runB> [--json]                                  (run ids or external ids; one run against one, no statistics)
+  compare  <runA> <runB> [--short] [--limit N] [--offset N] [--json] (run ids or external ids; one run against one, no statistics; --short: the places whose time moved most)
   history  <journey> <window> [--phone MODEL] [--short] [--json]   (exact window id, e.g. "press:live.chat.send")
   commits  <from> [<to>] [--branch NAME] [--json]                  (measured commits between two run sets or commit hashes)
   places   [--run-set ID | --journey KEY [--phone MODEL] [--branch NAME]] [--measure ID] [--sort median|p90|mad] [--window TEXT] [--limit N] [--offset N] [--top-components N] [--short] [--json]
@@ -13425,7 +13887,7 @@ ${READ_USAGE.detailFlag}
   --short  (findings, status, problems, finding, history, places, main, trend: what decides, without the evidence detail; the same as the MCP tools' form short; --json is unchanged)
   (key: KEEPSNAPPY_KEY or --key-env NAME; API: --api URL or KEEPSNAPPY_API)`;
 var STATES = ["present", "not-judged", "resolved", "all"];
-var SHORT_COMMANDS = new Set(["findings", "status", "problems", "finding", "history", "places", "main", "trend"]);
+var SHORT_COMMANDS = new Set(["findings", "status", "problems", "finding", "compare", "history", "places", "main", "trend"]);
 var FINDINGS_COMMANDS = new Set(["findings", "status", "problems", "finding", "compare", "history", "commits", "places", "layers", "main", "trend"]);
 async function findingsCommand(cmd, argv, rt) {
   const args = (() => {
@@ -13564,7 +14026,8 @@ async function findingsCommand(cmd, argv, rt) {
       const size = o["top-components"] === undefined ? 12 : Number(o["top-components"]);
       if (!Number.isInteger(size) || size < 1 || size > 200)
         throw new UsageError([READ_USAGE.compareTop]);
-      const query = page || o.all || o["top-components"] !== undefined ? { component_offset: ((page ?? 1) - 1) * size, component_limit: size } : {};
+      const components = page || o.all || o["top-components"] !== undefined ? { component_offset: ((page ?? 1) - 1) * size, component_limit: size } : {};
+      const query = compareQuery(o.short === true, { ...components, ...limit ? { limit } : {}, ...offset !== undefined ? { offset } : {} });
       const compared = await compareRuns(t, p[0], p[1], query);
       return out(o.all ? await allCompare(t, compared, size) : compared, formatCompare);
     }
@@ -13728,6 +14191,7 @@ var USAGE = `keepsnappy <command>
              [--config keepsnappy.yml] [--flows <files|dirs|globs,...>]   (journey titles: keepsnappy.yml flows.paths, else the flow's name: / top comment)
              [--completion-marker] (the flow posts step run:complete at the end of each iteration; runs without it are invalid)
              [--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)
+             [--plant JSON] (what the build plants against main, [{ place, kind, factor, unit: budget|MB }]: the run set's meta.plant)
              [--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)
@@ -13823,6 +14287,7 @@ async function main2(argv) {
           "harness-version": { type: "string" },
           "journey-version": { type: "string" },
           "flag-set": { type: "string" },
+          plant: { type: "string" },
           app: { type: "string" },
           driver: { type: "string" },
           "tunnel-for": { type: "string", multiple: true },
@@ -13873,9 +14338,9 @@ async function main2(argv) {
     if (platform === "ios-device" && !o.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 out = resolve9(o.out ?? `keepsnappy-${new Date().toISOString().replace(/[:.]/g, "-")}`);
     const udid = o.device ?? "booted";
-    const source = platform === "ios-sim" ? new IosSimulatorDataSource(deps, udid) : new IosDeviceDataSource(deps, udid, resolve8(out, ".scratch"));
+    const source = platform === "ios-sim" ? new IosSimulatorDataSource(deps, udid) : new IosDeviceDataSource(deps, udid, resolve9(out, ".scratch"));
     const installer = platform === "ios-sim" ? new IosSimulatorInstaller(deps, udid) : new IosDeviceInstaller(deps, udid);
     const bundleId = await bundleIdOf(deps, arms[0]?.target, o["bundle-id"]);
     let markers;
@@ -13894,7 +14359,7 @@ async function main2(argv) {
       outDir: out,
       testCommand: positionals,
       bundleId,
-      ...o["ri-capture"] ? { ri: new FileRiSource(deps, resolve8(o["ri-capture"])) } : {},
+      ...o["ri-capture"] ? { ri: new FileRiSource(deps, resolve9(o["ri-capture"])) } : {},
       ...o["mem-window"] ? { memWindow: o["mem-window"] } : {},
       ...o.timeout ? { testTimeoutMs: Number(o.timeout) * 1000 } : {}
     });
@@ -13906,9 +14371,9 @@ async function main2(argv) {
     const dir = positionals[0];
     if (!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")}`);
+    const ri = o["ri-capture"] ? new FileRiSource(deps, resolve9(o["ri-capture"])) : undefined;
+    const rows = await extract(deps, resolve9(dir), ri, o["mem-window"], o["clock-offset-ms"] ? Number(o["clock-offset-ms"]) : undefined);
+    console.log(`${rows.length} rows -> ${resolve9(dir, "metrics.csv")}`);
     return 0;
   }
   if (cmd === "aa") {
@@ -13916,7 +14381,7 @@ async function main2(argv) {
     if (!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);
+    console.log((await aa(deps, resolve9(dir), { config })).table);
     return 0;
   }
   console.error(USAGE);