staysfixed 0.10.0 → 0.11.0

package/src/v2/ship.js

@@ -44,7 +44,7 @@ import { promisify } from 'node:util';
 import { EXIT, messageOf } from '../core/errors.js';
 import { say, warn, ok, blank, heading, setLogLevel } from '../core/log.js';
 import { findConfigFile, rootForConfig } from '../core/paths.js';
-import { openStore, ensureStore, listBuilds } from './store.js';
+import { openStore, ensureStore, listBuilds, listCaptures, latestCapture, productNameFor } from './store.js';
 import { cutReference, shouldCut, referenceHistory, currentReference } from './reference.js';
 
 const exec = promisify(execFile);
@@ -141,7 +141,13 @@ export async function onShip(opts = {}) {
   };
 
   try {
-    const product = opts.product ?? (await productName(root));
+    // ONE READER FOR THE NAME, SHARED WITH `check`. Ship used to work this out itself and
+    // read the settings only when the file ended in `.json` — and every settings file
+    // `staysfixed init` writes is JavaScript, so on a real project the two commands filed
+    // under two different names and never met. See `productNameFor` in store.js for the
+    // measurement.
+    const naming = await productNameFor(root, { product: opts.product });
+    const product = naming.name;
     result.product = product;
 
     const release = await detectRelease({ root, version: opts.version, tag: opts.tag, build: opts.build });
@@ -172,13 +178,37 @@ export async function onShip(opts = {}) {
       const because = unreadable.length > 0
         ? ` ${unreadable.length} of its stored ${unreadable.length === 1 ? 'record' : 'records'} could not be read, which may be why.`
         : '';
+      // WHAT THE PRODUCT IS STILL BEING COMPARED AGAINST, asked rather than assumed.
+      //
+      // This branch used to end every one of its sentences with "Nothing about <product> is
+      // being compared against anything yet", whether or not that was true. Measured on
+      // 2026-08-31: a project that had shipped once and had a reference sitting in its store
+      // was told exactly that after a second release nobody had checked — and the very next
+      // `staysfixed check` went on comparing against that reference and would have reported
+      // any regression it found. Telling somebody the safety net is off while it is on is the
+      // one direction of wrong answer that gets a broken build waved through, because a
+      // person who believes nothing is watching stops reading what it says.
+      const standing = await standingReference(store, product);
+      // WHICH NAME IT LOOKED UNDER, said out loud. "Stays Fixed had never seen this build"
+      // was true and useless: it named neither the drawer that was searched nor the fact
+      // that another drawer exists. When the settings and package.json disagree about what
+      // this product is called, that disagreement IS the answer — `check` files under one
+      // and `ship` looked under the other, and a project can sit like that for its whole
+      // life without either command mentioning it. Measured 2026-08-31 on a Windows app
+      // whose settings said `notepad` and whose package.json said `win-proof`.
+      const misnamed = await nameClash(store, naming);
       result.lines = [
         `${product} ${release.describe}`,
-        `Stays Fixed has no record of this build, so it did not become the reference. Nothing about ${product} is being compared against anything yet.${because}`,
-        'Run `staysfixed check` once before the next release and it will record itself from then on.',
+        `Stays Fixed has no record of a build of ${product}, so it did not become the reference. ${stillComparedAgainst(standing, product)}${because}`,
+        ...(misnamed ? [misnamed.line] : []),
+        misnamed
+          ? `Ship under the same name — \`staysfixed ship --product ${misnamed.other}\` — or make the two agree.`
+          : 'Run `staysfixed check` once before the next release and it will record itself from then on.',
         ...(unreadable.length > 0 ? [`What could not be read: ${unreadable.join('; ')}`] : []),
       ];
-      result.summary = `${product} shipped ${release.what}, but Stays Fixed had never seen this build, so what "working" means has not moved.${because} Run a check before the next release.`;
+      result.summary = misnamed
+        ? `${product} shipped ${release.what}, but there is no record of a build of ${product}: ${misnamed.short} Nothing has been compared, and nothing will be until the two names agree.`
+        : `${product} shipped ${release.what}, but Stays Fixed had never seen this build, so what "working" means has not moved.${because} ${stillComparedAgainst(standing, product)} Run a check before the next release.`;
       return result;
     }
 
@@ -195,14 +225,66 @@ export async function onShip(opts = {}) {
         `The reference did NOT move. ${result.refused}`,
         'Your release is unaffected — this only decides what future checks compare against.',
       ];
-      result.summary = `${product} shipped ${release.what}. What "working" means did NOT move: ${decision.why} Future checks still compare against the previous reference.`;
+      // "Still compare against the previous reference" was said whether or not there was a
+      // previous one. On a first release that is refused there is none, and the sentence
+      // quietly promises a safety net that does not exist yet — the same wrong answer as the
+      // no-record branch above, reached the other way round.
+      result.summary = `${product} shipped ${release.what}. What "working" means did NOT move: ${decision.why} ${stillComparedAgainst(await standingReference(store, product), product)}`;
       return result;
     }
 
+    // A RUN THAT OBSERVED NOTHING IS NOT AN ANSWER, and must never become the standard.
+    //
+    // Everything above asks whether a check CONCLUDED something: was there one, was it
+    // blocked, did it leave differences unaccounted for. None of those questions is "did the
+    // product actually do anything while it was being watched", and a run where every journey
+    // was refused answers all three the way a healthy one does. It was not blocked — it ran to
+    // the end. It found no differences — there was nothing to differ.
+    //
+    // Measured on 2026-08-31 on a three-route server with a `throw` at the top of it, so it
+    // could not start. `staysfixed check` correctly recorded three refusals — "not checked, the
+    // thing being observed fell over before it could be read" — and `staysfixed ship` answered
+    // "1.0.0 is now what poisonshop calls working. All 6 addresses it was watched at answered
+    // the same way twice." Two refusals do answer the same way twice.
+    //
+    // Both halves of what follows were then measured on that same project. Leave the server
+    // broken and the next check compares one refusal with the other, finds them equal and says
+    // "Nothing that worked has changed. 6 addresses checked" — a clean result about a product
+    // that cannot start, which is the one sentence this tool exists never to say. Fix the
+    // server and every route it now answers is reported as a difference nobody asked for: 13
+    // of them, and a route whose name says money or signing in lands in a class no agent is
+    // allowed to wave through, so the phantom goes to a person and stays there.
+    const saw = await whatTheRunActuallySaw(store, build.id);
+    const nothingWasObserved = saw.refused.length > 0 && saw.walked.length === 0;
+    if (nothingWasObserved && opts.force !== true) {
+      result.cut = false;
+      result.refused = [
+        `Refusing to make ${release.what} the standard for ${product}: the run behind it never got the product to do anything.`,
+        `All ${saw.refused.length} of the ${plural(saw.refused.length, 'journey', 'journeys')} on record for this build came back refused — it did not start, or could not be reached — so what would be written down as "working" is the words "could not be read", ${saw.refused.length === 1 ? 'once' : `${saw.refused.length} times over`}: ${saw.refused.join(', ')}.`,
+        'A reference made of refusals is a reference that says nothing: every later check would find no answer on either side of every address, so nothing about this product would be watched at all, and the run would say so on every line of its coverage list instead of telling you anything.',
+        'Get the product running, run `staysfixed check`, and ship again. Or force it, and this refusal is kept on the record beside the reference.',
+      ].join(' ');
+      result.lines = [
+        `${product} ${release.describe}`,
+        `The reference did NOT move. ${result.refused}`,
+        'Your release is unaffected — this only decides what future checks compare against.',
+      ];
+      result.summary = `${product} shipped ${release.what}. What "working" means did NOT move: nothing was actually observed of this build — all ${saw.refused.length} of its ${plural(saw.refused.length, 'journey', 'journeys')} were refused. ${stillComparedAgainst(await standingReference(store, product), product)}`;
+      return result;
+    }
+
+    // A cut forced past the gate above has to SAY it was, on the record and for good.
+    // `cutReference` stamps `forced` only when the store's own decision refused, and the store
+    // knows nothing about refused journeys — so without this the one cut that most needs a
+    // reason beside it would be the one indistinguishable from a healthy release, months later
+    // when somebody is asking why the reference is full of "could not be read".
+    const why = opts.why ?? opts.note ?? release.describe;
     const cut = await cutReference(store, {
       product,
       build,
-      why: opts.why ?? opts.note ?? release.describe,
+      why: nothingWasObserved
+        ? `${why} — FORCED: nothing was observed of this build. All ${saw.refused.length} of its ${plural(saw.refused.length, 'journey', 'journeys')} refused (${saw.refused.join(', ')}), so this reference records "could not be read" as what the product does.`
+        : why,
       setBy: opts.setBy ?? 'staysfixed ship',
       force: opts.force === true,
       at: opts.at,
@@ -231,6 +313,23 @@ export async function onShip(opts = {}) {
       // ran only once, so part of this reference has no steadiness record behind it.
       ...(cut.stability.measuredJourneys < cut.stability.journeys ? [cut.stability.note] : []),
       'Nobody has to approve anything. The next check compares against this.',
+      // A reference with holes in it is still worth cutting, and is not worth cutting
+      // quietly. A journey that refused is going into the standard as the words "could not be
+      // read", so what it does is not in this reference at all, and the day it runs properly
+      // every one of its answers is reported as a difference nobody caused. Said here because
+      // the coverage caveat below counts doors, not refusals, and these are the ones that will
+      // come back as findings rather than as a gap.
+      ...(saw.refused.length > 0 && saw.walked.length > 0
+        ? [
+            `${saw.refused.length} of ${saw.refused.length + saw.walked.length} ${plural(saw.refused.length + saw.walked.length, 'journey', 'journeys')} refused and ${plural(saw.refused.length, 'is', 'are')} being recorded as part of this reference without having observed anything: ${saw.refused.join(', ')}. What ${plural(saw.refused.length, 'it does is', 'those do is')} not in the standard, so nothing behind ${plural(saw.refused.length, 'it', 'them')} is being watched until ${plural(saw.refused.length, 'it runs', 'they run')} — a check will say so in its coverage list rather than reporting it as a change.`,
+          ]
+        : []),
+      // And the forced version of the same thing, said as plainly as it deserves.
+      ...(nothingWasObserved
+        ? [
+            `This was FORCED. Nothing was observed of this build — all ${saw.refused.length} of its ${plural(saw.refused.length, 'journey', 'journeys')} refused (${saw.refused.join(', ')}) — so what "working" now means for ${product} is the words "could not be read". Until it is shipped again from a run that saw something, a check of this product cannot tell you anything.`,
+          ]
+        : []),
       // Said in the same breath as the good news, exactly as every other surface says it.
       ...(missed ? [missed] : []),
     ];
@@ -279,6 +378,114 @@ async function whatTheCheckMissed(store) {
   }
 }
 
+/**
+ * The channels only a running product can fill.
+ *
+ * The same line coverage.js draws, one notch further along. `contract` is the code being
+ * READ — routes and channels listed out of the source — and a door read out of a file has
+ * never been opened, so it can never be the evidence that anything ran. `counters` is
+ * arithmetic done on whatever was found, including on the contract, so it cannot be that
+ * evidence either: a source-only walk of this very repository files a `counters` observation
+ * saying it read two environment variables, and nothing was started.
+ *
+ * What is left is the product doing something where somebody could watch: what it gave back,
+ * what it printed, what it changed, what it drew, what a screen reader would read.
+ */
+const CHANNELS_ONLY_A_RUNNING_PRODUCT_FILLS = new Set(['meaning', 'effects', 'complaints', 'results', 'pixels']);
+
+/**
+ * Which of this build's journeys really watched the product, and which only refused.
+ *
+ * A journey counts as WALKED when its newest stored recording holds at least one observation
+ * that a running product had to produce and that was not refused. It counts as REFUSED when
+ * it holds observations of that kind and every one of them is a refusal — the adapter was
+ * asked, and said it could not. A journey with neither — the source reader, which only lists
+ * doors — is in neither list, because it is neither evidence that the product ran nor
+ * evidence that it would not.
+ *
+ * The newest recording per journey is the one read, because the newest recording per journey
+ * is what a later check compares against. Reading them all would say something truer about
+ * history and nothing truer about what this reference is going to mean.
+ *
+ * It never throws. A record that will not open leaves the journey out of both lists, which
+ * lands on the behaviour this file had before — the cut goes ahead — rather than turning a
+ * damaged file into a blocked release.
+ *
+ * @param {Store} store
+ * @param {string} buildId
+ * @returns {Promise<{walked: string[], refused: string[]}>}  Journey names, sorted.
+ */
+async function whatTheRunActuallySaw(store, buildId) {
+  /** @type {string[]} */
+  const walked = [];
+  /** @type {string[]} */
+  const refused = [];
+  try {
+    const refs = await listCaptures(store, { buildId });
+    for (const journey of [...new Set(refs.map((r) => r.journey))].sort()) {
+      const capture = await latestCapture(store, { buildId, journey });
+      if (!capture) continue;
+      const fromTheProduct = capture.observations.filter((o) => CHANNELS_ONLY_A_RUNNING_PRODUCT_FILLS.has(o.channel));
+      if (fromTheProduct.length === 0) continue;
+      if (fromTheProduct.some((o) => o.meta?.refused !== true)) walked.push(journey);
+      else refused.push(journey);
+    }
+  } catch {
+    // See above: what could not be read is left out, never guessed at in either direction.
+  }
+  return { walked, refused };
+}
+
+/**
+ * What this product currently compares against, or an honest admission that we cannot tell.
+ *
+ * Three answers, not two. 'none' and a real reference are the easy ones; a store that will
+ * not open is the third, and collapsing it into 'none' is what produced the sentence this
+ * helper exists to stop — a confident "nothing is being compared" from a reader that never
+ * managed to look.
+ *
+ * @param {Store} store
+ * @param {string} product
+ * @returns {Promise<{name: string, at: string}|'none'|'unknown'>}
+ */
+async function standingReference(store, product) {
+  try {
+    const current = await currentReference(store, product);
+    if (!current) return 'none';
+    return {
+      name: current.cut?.build?.version ?? current.pointer.buildId,
+      at: current.pointer.setAt.slice(0, 10),
+    };
+  } catch {
+    return 'unknown';
+  }
+}
+
+/**
+ * One sentence saying whether the safety net is on, for a release that did not move it.
+ *
+ * @param {{name: string, at: string}|'none'|'unknown'} standing
+ * @param {string} product
+ * @returns {string}
+ */
+function stillComparedAgainst(standing, product) {
+  if (standing === 'none') return `Nothing about ${product} is being compared against anything yet.`;
+  if (standing === 'unknown') {
+    return `What ${product} compares against could not be read just now, so this cannot say whether a standard is in place — check with \`staysfixed ship --history\` before trusting either answer.`;
+  }
+  return `Checks of ${product} go on comparing against ${standing.name}, the build shipped on ${standing.at} — that is still the standard, so a regression this release introduced would be reported rather than adopted.`;
+}
+
+/**
+ * @param {number} n
+ * @param {string} one
+ * @param {string} many
+ * @returns {string}
+ */
+function plural(n, one, many) {
+  return n === 1 ? one : many;
+}
+
 // ---------------------------------------------------------------------------
 
 /**
@@ -519,27 +726,66 @@ function projectRoot(from) {
   return config ? rootForConfig(config) : start;
 }
 
+/*
+ * `productName` used to live here and is gone on purpose. It read `product` out of the
+ * settings only when the file ended in `.json`, which is a shape `staysfixed init` never
+ * writes, so ship and check named the same product two different things and filed into two
+ * drawers that never meet. The one reader both commands use is `productNameFor` in store.js,
+ * next to the keys it decides — see the measurement written out there.
+ */
+
 /**
- * Which product is this? The settings file first, because one repo builds five things and
- * only the settings file knows what they are called.
+ * Is there a record of this build sitting under a DIFFERENT name for the same folder?
  *
- * @param {string} root
- * @returns {Promise<string>}
+ * Asked only when nothing was found under the name we resolved, and it answers the one
+ * question the old "Stays Fixed had never seen this build" never did: whether the build is
+ * missing or merely filed elsewhere. A project whose settings and package.json disagree hits
+ * this on every release and on every check, forever, and nothing else in the tool says a word
+ * about it.
+ *
+ * It reads the store and nothing else — no fingerprinting, no git — because the point is to
+ * name the clash, not to bless anything under a name nobody asked for. Cutting the reference
+ * under the other name would be the tool choosing what a product is called, and that is a
+ * decision it does not get to make.
+ *
+ * @param {Store} store
+ * @param {{name: string, settings: string|null, package: string|null, configFile: string|null}} naming
+ * @returns {Promise<{other: string, line: string, short: string}|null>}
  */
-async function productName(root) {
-  const configFile = findConfigFile(root);
-  if (configFile && configFile.endsWith('.json')) {
+async function nameClash(store, naming) {
+  /** @type {{name: string, where: string}[]} */
+  const others = [];
+  if (naming.settings && naming.settings !== naming.name) {
+    others.push({ name: naming.settings, where: `your settings file${naming.configFile ? ` (${path.basename(naming.configFile)})` : ''} calls this product` });
+  }
+  if (naming.package && naming.package !== naming.name && !others.some((o) => o.name === naming.package)) {
+    others.push({ name: naming.package, where: 'package.json calls this product' });
+  }
+  const here = path.basename(path.resolve(store.root));
+  if (here !== naming.name && !others.some((o) => o.name === here)) {
+    others.push({ name: here, where: 'this folder is called' });
+  }
+
+  for (const other of others) {
+    /** @type {{fingerprint: BuildFingerprint}[]} */
+    let builds = [];
     try {
-      const parsed = JSON.parse(await fsp.readFile(configFile, 'utf8'));
-      if (typeof parsed?.product === 'string' && parsed.product) return parsed.product;
+      builds = await listBuilds(store, { product: other.name });
     } catch {
-      // A settings file nobody can parse is somebody else's problem to report. Falling
-      // through to the package name keeps the release recorded either way.
+      // A store that will not list is not this function's problem to report; the caller has
+      // already said what it could not read.
+      continue;
     }
+    if (builds.length === 0) continue;
+    return {
+      other: other.name,
+      line:
+        `There ${builds.length === 1 ? 'IS 1 stored build' : `ARE ${builds.length} stored builds`} here, filed under "${other.name}" — ${other.where} that. ` +
+        `\`staysfixed check\` records under one name and this release looked under "${naming.name}", so the two never meet: every check says there is nothing on record as working, and every ship says it has never seen the build.`,
+      short: `${builds.length} ${builds.length === 1 ? 'build is' : 'builds are'} on record under "${other.name}" instead — ${other.where} that, and check files under it.`,
+    };
   }
-  const pkg = await packageJson(root);
-  if (typeof pkg?.name === 'string' && pkg.name) return pkg.name;
-  return path.basename(root);
+  return null;
 }
 
 /**
@@ -741,7 +987,10 @@ export async function run(ctx) {
  */
 async function printHistory(ctx, root, asJson) {
   const store = openStore({ root });
-  const product = ctx.str('product') ?? (await productName(root));
+  // The same one reader as the ship path itself. `staysfixed ship --history` used to work the
+  // name out separately, so on a project whose settings are JavaScript it printed the history
+  // of a product nothing had ever been filed under and answered "no references yet".
+  const product = (await productNameFor(root, { product: ctx.str('product') ?? undefined })).name;
   const history = await referenceHistory(store, product, { includeArchive: true });
   const current = await currentReference(store, product);
 
@@ -751,6 +1000,16 @@ async function printHistory(ctx, root, asJson) {
   }
 
   if (history.length === 0) {
+    // An empty log is not the same fact as an empty store. The pointer is what a check
+    // actually reads, and the two can come apart — a log truncated by hand, a store restored
+    // without it. Announcing "there is nothing to compare any build against" while the
+    // pointer sits there is the same lie the ship summary used to tell, one command over.
+    if (current) {
+      warn(`${product} has no record of when its reference was cut, so this cannot list the history.`);
+      say(current.note);
+      say('Checks are still comparing against that build. Ship once more and the history starts again from there.');
+      return EXIT.ok;
+    }
     warn(`${product} has never had a reference cut, so there is nothing to compare any build against yet.`);
     say('Ship once with `staysfixed ship` at the end of your release script and the next check has a standard to work from.');
     return EXIT.ok;
@@ -761,6 +1020,11 @@ async function printHistory(ctx, root, asJson) {
     const marker = current?.pointer.buildId === cut.buildId ? '→ ' : '  ';
     say(`${marker}${cut.at.slice(0, 16).replace('T', ' ')}  ${cut.build?.version ?? cut.buildId}${cut.forced ? '  (FORCED)' : ''}`);
     say(`     ${cut.summary}`);
+    // The reason the cut was made, which the summary never carries. It holds the person's own
+    // words about the release, and — the case this is here for — the sentence saying a cut was
+    // forced past a run that observed nothing. Dropping it left the only surface that answers
+    // "why is this the standard" unable to answer it.
+    if (cut.why && cut.why.trim() && cut.why.trim() !== cut.summary.trim()) say(`     Why: ${cut.why.trim()}`);
   }
   return EXIT.ok;
 }

package/src/v2/store.js

@@ -33,9 +33,10 @@ import fs from 'node:fs';
 import fsp from 'node:fs/promises';
 import path from 'node:path';
 import crypto from 'node:crypto';
-import { safeName } from '../core/paths.js';
+import { safeName, findConfigFile } from '../core/paths.js';
 import { StaysFixedError } from '../core/errors.js';
 import { sortObservations } from './observation.js';
+import { asMarkedValue } from './refusal.js';
 
 /**
  * @typedef {import('./types.js').Store} Store
@@ -82,6 +83,92 @@ function buildDir(store, buildId) {
   return path.join(store.buildsDir, safeName(buildId));
 }
 
+// ---------------------------------------------------------------------------
+// What this product is called — the key everything in here is filed under
+// ---------------------------------------------------------------------------
+
+/**
+ * Which product is this?
+ *
+ * IT LIVES HERE BECAUSE THE NAME IS THE STORE'S KEY. References are filed under it, builds
+ * are listed by it, and two commands that work it out two different ways do not disagree
+ * politely — they file into two different drawers and never meet again.
+ *
+ * Which is exactly what happened. Until 2026-08-31 `staysfixed ship` read `product` out of
+ * the settings file ONLY when that file ended in `.json`, and every settings file
+ * `staysfixed init` writes is JavaScript. So on a real project — measured driving a native
+ * Windows app over ssh — the settings said `product: "notepad"`, package.json said
+ * `"win-proof"`, `check` recorded the run under `notepad`, `ship` blessed under `win-proof`
+ * and answered "Stays Fixed had never seen this build", and every later check answered
+ * "no build of notepad is on record as working" and exited 2. Forever: the project could
+ * ship and check for its whole life and never once compare anything, with nothing anywhere
+ * saying the two names disagreed. `ship --product notepad` cut the reference instantly,
+ * which is the proof that the name was the whole cause.
+ *
+ * The order is the one `check` has always used: what the caller was told, then the settings
+ * file, then package.json, then the folder. Everything a caller needs to EXPLAIN the answer
+ * comes back too, because "no record of this build" was true and useless — "no record of a
+ * build of win-proof; your settings call this product notepad" names the bug in one line.
+ *
+ * It never throws. A settings file that will not load leaves `settings` null and the answer
+ * falls through, which is the behaviour both callers had before.
+ *
+ * @param {string} root
+ * @param {{product?: string, configFile?: string|null}} [opts]
+ * @returns {Promise<{name: string, from: 'told'|'settings'|'package'|'folder', settings: string|null, package: string|null, configFile: string|null}>}
+ */
+export async function productNameFor(root, opts = {}) {
+  const configFile = opts.configFile ?? findConfigFile(root) ?? null;
+  const settings = await productInSettings(configFile);
+  const pkg = await nameInPackage(root);
+  const told = typeof opts.product === 'string' && opts.product ? opts.product : null;
+  const name = told ?? settings ?? pkg ?? path.basename(path.resolve(root));
+  /** @type {'told'|'settings'|'package'|'folder'} */
+  const from = told ? 'told' : settings ? 'settings' : pkg ? 'package' : 'folder';
+  return { name, from, settings, package: pkg, configFile };
+}
+
+/**
+ * The `product` field out of a settings file of any shape.
+ *
+ * JSON is parsed and JavaScript is imported, which is what `check` does and always did. The
+ * import is the half that was missing from ship: `.js` and `.mjs` are the two shapes
+ * `staysfixed init` writes, so a JSON-only reader covers essentially no real project.
+ *
+ * @param {string|null} configFile
+ * @returns {Promise<string|null>}
+ */
+async function productInSettings(configFile) {
+  if (!configFile) return null;
+  try {
+    if (configFile.endsWith('.json')) {
+      const parsed = JSON.parse(await fsp.readFile(configFile, 'utf8'));
+      return typeof parsed?.product === 'string' && parsed.product ? parsed.product : null;
+    }
+    const module = await import(`file://${configFile}`);
+    const raw = module.default ?? module.config ?? module;
+    return typeof raw?.product === 'string' && raw.product ? raw.product : null;
+  } catch {
+    // A settings file nobody can load is somebody else's problem to report — `check` says so
+    // loudly about the same file. Falling through keeps the release recorded under SOME name
+    // rather than failing somebody's release over their settings.
+    return null;
+  }
+}
+
+/**
+ * @param {string} root
+ * @returns {Promise<string|null>}
+ */
+async function nameInPackage(root) {
+  try {
+    const pkg = JSON.parse(await fsp.readFile(path.join(root, 'package.json'), 'utf8'));
+    return typeof pkg?.name === 'string' && pkg.name ? pkg.name : null;
+  } catch {
+    return null;
+  }
+}
+
 /**
  * A sortable capture id: when it ran, and which of the two runs it was.
  * @param {CaptureRun} run
@@ -497,7 +584,19 @@ export async function loadCapture(store, where) {
       continue;
     }
     if (typeof parsed?.path === 'string' && typeof parsed?.channel === 'string') {
-      observations.push(/** @type {Observation} */ (parsed));
+      // A REFUSAL COMES BACK OFF THE DISK AS A REFUSAL, not as a sentence that happens to
+      // begin "not checked —".
+      //
+      // Every store on every machine holds refusals written as plain strings, because that
+      // is what the adapters wrote before there was a kind for them. A string is comparable,
+      // and on 2026-08-31 two of them compared equal and a product that threw on its first
+      // line came back "Nothing that worked has changed". Marking it here, at the one door
+      // every stored observation comes through, means the comparison, the reference and the
+      // report all see the same kind whatever age the file is — and nothing on disk is
+      // rewritten, so a store stays readable by an older copy of the tool.
+      const observation = /** @type {Observation} */ (parsed);
+      const marked = asMarkedValue(observation.value);
+      observations.push(marked === observation.value ? observation : { ...observation, value: marked });
     } else {
       unreadable++;
     }

package/src/v2/types.js

@@ -239,6 +239,11 @@
  *                                    False when we had no stability record for the reference,
  *                                    so `newlyUnstable` is empty for lack of evidence rather
  *                                    than because nothing became unstable.
+ * @property {boolean} [sameBuild]    True when the build being checked and the build on record
+ *                                    as working are the same build. Nothing has been edited, so
+ *                                    the two runs compared are two runs of ONE build and no
+ *                                    difference between them can be a change. Everything found
+ *                                    is in `noise`, still counted and still named.
  * @property {boolean} [couldNotTell] True when the wobble measurement was too big to be a
  *                                    measurement — the same build answered differently at
  *                                    most of its own addresses, so subtracting it subtracts

package/src/v2/waiver.js

@@ -174,8 +174,15 @@ const KEEP_EXPIRED = 50;
 /**
  * Try to record a difference as intended.
  *
+ * `audience` changes no rule and no verdict — every gate below runs identically whoever
+ * asked — and reaches exactly one sentence: the sealed-class refusal, which used to open
+ * "No agent can wave this through". Read by a person who has just typed `staysfixed waive`
+ * that is an answer about somebody else, and it invites the obvious follow-up: fine, but how
+ * do I? The rule is that NOBODY waives a sealed class, and it has to say so to whoever is
+ * reading. Measured 2026-08-31, when `waive` first became a command a person could type.
+ *
  * @param {Store} store
- * @param {{product: string, finding: Finding, why: string, intentId?: string, check?: CheckStamp, guards?: string[], by?: string}} what
+ * @param {{product: string, finding: Finding, why: string, intentId?: string, check?: CheckStamp, guards?: string[], by?: string, audience?: 'agent'|'person'}} what
  * @returns {Promise<WaiverDecision>}
  */
 export async function waive(store, what) {
@@ -196,7 +203,7 @@ export async function waive(store, what) {
   // anything else so that no amount of good paperwork can get a look-in first.
   const sealed = classify(finding, { guards: what.guards ?? [] });
   if (sealed) {
-    return { ok: false, gate: 'sealed', say: sayRefusal(sealed, finding), sealed };
+    return { ok: false, gate: 'sealed', say: sayRefusal(sealed, finding, what.audience), sealed };
   }
 
   const fingerprint = fingerprintFinding(finding);

package/src/watch/panel.js

@@ -1456,6 +1456,12 @@ const SCRIPT = `
     if (kind === 'guard') {
       if (status === 'passed') return 'still holds';
       if (status === 'skipped') return 'left out on purpose';
+      // Three different things wear the status 'failed', and calling all three "broken
+      // again" states as a fact something nobody knows. A guard that ran out of time did
+      // not answer the question, and a guard that asserted nothing never asked it. Saying
+      // a bug is back on a healthy tree is how a person learns to stop reading this panel.
+      if (ev.timedOut) return 'ran out of time, so nobody knows whether that bug is back';
+      if (ev.assertedNothing) return 'asked nothing, so it proved nothing';
       return ev.message || 'this one is broken again';
     }
     switch (status) {
@@ -1484,6 +1490,8 @@ const SCRIPT = `
     if (kind === 'guard') {
       if (status === 'passed') return 'still holds';
       if (status === 'skipped') return 'left out';
+      if (ev.timedOut) return 'no answer';
+      if (ev.assertedNothing) return 'asked nothing';
       return 'broken again';
     }
     switch (status) {
@@ -3109,7 +3117,10 @@ const SCRIPT = `
     entry.outText = outcomeText(kind, ev);
     if (entry.verdict) entry.verdict.textContent = shortOutcome(kind, ev);
     entry.failedAt = (kind === 'guard' && ev.status === 'failed' && ev.failedAt) ? ev.failedAt : '';
-    entry.story = (kind === 'guard' && ev.status === 'failed' && ev.because) ? ev.because : '';
+    // The story is the story of the BUG this guard exists to catch, and printing it under a
+    // guard that never got an answer says that bug is back. It only belongs under a guard
+    // that actually failed its own claim.
+    entry.story = (kind === 'guard' && ev.status === 'failed' && ev.because && !ev.timedOut && !ev.assertedNothing) ? ev.because : '';
     if (typeof ev.durationMs === 'number') tweenTo(entry.time, ev.durationMs, fmt);
     entry.tone = tone;
     redraw(entry);