staysfixed 0.12.0 → 0.13.0

package/src/v2/mcp/tools.js

@@ -538,7 +538,10 @@ export function toolDefinitions() {
       title: 'Prove what caused it',
       annotations: behaves({ title: 'Prove what caused it' }),
       description:
-        'Test a causal claim by undoing a change and running again. You believe your edit to a particular file caused a finding: this puts that file back to the reference, re-runs, and tells you whether the difference went away. If it survives the revert, your edit did not cause it and you were about to fix the wrong thing. Nothing is left reverted.',
+        'Test a causal claim by undoing a change and running again. You believe your edit to a particular file caused a finding: this puts that file back to the reference, re-runs, and tells you whether the difference went away. ' +
+        'It answers one of THREE things, and only two of them are answers: PROVEN CAUSED (undoing it made the difference go away), PROVEN NOT CAUSED (it was re-run without your change and the difference is still there, so you were about to fix the wrong file), ' +
+        'and NOT TESTED (nothing was measured - the file you named was not among the changes, the old build would not build, or nothing was re-run at all). NOT TESTED never means your edit is innocent; it means nobody looked, and it comes back as an error so it cannot be mistaken for a clean answer. ' +
+        'Proving costs a full re-run of the affected journeys - roughly what a check costs - because that is the only thing that settles it. Nothing is left reverted.',
       inputSchema: {
         type: 'object',
         properties: {
@@ -1512,6 +1515,22 @@ async function toolExplain(ctx, input) {
   } else if (deep && typeof deep.text === 'string') {
     out.push('');
     out.push(deep.text);
+  } else {
+    // The deep half is missing and nothing above says so.
+    //
+    // Same shape as the `prove` defect measured on 2026-08-31: a reply that is complete on
+    // its face while a whole half of it was never fetched. Everything above comes from the
+    // stored finding, which this surface can always read; the full list of addresses with
+    // both values comes from the engine, and when the engine cannot be loaded, or has no
+    // `explain` in it, the reply simply ended early and read as the whole answer. A reader
+    // has no way to tell "this is all there is" from "the rest could not be fetched", so it
+    // is said out loud rather than left to be inferred from an absence.
+    out.push('');
+    out.push(
+      engine.parts.explain
+        ? 'The engine returned nothing for this finding, so everything above comes from the stored record of the check and the full side-by-side values are missing. This is not the whole answer.'
+        : `This copy of Stays Fixed has no difference engine to ask, so everything above comes from the stored record of the check alone - the full list of addresses with both values is missing. This is not the whole answer. ${voice.isPerson ? 'Run' : 'Call'} ${voice.capabilities} for what this copy can do.`
+    );
   }
 
   content.push({ type: 'text', text: out.join('\n') });
@@ -1570,7 +1589,10 @@ async function toolProve(ctx, input) {
     return engineMissing(
       engine,
       'prove',
-      'prove({cwd, configFile, finding, revert}) returning {gone: boolean, detail?: string}. src/v2/cause.js already has proveCause(), but it takes an engine-internal finding and a loaded project, which this surface does not have - a small facade in src/v2/check.js is all that is needed.',
+      'prove({cwd, configFile, finding, revert}) returning {verdict: "caused by that change"|"not caused by that change"|"could not test", detail?: string, reran?: number, checked?: number, escalates?: boolean}. ' +
+      'The verdict has to be all three of those, not a boolean: "could not test" is a third outcome and reporting it as "not caused" is a false all-clear (measured 2026-08-31). ' +
+      '`reran` and `checked` are what let this reply say whether anything was actually run, so a five-second answer cannot pass for an eleven-minute one. ' +
+      'src/v2/cause.js already has proveCause() returning exactly that shape, but it takes an engine-internal finding and a loaded project, which this surface does not have - a small facade in src/v2/check.js is all that is needed.',
       voice
     );
   }
@@ -1586,23 +1608,174 @@ async function toolProve(ctx, input) {
 
   /** @type {any} */
   const result = (await run({ cwd: ctx.root, finding: id, revert })) ?? {};
-  const gone = result.gone === true;
+
+  // THREE OUTCOMES, THREE SENTENCES. Only two of them are answers.
+  //
+  // Until 2026-08-31 this branched on `result.gone === true` and printed one of two
+  // paragraphs, so everything that was not a proof came out as the confident denial "Your
+  // edit did not cause this, so fixing that file will not help." Measured on a real website
+  // that day: a one-line heading change that had definitely caused the finding was told it
+  // was innocent; naming a completely unrelated file produced the word-for-word identical
+  // denial; and a file that does not exist produced it too. All three came back in about
+  // five seconds, on a project where a real check takes eleven to twenty minutes, and the
+  // run log recorded zero server starts. Nothing had been re-run at all.
+  //
+  // `src/v2/cause.js` had the third outcome the whole time — its `cannot()` path carries a
+  // comment saying "not proven either way is not the same as proven innocent, and it must
+  // never be reported as if it were" — and this is the surface that was reporting it as if
+  // it were. So the verdict is read here, not re-derived from a boolean that cannot carry
+  // three states.
+  const verdict = verdictOf(result);
 
   /** @type {string[]} */
   const out = [];
-  if (gone) {
-    out.push(`PROVEN: your change caused it. With ${revert.join(', ')} put back, this matched the reference again.`);
-    out.push(`  ${trim(f.title, 200)}`);
+  const files = revert.join(', ');
+  const title = `  ${trim(f.title, 200)}`;
+  // How much real work the answer rests on, when the engine says. `reran` counts journeys
+  // actually walked again; `checked` counts the finding's addresses that were re-measured.
+  // Both are absent when the facade in src/v2/check.js does not forward them, and an absent
+  // number is never guessed at - it simply goes unsaid.
+  const reran = positive(result.reran);
+  const checked = positive(result.checked);
+
+  if (verdict === 'caused by that change') {
+    out.push(`PROVEN CAUSED: your change caused it. With ${files} put back, this matched the reference again.`);
+    out.push(title);
+    out.push(measuredLine(reran, checked, 'and the difference went away'));
     out.push('So it is yours to fix - or to record as intended, if that is genuinely what you meant and it is not sealed.');
+  } else if (verdict === 'not caused by that change') {
+    out.push(`PROVEN NOT CAUSED: it was re-run with your change undone and the difference is still there.`);
+    out.push(title);
+    out.push(measuredLine(reran, checked, 'and the difference survived'));
+    out.push(`So putting ${files} back does not fix this, and fixing that file will not either. Something else caused it, and nothing knows what yet - this finding is louder now, not quieter.`);
   } else {
-    out.push(`NOT PROVEN: it survived the revert. With ${revert.join(', ')} put back, this was still different.`);
-    out.push(`  ${trim(f.title, 200)}`);
-    out.push('Your edit did not cause this, so fixing that file will not help. Something else did, or it was already broken before you started.');
+    // The one that must never sound like the one above it. It says what it is, why, what it
+    // is NOT, and what would actually settle the question.
+    out.push(`NOT TESTED: this was not proved either way. Nobody looked.`);
+    out.push(title);
+    out.push('');
+    const why = trim(dropRepeatedTail(String(result.detail ?? 'The engine did not say why.')), 600);
+    out.push(`Why: ${why}`);
+    out.push('');
+    // The re-run fact, said once. `cause.js` writes it into its own sentence so that it
+    // survives a facade that forwards only the words, so when it is already in `why` there
+    // is nothing to add - and adding a vaguer version underneath ("nothing here says how
+    // much was re-run") would contradict the specific one directly above it.
+    const rerunLine =
+      reran === 0
+        ? 'Nothing was re-run: no build was started and no journey was walked again, so no part of this reply is a measurement of your product.'
+        : reran !== null
+          ? `${reran} ${reran === 1 ? 'journey was' : 'journeys were'} walked again and it still settled nothing.`
+          : /re-run|walked again/i.test(why)
+            ? ''
+            : 'Nothing here says how much was re-run, so do not read any of this as a measurement.';
+    if (rerunLine) out.push(rerunLine);
+    out.push(`This is NOT "your edit did not cause it". ${files} has not been cleared - it was never tested. Keep suspecting it.`);
+    out.push(`To get a real answer: ${voice.isPerson ? 'run' : 'call'} ${voice.check} so there is a fresh run to work from, then ${explainThis(voice, id)} to see which files this finding actually sits near, and name one you really changed.`);
   }
-  if (result.detail) out.push('', trim(String(result.detail), 600));
-  out.push('', 'The working tree has been put back exactly as it was.');
 
-  return { content: [{ type: 'text', text: out.join('\n') }] };
+  if (verdict !== 'could not test' && result.detail) out.push('', trim(dropRepeatedTail(String(result.detail)), 600));
+  out.push('', 'Nothing was left reverted. The working tree is exactly as it was.');
+
+  return {
+    content: [{ type: 'text', text: out.join('\n') }],
+    structuredContent: { finding: id, verdict, reverted: revert, reran, checked, escalates: result.escalates === true },
+    // "Could not test" answers non-zero on purpose, and the CLI's own help has promised
+    // exactly this since the command existed: "It answers 0 when it could test the claim and
+    // 2 when it could not." It exited 0 instead. An agent - or a CI step - that reads a zero
+    // as "asked and answered" is the false all-clear this tool exists to prevent, so the one
+    // outcome that is not an answer is the one outcome that does not come back clean.
+    isError: verdict === 'could not test',
+  };
+}
+
+/**
+ * How this reader asks to see THIS finding in full.
+ *
+ * `voice.explainCall` is a worked example carrying the made-up id f-a1b2c3, which is right
+ * where the point is to show the shape of a call and wrong the moment the sentence is about
+ * a finding that has a real id. Telling somebody to run `staysfixed explain f-a1b2c3` about
+ * finding f-15365c reads as a copy-and-paste slip and sends them to look up an id that does
+ * not exist.
+ *
+ * @param {Voice} voice
+ * @param {string} id
+ * @returns {string}
+ */
+function explainThis(voice, id) {
+  return voice.isPerson ? `\`staysfixed explain ${id}\`` : `staysfixed_explain { "finding": "${id}" }`;
+}
+
+/**
+ * Which of the three this is, refusing to invent the difference between two of them.
+ *
+ * The engine's own three-state verdict is used whenever it is there. When it is not - an
+ * older facade, or one that only ever returned `{gone: boolean}` - a `false` is genuinely
+ * ambiguous: it means either "measured, and your edit is innocent" or "could not measure".
+ * Those are the two this whole defect confused, so the unknown resolves to the one that
+ * claims nothing. Reporting "could not test" about something that was really tested costs
+ * somebody one more command; reporting "your edit did not cause this" about something
+ * nobody measured sends them to fix the wrong file, which is what happened on 2026-08-31.
+ *
+ * @param {any} result
+ * @returns {'caused by that change'|'not caused by that change'|'could not test'}
+ */
+function verdictOf(result) {
+  const said = typeof result?.verdict === 'string' ? result.verdict : null;
+  if (said === 'caused by that change' || said === 'not caused by that change' || said === 'could not test') return said;
+  if (result?.gone === true) return 'caused by that change';
+  return 'could not test';
+}
+
+/**
+ * One line saying what the verdict above actually rests on.
+ *
+ * A verdict with no measurement behind it reads exactly like one with eleven minutes behind
+ * it, which is how a five-second reply passed for a check of a whole website. When the
+ * numbers are not forwarded this says so plainly rather than inventing a reassuring one.
+ *
+ * @param {number|null} reran    Journeys walked again.
+ * @param {number|null} checked  Addresses re-measured.
+ * @param {string} outcome       What happened to the difference, in a few words.
+ * @returns {string}
+ */
+function measuredLine(reran, checked, outcome) {
+  if (reran === null && checked === null) return `That was measured by running it again, ${outcome}.`;
+  const bits = [];
+  if (reran !== null) bits.push(`${reran} ${reran === 1 ? 'journey' : 'journeys'} walked again`);
+  if (checked !== null) bits.push(`${checked} ${checked === 1 ? 'address' : 'addresses'} re-measured`);
+  return `Measured, not assumed: ${bits.join(', ')}, ${outcome}.`;
+}
+
+/**
+ * Drop a sentence the engine handed over twice.
+ *
+ * `prove` in src/v2/check.js builds its detail as `${proof.what} ${proof.why}`, and
+ * `proof.what` already ends with `why` - so every "could not test" arrived with its reason
+ * printed twice in a row. That is only noise, but a reply that visibly repeats itself is a
+ * reply people stop reading closely, and this one is asking to be read closely.
+ *
+ * @param {string} detail
+ * @returns {string}
+ */
+function dropRepeatedTail(detail) {
+  const s = detail.trim();
+  // Walk back from the end looking for a tail that already appeared earlier in the string.
+  // Only whole trailing sentences of real length count, so ordinary repeated words - "the
+  // change", "this file" - are never mistaken for a duplicated reason.
+  for (let cut = Math.floor(s.length / 2); cut >= 30; cut -= 1) {
+    const tail = s.slice(s.length - cut).trim();
+    if (tail.length < 30) break;
+    if (s.slice(0, s.length - cut).includes(tail)) {
+      const kept = s.slice(0, s.length - cut).trim();
+      // The cut can land one character inside the sentence that is being KEPT, because the
+      // repeated tail often starts at ". " and the full stop it takes belongs to the line
+      // before it. Losing it leaves the reason ending mid-air, which reads like the text was
+      // truncated - the one impression this particular reply must never give.
+      return /[.!?]$/.test(kept) ? kept : `${kept}.`;
+    }
+  }
+  return s;
 }
 
 // ---------------------------------------------------------------------------

package/src/v2/observation.js

@@ -829,6 +829,21 @@ export function mergeWobble(wobbles) {
  * here decides whether any difference is real. It decides one thing only — whether this run is
  * entitled to say the word "clean".
  *
+ * IT IS ASKED PER JOURNEY, NOT ONLY ONCE OVER THE WHOLE RUN, and that is the scope this rule
+ * was missing until 2026-08-31. Measured on a real Next.js site: 179 of 2849 addresses were
+ * unsteady across the run, which is nowhere near half, so the whole-run answer was "no storm"
+ * and the run exited 0 saying `ok` — while four of its twelve journeys had been unsteady at
+ * 69%, 75% and twice 100% of their own addresses. A page where EVERY address disagreed with
+ * itself was folded into a passing total by nine pages that behaved. The rule was right and
+ * the scope was wrong: applied per journey, the same one comparison catches all four. Whoever
+ * calls this owes it one call per journey; `noAnswerJourneys` below is that call.
+ *
+ * A MEASUREMENT OVER NOTHING IS ALSO NOT A MEASUREMENT. Two runs that each came back with no
+ * addresses at all agree about everything, which arithmetically is nought unsteady and nought
+ * steady, and `unstable <= steady` waved it through as calm weather. That is the same false
+ * all-clear wearing the opposite clothes — a journey with no answer in it counted towards a
+ * pass — so it is answered here rather than left to whichever caller thinks to look.
+ *
  * @param {Wobble} wobble
  * @returns {{stormy: boolean, share: number, looked: number, vanished: number, why: string}}
  */
@@ -837,6 +852,21 @@ export function wobbleStorm(wobble) {
   const looked = unstable + wobble.steady;
   const vanished = wobble.entries.filter((e) => e.kind === 'vanished').length;
   const share = looked === 0 ? 0 : unstable / looked;
+  // NOTHING WAS LOOKED AT, so there is nothing here to be steady or unsteady about. A walk
+  // that ran, came back empty, and was run again and came back empty a second time produces
+  // nought unsteady out of nought — which reads as perfect agreement to every count below
+  // and is the emptiest possible sentence to build a pass on. Said out loud instead.
+  if (wobble.measured && looked === 0) {
+    return {
+      stormy: true,
+      share: 0,
+      looked: 0,
+      vanished: 0,
+      why:
+        'The new build was run twice here and neither run found a single address to look at, so there was nothing to measure and nothing to compare. ' +
+        'Two empty walks agree with each other about everything, which is why this used to count towards a clean run. It is not a pass and not a failure — there is no answer here.',
+    };
+  }
   // MORE OF IT WOBBLED THAN HELD STILL, and that one comparison is the whole rule. There is
   // no threshold here to tune and no number to defend: half is the point past which more of
   // the comparison has been thrown away than kept, and no answer computed from what is left
@@ -866,6 +896,121 @@ export function wobbleStorm(wobble) {
   return { stormy: true, share, looked, vanished, why };
 }
 
+/**
+ * Which journeys have no answer in them, asked ONE AT A TIME.
+ *
+ * This is `wobbleStorm` with the scope it should always have had. The rule inside it — more
+ * addresses wobbled than held still — is right, and it was being asked once, of everything
+ * added together. Measured 2026-08-31 on a real Next.js site: 179 unsteady addresses out of
+ * 2849 across twelve journeys is not a storm by any reading, and underneath that total sat
+ * four journeys that were unsteady at 69%, 75% and twice 100% of their own addresses. Two
+ * whole pages where every single address disagreed with itself were folded into a passing
+ * run by the nine pages that behaved.
+ *
+ * Adding journeys together is what did it. Each journey is its own measurement — its own
+ * pages, its own two walks, its own chance of falling over — and averaging a page that told
+ * you nothing with nine that told you plenty produces a number that describes no page at
+ * all. So the wobbles come in one per journey and the answer is a list, not a share.
+ *
+ * A journey in this list is NOT a failure and NOT a pass: whatever it disagreed with itself
+ * about was dropped before it could be compared, so the quiet underneath it is the quiet of
+ * nothing having been looked at. The caller owes it a named hole in the coverage and a
+ * verdict that is not `ok`.
+ *
+ * @param {Wobble[]} wobbles   One per journey, in the order they were walked.
+ * @returns {{journey: string, why: string, looked: number, unstable: number, steady: number, share: number}[]}
+ */
+export function noAnswerJourneys(wobbles) {
+  /** @type {{journey: string, why: string, looked: number, unstable: number, steady: number, share: number}[]} */
+  const out = [];
+  for (const wobble of wobbles) {
+    // The merged record is the whole run wearing one journey's shape, and asking it here
+    // would put the very scope bug this function exists to fix straight back in.
+    if (wobble.journey === '*') continue;
+    const storm = wobbleStorm(wobble);
+    if (!storm.stormy) continue;
+    out.push({
+      journey: wobble.journey,
+      why: storm.why,
+      looked: storm.looked,
+      unstable: wobble.unstable.length,
+      steady: wobble.steady,
+      share: storm.share,
+    });
+  }
+  return out;
+}
+
+/**
+ * WHAT KIND of disagreement this was: the answers moving, or the addresses themselves coming
+ * and going between the two passes.
+ *
+ * The two are folded into one number everywhere else — `unstable` — and they are not the
+ * same news. An answer that changed is the product wobbling, which is what the measurement
+ * is for. An address that only one of the two passes ever saw is the WALK not covering the
+ * same ground twice, and it is why the run's own headline count moves.
+ *
+ * Measured 2026-08-31, three checks of one untouched Next.js site, minutes apart, nothing
+ * edited between them: 2364, 2684 and 2861 addresses looked at, and 0, 179 and 500 of them
+ * unsteady. A tool whose whole method is running one thing twice and subtracting what
+ * disagrees cannot give three answers to one question and expect to be believed. Some of
+ * that spread is the product being genuinely unsteady, which is the measurement working;
+ * the ADDRESS COUNT moving by five hundred is not the product at all. Separating the two is
+ * what lets the run say which is which instead of quoting one number that means neither.
+ *
+ * @param {Wobble} wobble
+ * @returns {{changed: number, appeared: number, vanished: number, drifted: number, bothPasses: number, steady: number, looked: number}}
+ */
+export function wobbleShape(wobble) {
+  let changed = 0;
+  let appeared = 0;
+  let vanished = 0;
+  for (const e of wobble.entries) {
+    if (e.kind === 'changed') changed += 1;
+    else if (e.kind === 'appeared') appeared += 1;
+    else vanished += 1;
+  }
+  return {
+    changed,
+    appeared,
+    vanished,
+    // The addresses that exist on one pass and not the other. This is the part of the total
+    // that is the walk rather than the product, and the part that moves between runs.
+    drifted: appeared + vanished,
+    // The addresses BOTH passes actually reached. The steadiest count this run owns, and
+    // the honest one to quote.
+    bothPasses: wobble.steady + changed,
+    steady: wobble.steady,
+    looked: wobble.steady + wobble.unstable.length,
+  };
+}
+
+/**
+ * The sentence that names the drifting count, so no run has to invent its own wording for
+ * the one number readers were quoting at each other.
+ *
+ * It is said whenever the two passes of one build did not look at the same addresses. Empty
+ * when they did, because a sentence that appears on every single run is a sentence people
+ * learn to skip, and this one has to land when it is true.
+ *
+ * @param {Wobble} wobble
+ * @returns {string}   Empty when both passes covered the same ground.
+ */
+export function populationDriftNote(wobble) {
+  if (!wobble.measured) return '';
+  const shape = wobbleShape(wobble);
+  if (shape.drifted === 0) return '';
+  const parts = [];
+  if (shape.vanished > 0) parts.push(`${shape.vanished} ${shape.vanished === 1 ? 'address' : 'addresses'} the first pass saw ${shape.vanished === 1 ? 'was' : 'were'} not there on the second`);
+  if (shape.appeared > 0) parts.push(`${shape.appeared} ${shape.appeared === 1 ? 'address' : 'addresses'} turned up only on the second`);
+  return (
+    `THE TWO PASSES DID NOT LOOK AT THE SAME ADDRESSES: ${parts.join(', and ')}. ` +
+    `That is the walk moving, not the product answering differently — ${shape.changed} ${shape.changed === 1 ? 'address' : 'addresses'} really did give two different answers. ` +
+    `So the total of ${shape.looked} addresses is not a number that will be the same on the next run of the identical build; ` +
+    `${shape.bothPasses} is the count both passes actually reached, and it is the one to quote.`
+  );
+}
+
 /**
  * Subtract the measured noise from the differences.
  *

package/src/v2/run.js

@@ -30,7 +30,9 @@ import {
   subtractWobble,
   sameValue,
   indexByPath,
-  wobbleStorm,
+  noAnswerJourneys,
+  populationDriftNote,
+  wobbleShape,
 } from './observation.js';
 // `diffCaptures` is no longer called from here directly. Everything goes through
 // `compareAnswers`, which is that same comparison with one rule around it: an address where
@@ -268,6 +270,20 @@ export async function runCheck(opts) {
     const comparedJourneys = [];
     /** @type {Wobble[]} */
     const wobbles = [];
+    // JOURNEYS THAT PRODUCED NO ANSWER, kept as a list rather than folded into a total.
+    //
+    // This is the scope fix of 2026-08-31. The storm rule — more addresses wobbled than held
+    // still — was asked once, of every journey added together, and on a real Next.js site
+    // 179 unsteady addresses out of 2849 is not a storm by any reading. Underneath that
+    // total sat four journeys unsteady at 69%, 75% and twice 100% of their own addresses,
+    // every one of them printed in the coverage list as "could not be compared... there is
+    // no answer here" — while the run exited 0 and said `ok`. A page where every single
+    // address disagreed with itself was folded into a pass by the pages that behaved.
+    // Reproduced here the same day on a six-page Next.js site with two pages made unsteady
+    // on the server, where the browser freeze cannot reach them: four journeys at 61%, 98%,
+    // 98% and 100%, one timed-out walk, `ok: true`, exit code 0.
+    /** @type {{journey: string, why: string, looked: number}[]} */
+    const noAnswer = [];
     /** @type {Wobble[]} */
     const referenceWobbles = [];
     /** @type {string[]} */
@@ -312,11 +328,19 @@ export async function runCheck(opts) {
           surface: journey.surface,
         });
       }
-      const weather = wobbleStorm(wobble);
-      if (weather.stormy) {
+      // ASKED OF THIS ONE JOURNEY, and the answer is kept. The same call used to happen
+      // here and go nowhere but the coverage list: the gap was written, the verdict never
+      // read it, and the run went out `ok: true` with "there is no answer here" printed
+      // four times inside it. A hole nothing refuses to pass over is a hole nobody acts on.
+      for (const dead of noAnswerJourneys([wobble])) {
+        noAnswer.push({ journey: journey.describe || journey.name, why: dead.why, looked: dead.looked });
+        // A journey that came back with nothing at all already has its own line, three
+        // lines above, in words that fit it better. Saying it twice teaches the reader to
+        // skim the one list in this tool that must never be skimmed.
+        if (dead.looked === 0) continue;
         gaps.push({
           what: `"${journey.describe || journey.name}" could not be compared: the new build did not answer it the same way twice.`,
-          why: weather.why,
+          why: dead.why,
           unlockedBy: 'Run it again on a quiet machine. If it happens twice, something in the product does not survive being started a second time.',
           surface: journey.surface,
         });
@@ -488,6 +512,42 @@ export async function runCheck(opts) {
     // in the gap list is a fact most readers will never meet.
     /** @type {string[]} */
     const runNotes = [];
+    // THE NUMBER OF ADDRESSES THIS RUN LOOKED AT IS NOT ALLOWED TO MOVE IN SILENCE.
+    //
+    // Measured 2026-08-31, three checks of one untouched Next.js site minutes apart with
+    // nothing edited between them: 2364, 2684 and 2861 addresses looked at, and 0, 179 and
+    // 500 of them unsteady. A tool whose whole method is running one thing twice and
+    // subtracting what disagrees cannot give three answers to one question and expect to be
+    // believed. Part of that spread is the product genuinely wobbling, which is exactly what
+    // the measurement is for and is reported as wobble. The ADDRESS COUNT moving by five
+    // hundred is not the product: it is the two passes of one build walking over different
+    // ground, because a request was cancelled on one of them, a page finished loading on one
+    // of them, or the walk ran out of time on one of them. Every one of those already has a
+    // line in this list; what had no line at all was the drift itself, so the total simply
+    // came out different each run with nothing anywhere saying why.
+    //
+    // It cannot be made steady from here — the causes are in the walk, not the arithmetic —
+    // so it is named, and the count both passes actually reached is named beside it as the
+    // number worth quoting. A number that moves and says nothing is worse than a smaller one
+    // that is honest.
+    const drift = populationDriftNote(wobble);
+    if (drift) {
+      const worst = wobbles
+        .map((w) => ({ journey: w.journey, drifted: wobbleShape(w).drifted }))
+        .filter((w) => w.drifted > 0)
+        .sort((x, y) => y.drifted - x.drifted);
+      const named = worst.slice(0, 4).map((w) => `${w.journey} (${w.drifted})`).join(', ');
+      runNotes.push(drift);
+      gaps.push({
+        what: 'The two runs of the new build did not walk over the same addresses, so the number this run says it looked at will not be the same number next time.',
+        why:
+          `${drift} Worst in ${named}${worst.length > 4 ? `, and ${worst.length - 4} more` : ''}. ` +
+          'Every address that only one of the two passes reached was never compared with anything, on either side.',
+        unlockedBy:
+          'Find what makes an address turn up on one pass and not the other — a request the browser cancels when the page is torn down, a page that only sometimes finishes loading, a walk that runs out of time — and either make it steady or take it out of what is watched. The timeouts and torn walks that cause it are named separately in this same list.',
+      });
+    }
+
     const kept = await remember(opts, walked);
     if (kept.why) {
       runNotes.push(
@@ -798,6 +858,16 @@ export async function runCheck(opts) {
         subtraction.newlyUnstable.length === 0 &&
         subtraction.couldNotTell !== true &&
         answersLost === 0 &&
+        // AND NOT ONE JOURNEY MAY HAVE COME BACK WITH NO ANSWER. `couldNotTell` above is
+        // this same law asked of the whole run added together, and adding is what hid it:
+        // 179 unsteady addresses out of 2849 is not a storm, and four of that run's twelve
+        // journeys were unsteady at 69%, 75% and twice 100% of their own. Whatever those
+        // four disagreed with themselves about was dropped before it could be compared, so
+        // the quiet underneath them is the quiet of nothing having been looked at — and it
+        // was being counted towards a pass by the journeys that behaved. Measured on a real
+        // Next.js site, 2026-08-31, where the run exited 0 and printed `ok` with "there is
+        // no answer here" written inside it four times.
+        noAnswer.length === 0 &&
         // AND SOMETHING HAS TO HAVE BEEN COMPARED. There is already a branch above for the
         // case where no journey had an old-build side at all; this is the same law one notch
         // finer, for the run where every journey HAD a record and every address in it holds
@@ -825,6 +895,12 @@ export async function runCheck(opts) {
           // for as long as it did is that the silence looked exactly like agreement.
           unanswered: uncompared.length,
           lost: answersLost,
+          // Named, not counted. "4 journeys could not be compared" sends the reader to a
+          // list of thirty-odd coverage lines to find out which four; the names cost one
+          // line and are what somebody acts on. `looked` rides along because a journey that
+          // disagreed with itself and a journey that saw nothing at all are two different
+          // pieces of news and must not be described in one borrowed sentence.
+          noAnswer: noAnswer.map((d) => ({ journey: d.journey, looked: d.looked })),
         }),
       startedAt,
       started,
@@ -1304,15 +1380,44 @@ function warningGaps(mode, provedLive) {
  * @param {BuildFingerprint} reference
  * @param {boolean} provedLive
  * @param {number} dropped   Suspicions the old build turned out to have as well.
- * @param {{compared: number, asked: number, addresses: number, unanswered?: number, lost?: number}} how
+ * @param {{compared: number, asked: number, addresses: number, unanswered?: number, lost?: number, noAnswer?: {journey: string, looked: number}[]}} how
  *   How much of the run this sentence covers: journeys that were really put beside the old
- *   build, journeys asked for, the addresses really compared, and the addresses that could
- *   not be compared because one side of them was a refusal rather than an answer.
+ *   build, journeys asked for, the addresses really compared, the addresses that could not
+ *   be compared because one side of them was a refusal rather than an answer, and the
+ *   journeys that produced no answer at all because the new build would not answer them the
+ *   same way twice.
  * @returns {string}
  */
 function summarise(findings, subtraction, warning, notes, reference, provedLive, dropped, how) {
   const against = provedLive ? `${nameOf(reference)}, run live` : `the stored record of ${nameOf(reference)}`;
   const parts = [];
+  // FIRST, ALWAYS, AND BEFORE THE HEADLINE. A journey with no answer in it is the one thing
+  // that must not be reachable by reading one more sentence: the headline is all some
+  // readers get, and "Nothing that worked has changed" sitting on top of four journeys that
+  // were never compared is the exact false all-clear this whole tool exists to refuse.
+  // Until 2026-08-31 that sentence was printed, `ok` was true, and the run exited 0.
+  const dead = how.noAnswer ?? [];
+  if (dead.length > 0) {
+    const names = dead.map((d) => d.journey);
+    const empty = dead.filter((d) => d.looked === 0).length;
+    const stormy = dead.length - empty;
+    const because = [];
+    if (stormy > 0) {
+      because.push(
+        `The new build disagreed with itself about most of what ${stormy === dead.length ? plural(stormy, 'that journey looks', 'those journeys look') : `${stormy} of them look`} at, so almost everything ${plural(stormy, 'it', 'they')} saw was dropped before it could be compared with anything.`,
+      );
+    }
+    if (empty > 0) {
+      because.push(
+        `${empty === dead.length ? `${plural(empty, 'It was', 'They were')}` : `${empty} of them ${plural(empty, 'was', 'were')}`} walked twice and came back with nothing at all to look at.`,
+      );
+    }
+    parts.push(
+      `NO ANSWER FOR ${dead.length} OF THE ${how.asked} ${plural(how.asked, 'JOURNEY', 'JOURNEYS')} HERE: ${names.slice(0, 4).join(', ')}${names.length > 4 ? `, and ${names.length - 4} more` : ''}. ` +
+        `${because.join(' ')} ` +
+        `The quiet underneath ${plural(dead.length, 'it', 'them')} is the quiet of nothing having been looked at, not of nothing having changed. This is not a pass and not a failure, and the journeys that did answer do not make it one.`,
+    );
+  }
   // How much of the run this sentence is actually about. A run that compared four of its
   // seventeen journeys is not a run that found nothing; it is a run that mostly did not look,
   // and the first sentence is the only one some readers get.
@@ -1357,10 +1462,29 @@ function summarise(findings, subtraction, warning, notes, reference, provedLive,
     // paragraphs down in a list.
     const n = how.lost ?? 0;
     parts.push(
-      `Nothing that COULD be compared has changed — but ${n} ${plural(n, 'address', 'addresses')} the old build answers at could not be answered by this build at all, so ${plural(n, 'it was', 'they were')} not compared. That is coverage this build has taken away, and it is not a pass. ${how.addresses} ${plural(how.addresses, 'address was', 'addresses were')} really put beside ${against}.${reach}`,
+      `THIS BUILD ANSWERS AT FEWER PLACES THAN THE LAST ONE. Nothing that could still be compared has changed — but ${n} ${plural(n, 'address', 'addresses')} the old build answers at could not be answered by this build at all, so ${plural(n, 'it was', 'they were')} not compared. That is coverage this build has taken away, and it is not a pass. ${how.addresses} ${plural(how.addresses, 'address was', 'addresses were')} really put beside ${against}.${reach}`,
+    );
+  } else if (findings.length === 0 && dead.length > 0) {
+    // "Nothing that worked has changed" is not available to a run that could not read part
+    // of itself. What IS true is said instead, with the size of the hole beside it, so the
+    // sentence cannot be quoted as an all-clear by anybody who reads only this far.
+    parts.push(
+      `SOME OF THIS PRODUCT COULD NOT BE READ AT ALL. Nothing that could be compared has changed: ${how.addresses} ${plural(how.addresses, 'address was', 'addresses were')} really put beside ${against} — and the ${plural(dead.length, 'journey', 'journeys')} named above ${plural(dead.length, 'is', 'are')} not among them, so a break inside ${plural(dead.length, 'it', 'them')} would look exactly like this.${reach}`,
     );
   } else if (findings.length === 0) {
-    parts.push(`Nothing that worked has changed. ${how.addresses} ${plural(how.addresses, 'address', 'addresses')} checked against ${against}.${reach}`);
+    // A WHOLE JOURNEY WITH NOTHING ON THE OTHER SIDE IS NOT A PASS, and the headline is the
+    // only line some readers get. This happens for real on the day somebody upgrades: the
+    // tool learns to watch something new — calling a library's exported functions, say — and
+    // the record made by the old version has no answers to hold the new ones against. The run
+    // said so, three sentences down, under a headline reading "Nothing that worked has
+    // changed". A broken library upgraded into this state read as clean. Measured 2026-08-31.
+    if (missed > 0) {
+      parts.push(
+        `PART OF THIS RUN HAD NOTHING TO BE COMPARED AGAINST. Nothing that could be compared has changed — but ${missed} of ${how.asked} ${plural(how.asked, 'journey', 'journeys')} had nothing on the old build's side to be held against, so ${plural(missed, 'it was', 'they were')} not checked at all, and a break inside ${plural(missed, 'it', 'them')} would look exactly like this. That is missing coverage rather than a failure — it is what a journey the old build never had looks like, and it is what an upgrade that learned to watch something new looks like. Ship once from a build you are happy with, or run with --paired, and the next check covers ${plural(missed, 'it', 'them')} properly. ${how.addresses} ${plural(how.addresses, 'address was', 'addresses were')} really put beside ${against}.${reach}`,
+      );
+    } else {
+      parts.push(`Nothing that worked has changed. ${how.addresses} ${plural(how.addresses, 'address', 'addresses')} checked against ${against}.${reach}`);
+    }
   } else {
     const sealed = findings.filter((f) => f.sealed).length;
     parts.push(