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

package/README.md

@@ -70,7 +70,7 @@ Annotated example: `examples/keepsnappy.yml`. Every setting:
 
 Unknown settings and wrong types are errors, all listed together.
 
-Results and exit codes: results never change the exit code by default (ruling D9, no blocking PR checks): `0` also for "More work". `--fail-on-worse` (needs `--wait`) fails the job (exit `3`) only when the verdict computed on that run set is Worse and blocking. Closing a run set never computes its verdict (decision 0031: the operator computes verdicts on demand), so with no computed verdict `--fail-on-worse` checks nothing: the CLI prints `Verdict not computed yet (computed on demand): --fail-on-worse checked nothing` and exits `0`. The CLI exits `2` for a configuration problem (bad or missing `keepsnappy.yml`, unknown or misspelt flags, a glob matching nothing, `--wait` without a branch or key) and `1` for an infrastructure problem (cannot read the device log, an API request failing, an API URL that does not answer as the KeepSnappy API, `--upload` that sent no run: "Blocked"; results stay in the out dir). Failed runs are marked invalid in `runs.ndjson` / `metrics.csv` and ignored by the statistics. The ending summary reads like:
+Results and exit codes: results never change the exit code by default (ruling D9, no blocking PR checks): `0` also for "More work". `--fail-on-worse` (needs `--wait`) fails the job (exit `3`) only when the verdict computed on that run set is Worse and blocking. Closing a run set never computes its verdict (decision 0031: the operator computes verdicts on demand), so with no computed verdict `--fail-on-worse` checks nothing: the CLI prints `Verdict not computed yet (computed on demand): --fail-on-worse checked nothing` and exits `0`. The CLI exits `2` for a configuration problem (bad or missing `keepsnappy.yml`, unknown or misspelt flags, a glob matching nothing, `--wait` without a branch or key) and `1` for an infrastructure problem (cannot read the device log, an API request failing, an API URL that does not answer as the KeepSnappy API, `--upload` that sent no run: "Blocked", or a local run with no valid run; results stay in the out dir). For a local run with no valid run, it prints `No valid run was recorded` with the invalid reasons when known. Failed runs are marked invalid in `runs.ndjson` / `metrics.csv` and ignored by the statistics. The ending summary reads like:
 
 ```
 7/8 runs valid (dropped: 1 test-failed: exit 1)

package/dist/appium-driver.js

@@ -507,23 +507,29 @@ class Driver {
     });
     await this.cmd("DELETE", "/actions").catch(() => null);
   }
-  async drag(from, to, durationMs) {
+  async drag(from, to, durationMs, note) {
     to = { x: to.x, y: Math.min(to.y, await this.safeBottomY()) };
-    await this.cmd("POST", "/actions", {
-      actions: [
-        {
-          type: "pointer",
-          id: "finger1",
-          parameters: { pointerType: "touch" },
-          actions: [
-            { type: "pointerMove", duration: 0, x: from.x, y: from.y },
-            { type: "pointerDown", button: 0 },
-            { type: "pointerMove", duration: durationMs, x: to.x, y: to.y },
-            { type: "pointerUp", button: 0 }
-          ]
-        }
-      ]
-    });
+    const logged = this.log.length;
+    try {
+      await this.cmd("POST", "/actions", {
+        actions: [
+          {
+            type: "pointer",
+            id: "finger1",
+            parameters: { pointerType: "touch" },
+            actions: [
+              { type: "pointerMove", duration: 0, x: from.x, y: from.y },
+              { type: "pointerDown", button: 0 },
+              { type: "pointerMove", duration: durationMs, x: to.x, y: to.y },
+              { type: "pointerUp", button: 0 }
+            ]
+          }
+        ]
+      });
+    } finally {
+      if (note && this.log[logged])
+        Object.assign(this.log[logged], note);
+    }
     await this.cmd("DELETE", "/actions").catch(() => null);
   }
   async relaunch(bundleId = this.bundleId) {
@@ -726,7 +732,7 @@ import { dirname, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 var DRIVER_NAME = "appium";
 function driverVersion() {
-  const built = "0.1.0-alpha.18";
+  const built = "0.1.0-alpha.19";
   if (built)
     return built;
   let dir = dirname(fileURLToPath(import.meta.url));

package/dist/keepsnappy.js

@@ -1953,6 +1953,16 @@ var MEASURES = {
     decimals: 1,
     what: "The part of the slowest screen update that React spent outside every component's own render, in its own bookkeeping"
   },
+  jank_ms: {
+    unit: "ms",
+    worse: "higher",
+    at: ["screen", "launch", "press", "drag", "step", "other", "background"],
+    producer: "tracesift",
+    label: "Jank time",
+    short: "jank time",
+    decimals: 1,
+    what: "The time the window's screen updates spent past one 60 Hz frame, added up, read from the full React export"
+  },
   commits_over_2_frames: {
     unit: "count",
     worse: "higher",
@@ -5203,6 +5213,7 @@ 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/placeWords.js
 var GENERIC_GROUPS = new Set(["app", "tabs", "root"]);
@@ -5247,6 +5258,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 +5322,13 @@ function fieldValueText(field, v) {
   const def = fieldDef(field.split(KEY_SEPARATOR)[0]);
   return format(def?.unit, def?.decimals ?? FALLBACK_DECIMALS, v);
 }
+function timeMove(field, a, b) {
+  if (a === null || b === null || !(a > 0))
+    return null;
+  const breakdown = breakdownMeasure(field);
+  const unit = breakdown ? BREAKDOWN_MEASURES[breakdown].unit : fieldDef(field.split(KEY_SEPARATOR)[0])?.unit;
+  return unit === "ms" ? Math.abs(b - a) / a : null;
+}
 
 // packages/present/dist/src/rowWords.js
 var GONE_TAILS = {
@@ -5364,9 +5383,6 @@ function leadBody(subject, measure, main, pr) {
 var screenLeadText = (tier, subject, measure, main, pr) => `${STATE_WORDS[TIER_STATE[tier]]}: ${leadBody(subject, measure, main, pr)}`;
 var FOR_INFORMATION = "For information";
 var informationLeadText = (subject, measure, main, pr) => `${FOR_INFORMATION}: ${leadBody(subject, measure, main, pr)}`;
-function foldedText(n, rows, page) {
-  return `${n} ${GONE_TAILS[page][rows === "components" ? "removed" : "notInRun"]}`;
-}
 function placeShownName(p, o = {}) {
   const target = p.target ? componentShownName(p.target.name, p.target.file) : libraryViewName(p.kind, p.host ?? "");
   const named = p.target && p.parent ? `${target} in ${componentShownName(p.parent.name, p.parent.file)}${p.k ? `, ${ordinal(p.k)}` : ""}` : target;
@@ -5427,6 +5443,19 @@ var placeOpenWord = (id) => {
   const open = placeOpen(id);
   return open ? OPEN_WORDS[open] : null;
 };
+var TWIN2 = /\+3s$/;
+function foldTwins(rows, placeOf, also = () => "") {
+  const seen = new Set;
+  const out = rows.filter((r) => {
+    const key = `${placeOf(r).replace(TWIN2, "")}\x00${also(r)}`;
+    if (seen.has(key))
+      return false;
+    seen.add(key);
+    return true;
+  });
+  return { rows: out, folded: rows.length - out.length };
+}
+var foldedTwinsText = (n) => `${n} “${PLACE_KIND_WORDS.after3s}” ${n === 1 ? "twin" : "twins"} folded into ${n === 1 ? "its place" : "their places"}`;
 function placeIdShownName(id, o = {}) {
   const p = placeParts(id);
   if (!p)
@@ -5513,6 +5542,42 @@ function shortestPaths(files) {
   }
   return out;
 }
+// packages/present/dist/src/problems.js
+var FAR_OVER_BUDGET_WORD = "Far over budget";
+var PROBLEM_TAG_WORDS = { new: NEW_IN_PR_CHIP, main: "Also on main", none: NOT_COMPARED_WORD };
+var PROBLEM_TAG_LINE_WORDS = { new: "new in this PR", main: "also on main", none: "not compared with main" };
+var problems = (n) => `${n.toLocaleString("en-US")} ${n === 1 ? "problem" : "problems"}`;
+var places = (n) => `${n.toLocaleString("en-US")} ${n === 1 ? "place" : "places"}`;
+function problemCountsText(c, own) {
+  const tags = c.tags;
+  const split = tags ? `: ${[`${tags.new} ${PROBLEM_TAG_LINE_WORDS.new}`, ...["main", "none"].filter((t) => tags[t]).map((t) => `${tags[t]} ${PROBLEM_TAG_LINE_WORDS[t]}`)].join(", ")}` : "";
+  return `${problems(c.count)} at ${places(c.places)} in ${own} own runs${split}${c.far_count ? `; ${c.far_count} of them ${FAR_OVER_BUDGET_WORD.toLowerCase()}` : ""}`;
+}
+var newProblems = (n) => `${n.toLocaleString("en-US")} new ${n === 1 ? "problem" : "problems"}`;
+var PROBLEMS_BLOCK_WORDS = {
+  branch: {
+    heading: "New problems in this branch",
+    sub: "too slow on their own, whatever main does; they don’t block the merge",
+    seeAll: (n) => `See all ${newProblems(n)}`,
+    alsoLine: (n) => `${problems(n)} also on main`,
+    notComparedLine: (n) => `${problems(n)} not compared with main`,
+    choices: { new: PROBLEM_TAG_WORDS.new, also: PROBLEM_TAG_WORDS.main, not_compared: PROBLEM_TAG_WORDS.none },
+    panelTitle: "Problems in this branch",
+    panelNote: "Each one is too slow in this branch’s own runs, whatever main does. Problems never block.",
+    filter: "Which problems"
+  },
+  main: {
+    heading: "New problems in this session",
+    sub: "too slow on their own, whatever earlier sessions did",
+    seeAll: (n) => `See all ${newProblems(n)}`,
+    alsoLine: (n) => `${problems(n)} also in earlier sessions`,
+    notComparedLine: (n) => `${problems(n)} not compared with earlier sessions`,
+    choices: { new: "New in this session", also: "Also in earlier sessions", not_compared: "Not compared with earlier sessions" },
+    panelTitle: "Problems in this session",
+    panelNote: "Each one is too slow in this session’s own runs, whatever earlier sessions did. Problems never block.",
+    filter: "Which problems"
+  }
+};
 // packages/present/dist/src/stability.js
 var UNSTABLE_WORDS = {
   short: "main varies too much here",
@@ -5619,8 +5684,6 @@ function resultContextLines(c, verbose = false, short = false) {
   for (const [screen, rows] of screens) {
     const line = notInRunRowsText({ screens: rows.filter((p) => p.kind === "screen").length, places: rows.filter((p) => p.kind !== "screen").length }, c.page);
     out.push(`${screen ? `${screen}: ` : ""}${line.lead}${line.rest}`);
-    if (rows.length > 3)
-      out.push(`  ${foldedText(rows.length, "places", c.page)}`);
     if (!short || rows.length <= 3)
       out.push(...rows.map((p) => `  ${windowQualified(p.place)}`));
   }
@@ -5630,8 +5693,6 @@ function resultContextLines(c, verbose = false, short = false) {
   for (const [place, rows] of removed) {
     const line = removedRowsText(rows.length, c.page);
     out.push(`${windowQualified(place)}: ${line.lead}${line.rest}`);
-    if (rows.length > 3)
-      out.push(`  ${foldedText(rows.length, "components", c.page)}`);
     if (!short || rows.length <= 3)
       out.push(...rows.map((r) => `  ${r.ref.kind === "breakdown" ? componentReadName({ key: r.ref.key, name: r.ref.name }) : measureWords(r.ref.measure)}`));
   }
@@ -5706,11 +5767,13 @@ var MAIN_TIER_RESULT_WORDS = {
   worse: STATE_WORDS.worse
 };
 var MAIN_TIER_RANK = { worse: 0, slight: 1, cant: 2, better: 3, same: 4 };
+var earlierWords = (sessions, since, config) => `main has ${sessions}${config.baseline.sessions === undefined ? "" : ` of ${config.baseline.sessions}`} earlier sessions${since ? ` on ${since}` : ""}`;
 function mainCantWords(reason, config) {
   if (!reason)
     return "";
-  return reason.kind === "noisy_main" ? "main’s runs vary too much there" : `main has ${reason.earlier_sessions}${config.baseline.sessions === undefined ? "" : ` of ${config.baseline.sessions}`} earlier sessions${reason.since_label ? ` on ${reason.since_label}` : ""}`;
+  return reason.kind === "noisy_main" ? "main’s runs vary too much there" : earlierWords(String(reason.earlier_sessions), reason.since_label, config);
 }
+var mainCantRangeWords = (r, config) => earlierWords(`${r.min}–${r.max}`, r.since_label, config);
 var waitingSessionsWords = (sessions) => `${sessions} older main ${sessions === 1 ? "session waits" : "sessions wait"} for a reprocess`;
 function mainPlaceReasonWords(reason, config) {
   switch (reason.kind) {
@@ -5740,9 +5803,11 @@ var SHORT_ASPECT_WORDS = {
   driverVersion: "Driver",
   journeyVersion: "Journey"
 };
+var cantAt = (places) => `${STATE_WORDS["cant-tell"]} at ${places} place${places === 1 ? "" : "s"}`;
 function mainSessionCantWords(places, reason, config) {
-  return `${STATE_WORDS["cant-tell"]} at ${places} place${places === 1 ? "" : "s"}: ${mainCantWords(reason, config)}`;
+  return `${cantAt(places)}: ${mainCantWords(reason, config)}`;
 }
+var mainSessionCantRangeWords = (places, r, config) => `${cantAt(places)}: ${mainCantRangeWords(r, config)}`;
 var KIND_PLURAL = {
   screen: "screens",
   press: "taps",
@@ -5768,8 +5833,8 @@ function mainCutWords(v) {
 }
 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 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)}`,
@@ -5777,7 +5842,7 @@ var VERDICT_SECTION_WORDS = {
   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)})`,
+  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`,
@@ -5785,11 +5850,29 @@ var VERDICT_SECTION_WORDS = {
   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`,
+  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" },
@@ -5808,7 +5891,7 @@ var VERDICT_SECTION_WORDS = {
   countsLabel: "Places by result",
   links: {
     openChart: "Open chart",
-    seeAll: (n) => `See all ${places(n)}`,
+    seeAll: (n) => `See all ${places2(n)}`,
     whichPlaces: "Which places",
     whichChanges: "Which changes",
     howToFix: "How to fix",
@@ -5832,9 +5915,19 @@ 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`,
+  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"
   }
@@ -5844,26 +5937,25 @@ 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(" · ");
 };
 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;
@@ -5880,19 +5972,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 +6004,55 @@ 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 lines = [];
+  const basis = compared(l, input.pr, newestSlower);
+  const extra = conditions(l, input.pr).join(", ");
+  const heat = l.heatedRuns ? upper(SUMMARY_WORDS.heated(l.heatedRuns, l.runs)) : null;
+  const tail = [...basis || extra ? [basis ? `${basis}${extra ? `; ${extra}` : ""}` : upper(extra)] : [], ...heat ? [heat] : []];
+  if (l.state === "worse" || l.state === "warning" || l.state === "better") {
+    const seen = new Set;
+    const places = l.changes.filter((c) => {
+      const key = c.key ?? c.place ?? c.measure;
+      return seen.has(key) ? false : (seen.add(key), true);
+    });
+    const room = MAX_LINES - tail.length;
+    const top = places.length > room ? places.slice(0, Math.min(TOP2, room - 1)) : places.slice(0, TOP2);
+    lines.push(...top.map((c) => changeLine(c, l.state)));
+    if (!top.length)
+      lines.push(why(l));
+    const more = l.places - top.length;
+    if (top.length && more > 0)
+      lines.push(SUMMARY_WORDS.morePlaces(more));
+  } else {
+    const fix = l.state === "cant-tell" ? unblock(l, input.pr) : null;
+    lines.push(fix ? SUMMARY_WORDS.unblock(why(l), fix) : why(l));
+  }
+  lines.push(...tail);
+  const label = input.pr ? SUMMARY_WORDS.link.comparison : SUMMARY_WORDS.link.session;
+  return { state: l.state, newestSlower, lead, ...withLines(lines), link: { label, url: (single ? l.url : null) ?? input.url } };
 }
+var withLines = (lines) => ({ lines, detail: lines.join(`
+`) });
 function pendingMessage(branch, url) {
-  return { state: "not-computed", newestSlower: false, lead: `${SUMMARY_WORDS.notComputed} · ${clip(branch, NAME.name)}`, 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 +6127,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 +6140,20 @@ 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
   };
 }
 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) => summaryMessage({ branch: s.branch, pr: isPr(s), lanes: lanesOf(s), url: linkOf(s) ?? s.dashboard_url, app: s.app ?? null, prNumber: s.pull_request?.number ?? null });
 var MESSAGE_COLORS = { error: "#D6334A", warn: "#C47A00", better: "#238359", none: "#7C8492" };
 function messageTone(s) {
   const lanes = s ? lanesOf(s) : [];
-  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 };
@@ -6069,18 +6195,43 @@ function resultSlackPayload(s, o = {}) {
 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 +6243,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 +6253,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 +6390,35 @@ async function createRunSet(t, body) {
     throw new UploadError("POST /v1/run-sets: response has no run_set_id (is the URL the KeepSnappy API?)");
   return { run_set_id: r.run_set_id, dashboard_url: String(r.dashboard_url ?? "") };
 }
+var UNKNOWN_OUTCOME = new Set([0, 502, 503, 504]);
+var CONFIRM_READS = 6;
+var CONFIRM_WAIT_MS = 1e4;
 async function completeRunSet(t, id, verdicts) {
   const path = `/v1/run-sets/${encodeURIComponent(id)}/complete`;
-  const r = await call(t.fetch ?? fetch, t.url, path, keyHeader(t), { verdicts });
+  let r;
+  try {
+    r = await call(t.fetch ?? fetch, t.url, path, keyHeader(t), { verdicts });
+  } catch (e) {
+    const closed = e instanceof UploadError && UNKNOWN_OUTCOME.has(e.status ?? -1) ? await confirmedClose(t, id) : null;
+    if (closed)
+      return closed;
+    throw e;
+  }
   if (!r.run_set_id)
     throw new UploadError(`POST ${path}: response has no run_set_id`);
   return r;
 }
+async function confirmedClose(t, id) {
+  const path = `/v1/run-sets/${encodeURIComponent(id)}`;
+  for (let i = 0;i < CONFIRM_READS; i++) {
+    if (i)
+      await pause(CONFIRM_WAIT_MS);
+    const s = await call(t.fetch ?? fetch, t.url, path, keyHeader(t), undefined, "GET").catch(() => null);
+    if (s?.run_set_id && (s.status === "processed" || s.status === "failed"))
+      return s;
+  }
+  return null;
+}
 async function createIngestRun(t, body) {
   const r = await call(t.fetch ?? fetch, t.url, "/v1/runs", keyHeader(t), body);
   if (!r.run_id || !r.run_token)
@@ -10188,8 +10361,14 @@ ${outcome.summary}`);
   const info = { device, ...git.branch ? { branch: git.branch } : {}, ...git.commit ? { commit: git.commit } : {} };
   await deps.fs.writeFile(join9(out, RUN_INFO), `${JSON.stringify({ ...info, ...runSet ? { run_set_id: runSet.run_set_id } : {} }, null, 2)}
 `);
-  if (!api)
+  if (!api) {
+    if (!runs.some((run) => run.valid)) {
+      const reasons = [...new Set(runs.map((run) => run.invalid_reason).filter(Boolean))];
+      rt.print(`No valid run was recorded: ${runs.length === 0 ? "no runs were attempted" : `${runs.length} ${runs.length === 1 ? "run" : "runs"} invalid${reasons.length ? ` (${reasons.join(", ")})` : ""}`}.`);
+      return EXIT.infra;
+    }
     return EXIT.ok;
+  }
   const up = await uploadRuns(deps, out, runs, {
     ingestUrl: api.url,
     key: api.key,
@@ -10714,7 +10893,7 @@ import { existsSync, readFileSync, statSync } from "node:fs";
 import { dirname as dirname2, join as join11, relative as relative2, resolve as resolve4 } from "node:path";
 import { fileURLToPath } from "node:url";
 function driverVersion() {
-  const built = "0.1.0-alpha.18";
+  const built = "0.1.0-alpha.19";
   if (built)
     return built;
   let dir = dirname2(fileURLToPath(import.meta.url));
@@ -10795,6 +10974,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 +10984,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 +11040,8 @@ var REACT_MEASURES = [
   "self_ms_top",
   "component_ms",
   "dimension:component",
-  "dimension:updater"
+  "dimension:updater",
+  "jank_ms"
 ];
 var WINDOW_MODEL_AFFECTS = [
   "commits",
@@ -10882,7 +11066,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 = [
@@ -11048,6 +11233,16 @@ 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)."
   }
 ];
 var UNSTABLE_NOISY = {
@@ -11075,7 +11270,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 +11302,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 +11319,12 @@ 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);
-  });
+  };
+  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 +11366,27 @@ 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 JANK_SOURCE = `W8 option A, Arek 2026-10-26 ("Opcja A jest git", [ctl-arek-jank-time]): jank time (the window's commit times past one 60 Hz frame, added up) is judged in place of the slowest commit, so one spike no longer decides and jitter below a frame counts 0; curve T-NOISE-JANK; deciding since simple-4.26 after the pack v3 replay (A/A Slightly worse 58 -> 46 of 840 on aa-ni, doses 54 of 54)`;
 var SHAPE = {
-  id: "simple-4.25+noise95-99",
+  id: "simple-4.26+noise95-99",
   minRuns: 2,
   baseline: { sessions: 3, ...GUESS("Q4 / REQ-VER-33: main's newest 3 sessions against one PR session (the quieter setting of the plan 58 simulation)") },
   repeats: { kind: "every-pr-beyond-every-main" },
@@ -11202,9 +11412,10 @@ var SHAPE = {
   },
   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,
     { ...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 +11441,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: [
     {
@@ -11286,7 +11488,8 @@ var SHAPE = {
   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`
   }],
   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: [
@@ -12743,6 +12946,7 @@ import { parseArgs as parseArgs3 } from "node:util";
 var SHORT_SESSIONS = 3;
 var SHORT_POINTS = 5;
 var SHORT_PLACES = 5;
+var SHORT_COMPARE_MEASURES = 3;
 var SHORT_FORM_NOTES = {
   list_findings: "the how-sure lines, the place lines of findings that are not Worse and the lanes that were judged",
   get_finding: "the why, seen and layer lines, the component lines, the memory evidence lines other than the judged measure and the prompt",
@@ -12752,7 +12956,8 @@ var SHORT_FORM_NOTES = {
   place_trend: `the sessions older than the newest ${SHORT_SESSIONS} and the history restarts among them (unknown restarts always stay)`,
   window_history: `the runs older than the newest ${SHORT_POINTS}`,
   pr_status: "the per-journey dashboard links and the heat note",
-  list_problems: `the work and component lines, the dashboard links and the problems after the first ${SHORT_PLACES}`
+  list_problems: `the work and component lines, the dashboard links and the problems after the first ${SHORT_PLACES}`,
+  compare_runs: `the component lines and the measures beyond each place's ${SHORT_COMPARE_MEASURES} times that moved most`
 };
 var andList = (xs) => xs.length < 2 ? xs[0] ?? "" : `${xs.slice(0, -1).join(", ")} and ${xs[xs.length - 1]}`;
 
@@ -12859,6 +13064,7 @@ function measuredLines(l, r, opts) {
   };
   if (m.lanes.length === 1) {
     r.both(`${scope}: newest measured ${f.branch ? "" : `on ${n.branch}, `}${lane(n)}; ${plural2(m.run_sets, "run set")} measured.`);
+    r.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 +13072,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)
@@ -12932,10 +13139,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(...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 +13153,7 @@ function formatBranchStatus(s, opts = {}) {
       r.full(`    ${l.link}`);
   }
   const links = s.lanes.filter((l) => l.link).length;
+  const staleLanes = s.problems?.stale_lanes ?? 0;
   const heated = s.counts.heat_runs ?? 0;
   const more = [
     [false, heated ? `${INFO_WORDS.heat.toLowerCase()} in ${plural2(heated, "run")} (information, never blocks)` : ""],
@@ -12953,6 +13162,7 @@ function formatBranchStatus(s, opts = {}) {
       s.not_judged_findings ? `${plural2(s.not_judged_findings, "finding")} not judged in the newest run set; they may still be there: keepsnappy findings --branch ${s.branch} --state not-judged` : ""
     ],
     [true, statusProblemsLine(s)],
+    [true, staleLanes ? `${staleWords(staleLanes)}: ${staleLanes === 1 ? "its word and problems are" : "their words and problems are"} of older rules` : ""],
     [true, s.problems?.unread_lanes ? `${unreadWords(s.problems.unread_lanes)} for problems: ${staleResult(s.problems.unread_lanes)}` : ""],
     [true, s.links.overview ? `Dashboard: ${s.links.overview}` : ""],
     [true, s.worst.length ? "One finding with its evidence and a prompt: keepsnappy finding <id> --prompt" : ""]
@@ -12968,9 +13178,11 @@ function statusProblemsLine(s) {
   const p = s.problems;
   if (!p?.count)
     return "";
-  return `${plural2(p.places, "place")} over budget in this branch’s own runs (${p.far_count ? `${p.far_count} far over budget; ` : ""}not a regression, never blocks): list_problems, or keepsnappy problems --branch ${s.branch}`;
+  return `${problemCountsText(p, "this branch’s")}. Not a regression, never blocks: list_problems, or keepsnappy problems --branch ${s.branch}`;
 }
 var unreadWords = (n) => `${n} journey × phone not read`;
+var STALE_FLAG = staleFlagText(["config"]);
+var staleWords = (n) => `${n} journey × phone from a stale result (${STALE_FLAG})`;
 var staleResult = (n) => `${n === 1 ? "its stored result is" : "their stored results are"} not current`;
 function formatProblemList(l, opts = {}) {
   const r = new Rows;
@@ -12987,7 +13199,7 @@ function formatProblemList(l, opts = {}) {
     return r.render(opts.form);
   }
   if (c.count)
-    r.both(`${b}: ${plural2(c.places, "place")} over budget in ${b === l.baseline_branch ? "main’s" : "this branch’s"} own runs${c.far_count ? ` (${c.far_count} far over budget)` : ""}`);
+    r.both(`${b}: ${problemCountsText(c, b === l.baseline_branch ? "main’s" : "this branch’s")}`);
   else if (read)
     r.both(`${b}: no problem over budget in the newest run set (${read} journey × phone read)`);
   else
@@ -12995,10 +13207,12 @@ function formatProblemList(l, opts = {}) {
   r.both(l.note);
   if (read && unread)
     r.both(`${unreadWords(unread)}: ${staleResult(unread)}, so nothing is known about ${unread === 1 ? "its" : "their"} problems.`);
+  if (c.stale_lanes)
+    r.both(`${staleWords(c.stale_lanes)}: ${c.stale_lanes === 1 ? "its" : "their"} problems are listed, each marked “${STALE_MARK}”.`);
   l.problems.forEach((p, i) => {
     const keep = i < SHORT_PLACES;
     r.add(keep, "", `${l.offset + i + 1}. ${p.text}: ${p.place_name}${opts.verbose ? ` (${p.place})` : ""}${p.intermittent ? ` — ${p.note}, not counted` : ""}`);
-    r.add(keep, `   ${p.journey_title ?? p.journey} on ${p.phone_name}, ${p.runs_text}${p.tag_word ? `, ${p.tag_word}` : ""}`);
+    r.add(keep, `   ${p.journey_title ?? p.journey} on ${p.phone_name}, ${p.runs_text}${p.tag_word ? `, ${p.tag_word}` : ""}${p.stale ? `, ${STALE_MARK}` : ""}`);
     const top = p.top_components[0];
     const topName = componentReadNames(p.top_components)[0];
     const detail = [p.work, top ? `heaviest ${topName}${opts.verbose && top.key ? ` (${top.key})` : ""} ${top.self_text}` : null, p.new_component ? NEW_IN_PR_CHIP : null, p.range_text ? `${p.range_text} between runs` : null].filter(Boolean);
@@ -13021,56 +13235,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 +13319,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 +13356,7 @@ function formatSessionPlaces(p, opts = {}) {
     return r.both("Stale: its statistics are of another derivation or stats version and are not served until the next recompute rewrites them; nothing is known about its places (not zero).").render(opts.form);
   const by = p.filters.measure;
   const byLabel = p.places.flatMap((x) => x.measures).find((m) => m.measure === by)?.label ?? by;
-  r.both(`Stored per-session statistics: no verdict, no comparison. Places by ${byLabel} (${p.filters.sort}), highest first${p.filters.window ? `, matching “${p.filters.window}”` : ""}${p.without_measure ? `; ${p.without_measure} of ${p.total} places ${p.without_measure === 1 ? "has" : "have"} no value for it` : ""}.`, "");
+  r.both(`Stored per-session statistics: no verdict, no comparison. Places by ${byLabel} (${p.filters.sort}), highest first${p.filters.window ? `, matching “${p.filters.window}”` : ""}${p.without_measure ? `; ${p.without_measure} of ${p.total} places ${p.without_measure === 1 ? "has" : "have"} no value for it` : ""}${p.folded_twins ? `; ${foldedTwinsText(p.folded_twins)}` : ""}.`, "");
   let componentLines = 0;
   p.places.forEach((place, i) => {
     const m = place.measures.find((x) => x.measure === by);
@@ -13212,7 +13429,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 +13471,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 +13516,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 +13542,10 @@ function formatPlaceTrend(t, opts = {}) {
       const value = place.sessions.find((s) => s.run_set_id === session.run_set_id);
       if (!value)
         continue;
-      const unit = place.unit ? ` ${place.unit}` : "";
+      const value_ = (v) => storedValueText(place.ref, v, place.unit);
       if (!k)
         olderSessions.add(session.run_set_id);
-      r.add(k, `${session.completed_at?.slice(0, 10) ?? "date unknown"} ${session.commit.sha?.slice(0, 7) ?? "commit unknown"} · ${windowQualified(place.window)}${opts.verbose ? ` (${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 +13602,8 @@ var branchStatus = (t, branch) => get(t, "v1/branches/status", { branch });
 var listProblems = (t, f = {}) => get(t, "v1/problems", { branch: f.branch, main: f.main ? "true" : undefined, journey: f.journey, phone: f.phone, limit: f.limit, offset: f.offset || undefined });
 var getFinding = (t, id) => get(t, `v1/findings/${encodeURIComponent(id)}`);
 var compareRuns = (t, a, b, page = {}) => get(t, "v1/compare", { a, b, ...page });
+var SHORT_COMPARE_PLACES = 10;
+var compareQuery = (short, page) => short ? { order: "moved", limit: SHORT_COMPARE_PLACES, ...page } : page;
 var windowHistory = (t, q) => get(t, "v1/history", q);
 var commitsBetween = (t, q) => get(t, "v1/commits", q);
 var layers = (t) => get(t, "v1/layers");
@@ -13409,7 +13638,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 +13654,7 @@ ${READ_USAGE.detailFlag}
   --short  (findings, status, problems, finding, history, places, main, trend: what decides, without the evidence detail; the same as the MCP tools' form short; --json is unchanged)
   (key: KEEPSNAPPY_KEY or --key-env NAME; API: --api URL or KEEPSNAPPY_API)`;
 var STATES = ["present", "not-judged", "resolved", "all"];
-var SHORT_COMMANDS = new Set(["findings", "status", "problems", "finding", "history", "places", "main", "trend"]);
+var SHORT_COMMANDS = new Set(["findings", "status", "problems", "finding", "compare", "history", "places", "main", "trend"]);
 var FINDINGS_COMMANDS = new Set(["findings", "status", "problems", "finding", "compare", "history", "commits", "places", "layers", "main", "trend"]);
 async function findingsCommand(cmd, argv, rt) {
   const args = (() => {
@@ -13564,7 +13793,8 @@ async function findingsCommand(cmd, argv, rt) {
       const size = o["top-components"] === undefined ? 12 : Number(o["top-components"]);
       if (!Number.isInteger(size) || size < 1 || size > 200)
         throw new UsageError([READ_USAGE.compareTop]);
-      const query = page || o.all || o["top-components"] !== undefined ? { component_offset: ((page ?? 1) - 1) * size, component_limit: size } : {};
+      const components = page || o.all || o["top-components"] !== undefined ? { component_offset: ((page ?? 1) - 1) * size, component_limit: size } : {};
+      const query = compareQuery(o.short === true, { ...components, ...limit ? { limit } : {}, ...offset !== undefined ? { offset } : {} });
       const compared = await compareRuns(t, p[0], p[1], query);
       return out(o.all ? await allCompare(t, compared, size) : compared, formatCompare);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keepsnappy/agent",
-  "version": "0.1.0-alpha.18",
+  "version": "0.1.0-alpha.19",
   "description": "KeepSnappy CLI: runs your app journeys, measures from inside the app and reports More work / Less work / No change per step.",
   "type": "module",
   "license": "UNLICENSED",