retake-demos 0.13.1 → 0.13.2

package/AGENTS.md

@@ -235,9 +235,14 @@ Most real demos start behind a sign-in. The agent never sees a password:
   control where nothing is wrong, then reports recall and false positives.
   Expensive: nine takes, about ten minutes, needs the app running. The report
   it leaves is cheap to read, and **you should read it before telling anybody
-  how much a sweep finding is worth.** Its stated limits travel with it: the
-  seeds were written by somebody who has read the checklist, so recall is an
-  upper bound.
+  how much a sweep finding is worth.** Its stated limits travel with it, and
+  all four belong in anything you say about the numbers: the seeds were written
+  by somebody who has read the checklist, so recall is an upper bound; injected
+  faults are cleaner than real ones; the run names the checklist items nothing
+  seeds, and says nothing whatever about those; and a run whose control did not
+  record cleanly measured nothing at all and exits 3 rather than printing a
+  reassuring zero. From MCP you can only READ the last measurement — making one
+  is a terminal command, because it records for ten minutes.
 - `retake intent` — what the product IS, in the builder's words: what it does,
   who uses it, and what about it is deliberate. Every visual check reads it.
   Without it they judge the app as a generic web page — measured on a real

package/dist/cli.js

@@ -45,7 +45,7 @@ import { notes } from "./ext/notes.js";
 import { sense } from "./ext/sense.js";
 import { sweep } from "./ext/sweep.js";
 import { TEMPLATE, readIntent, writeIntent } from "./ext/intent.js";
-import { planCalibration, report } from "./ext/calibrate.js";
+import { planCalibration, report, usable } from "./ext/calibrate.js";
 import { checkFlags, flag, unflag } from "./ext/flags.js";
 import { describeOrphans, findOrphans, healOrphans } from "./ext/heal.js";
 import { SHAPES, describePlan, describeTrials, planDestroy, refuseToRun, tryCandidates } from "./ext/destroy.js";
@@ -399,27 +399,55 @@ program
     if (opts.plan)
         return;
     const results = [];
+    /** Sweep once, and give back what it said. */
+    const look = async (m, dir, fresh) => (await sweep(m, dir, () => { }, { demosDir: path.resolve("demos"), fresh })).frames.flatMap((f) => f.issues.map((i) => i.kind));
+    let stability = null;
     for (const v of plan.variants) {
         const dir = path.join(plan.root, v.name);
         say(`\n${v.name}${v.defect ? ` — ${v.defect.looks}` : ""}`);
         try {
             const take = await record(v.manifest, { outDir: dir, manifestDir: loaded.dir, headed: false, log: () => { } });
             await render(v.manifest, take, dir, { log: () => { }, noMaster: true });
-            const s = await sweep(v.manifest, dir, () => { }, { demosDir: path.resolve("demos") });
-            const took = true; // the seed proved itself in the page, or the take threw
-            const kinds = s.frames.flatMap((f) => f.issues.map((i) => i.kind));
+            // A recording that fell over, recorded nothing, or produced no frames
+            // measures nothing — whichever end of it broke. Asking sweep about it
+            // and reporting the empty answer is how a run against an app that was
+            // not even running came back reading "none on the control".
+            const fit = usable(dir, take);
+            if (!fit.ok) {
+                results.push({ variant: v.name, defect: v.defect, kinds: [], found: false, seeded: false, why: fit.why, other: 0 });
+                say(`  → not measured: ${fit.why}`);
+                continue;
+            }
+            const kinds = await look(v.manifest, dir, false);
             const found = !v.defect ? false : kinds.some((k) => k.toUpperCase().startsWith(v.defect.expect.split(" ")[0]));
-            results.push({ variant: v.name, defect: v.defect, kinds, found: found && took, seeded: took, other: v.defect ? kinds.filter((k) => !k.toUpperCase().startsWith(v.defect.expect.split(" ")[0])).length : 0 });
-            say(`  → ${kinds.join(", ") || "nothing"}${v.defect && !took ? "   (the seed did not land — nothing was asked of the check)" : ""}`);
+            results.push({ variant: v.name, defect: v.defect, kinds, found, seeded: true, other: v.defect ? kinds.filter((k) => !k.toUpperCase().startsWith(v.defect.expect.split(" ")[0])).length : 0 });
+            say(`  → ${kinds.join(", ") || "nothing"}`);
+            // The control, asked the same question about the same frames a second
+            // time. Judges are not deterministic, and a harness that never checks
+            // this cannot tell a real finding from a coin landing heads.
+            if (!v.defect) {
+                say("  asking the control again, to see whether the answer holds");
+                stability = { first: kinds, again: await look(v.manifest, dir, true) };
+                say(`  → ${stability.again.join(", ") || "nothing"}`);
+            }
         }
         catch (e) {
-            results.push({ variant: v.name, defect: v.defect, kinds: [], found: false, seeded: !/seed did not take/.test(String(e.message)), other: 0, error: String(e.message).split("\n")[0].slice(0, 90) });
-            say(`  → could not run: ${String(e.message).split("\n")[0].slice(0, 90)}`);
+            const msg = String(e.message).split("\n")[0].slice(0, 90);
+            results.push({ variant: v.name, defect: v.defect, kinds: [], found: false, seeded: false, why: `the run threw — ${msg}`, other: 0, error: msg });
+            say(`  → could not run: ${msg}`);
         }
     }
-    for (const l of report(results))
+    for (const l of report(results, stability))
         say(l);
-    fs.writeFileSync(path.join(plan.root, "report.json"), JSON.stringify({ at: new Date().toISOString(), demo: loaded.manifest.name, results }, null, 2) + "\n");
+    fs.writeFileSync(path.join(plan.root, "report.json"), JSON.stringify({ at: new Date().toISOString(), demo: loaded.manifest.name, results, stability }, null, 2) + "\n");
+    // The false-positive rate is the number people act on. If the control did
+    // not record, this run produced no number at all, and exiting 0 says the
+    // opposite.
+    const control = results.find((r) => !r.defect);
+    if (!control?.seeded) {
+        process.exitCode = 3;
+        say("\nnothing was measured — fix the run before quoting any of this.");
+    }
 });
 program
     .command("intent")

package/dist/dryrun.js

@@ -266,8 +266,17 @@ export async function dryRun(m, manifestDir, log, opts = {}) {
                     // records perfectly. The starter demo shipped with `retake init` hits
                     // it, so a new person's first dry run failed on a demo that works.
                     case "scroll":
-                        if (step.to && step.to !== "top" && step.to !== "bottom")
+                        // And actually scroll. Skipping it left the page at the top while
+                        // every later step ran, so a dry run rehearsed a different page from
+                        // the one the recording would see.
+                        if (step.to === "top")
+                            await page.evaluate(() => window.scrollTo(0, 0));
+                        else if (step.to === "bottom")
+                            await page.evaluate(() => window.scrollTo(0, document.body.scrollHeight));
+                        else if (step.to) {
                             await page.locator(step.to).first().boundingBox({ timeout: short });
+                            await page.locator(step.to).first().scrollIntoViewIfNeeded({ timeout: short });
+                        }
                         break;
                     case "upload":
                         await page.locator(step.selector).first().waitFor({ timeout: short });

package/dist/ext/calibrate.js

@@ -45,6 +45,7 @@ import fs from "node:fs";
 import path from "node:path";
 import YAML from "yaml";
 import { createHash } from "node:crypto";
+import { LOOK_FOR } from "./sweep.js";
 /**
  * Deliberately mechanical. Every one of these is visible to a person in one
  * glance, which is the bar: if a human cannot see it in the frame, a miss is
@@ -74,7 +75,12 @@ export const DEFECTS = [
     },
     {
         name: "unreadable-contrast",
-        proof: "getComputedStyle(document.body).color.replace(/\\\\s/g,'') === 'rgb(233,235,228)'",
+        // Was `.replace(/\\s/g,'')`, which after string escaping built a regex for
+        // a literal backslash followed by "s" — so the spaces in "rgb(233, 235,
+        // 228)" were never stripped, the proof was never true, and this seed
+        // reported "did not land" on every app it was ever run against. It was
+        // counted as one of eight for two releases. No regex now.
+        proof: "getComputedStyle(document.body).color.split(' ').join('') === 'rgb(233,235,228)'",
         expect: "CONTRAST",
         looks: "body text almost the same colour as the page behind it",
         css: "body,p,li,span{color:#e9ebe4!important}",
@@ -139,6 +145,12 @@ export const lab = (outRoot, demo) => path.join(outRoot, ".calibrate", demo);
 export function planCalibration(m, outRoot, opts = {}) {
     const root = lab(outRoot, m.name);
     fs.mkdirSync(root, { recursive: true });
+    // `--only typo` used to match nothing and run a control alone, then print a
+    // recall line reading "0 of 0" — which is not a failure, it is a measurement
+    // of nothing wearing the clothes of one.
+    const unknown = (opts.only ?? []).filter((n) => !DEFECTS.some((d) => d.name === n));
+    if (unknown.length)
+        throw new Error(`no such defect: ${unknown.join(", ")} — try ${DEFECTS.map((d) => d.name).join(", ")}`);
     const want = opts.only?.length ? DEFECTS.filter((d) => opts.only.includes(d.name)) : DEFECTS;
     const variants = [];
     const write = (name, defect) => {
@@ -166,6 +178,17 @@ export function planCalibration(m, outRoot, opts = {}) {
                 { action: "evaluate", script: `{ if (!(${defect.proof})) throw new Error("the ${defect.name} seed did not take on this app"); }` },
                 { action: "wait", ms: 300 },
             ];
+            // And again at the END. The setup proof says the seed was on the page
+            // before the camera rolled; it says nothing about whether it was still
+            // there for the frames that were actually judged. A single-page app that
+            // navigates or re-renders can drop it halfway through, and every frame
+            // after that point asks the check to find something that is not there.
+            // Failing the step is right: a run that lost its seed is not a miss, it
+            // is not a measurement.
+            clone.steps = [
+                ...clone.steps,
+                { action: "evaluate", script: `{ if (!(${defect.proof})) throw new Error("the ${defect.name} seed was gone by the end of the run"); }` },
+            ];
         }
         const file = path.join(root, `${name}.yaml`);
         fs.writeFileSync(file, [
@@ -220,8 +243,40 @@ export function landed(controlDir, variantDir) {
         return true; // cannot tell; do not accuse the harness
     return a.join() !== b.join();
 }
+/**
+ * Is this recording fit to measure anything at all?
+ *
+ * It was not asked. A control recorded against an app that was not running
+ * came back with an empty timeline, `ok: false` and no frames — and the report
+ * said "FALSE POSITIVES none on the control", which is the single number this
+ * harness exists to produce. Nothing was wrong with the control because
+ * nothing had happened in it. A blank measurement that reads as a clean one is
+ * worse than no measurement, and it exited 0.
+ */
+export function usable(dir, take) {
+    if (!take)
+        return { ok: false, why: "nothing was recorded" };
+    if (!take.timeline?.length)
+        return { ok: false, why: "the run recorded no steps at all" };
+    if (take.ok === false)
+        return { ok: false, why: "the run did not finish cleanly" };
+    let stills = 0;
+    try {
+        stills = fs.readdirSync(path.join(dir, "stills")).filter((f) => /\.(png|jpe?g)$/i.test(f)).length;
+    }
+    catch { /* none */ }
+    if (!stills)
+        return { ok: false, why: "the run produced no frames to look at" };
+    return { ok: true, why: "" };
+}
+/** The `sweep` items nothing here seeds, named rather than left to arithmetic. */
+export function uncovered() {
+    const seeded = new Set(DEFECTS.map((d) => d.expect.toUpperCase()));
+    return LOOK_FOR.map((l) => l.split(" — ")[0].trim())
+        .filter((kind) => !seeded.has(kind.toUpperCase()));
+}
 /** Recall, false positives, and the sentence that says what they mean. */
-export function report(rs) {
+export function report(rs, stability = null) {
     const all = rs.filter((r) => r.defect);
     const seeded = all.filter((r) => r.seeded);
     const unseeded = all.filter((r) => !r.seeded);
@@ -231,27 +286,56 @@ export function report(rs) {
     out.push("");
     out.push(`RECALL   ${found} of ${seeded.length} defects that actually appeared were found`);
     for (const r of seeded) {
-        out.push(`  ${r.found ? "✓" : "✗"} ${r.variant.padEnd(20)} wanted ${String(r.defect.expect).padEnd(19)} got ${r.kinds.join(", ") || (r.error ? `— ${r.error}` : "nothing")}`);
+        out.push(`  ${r.found ? "\u2713" : "\u2717"} ${r.variant.padEnd(20)} wanted ${String(r.defect.expect).padEnd(19)} got ${r.kinds.join(", ") || (r.error ? `\u2014 ${r.error}` : "nothing")}`);
     }
     if (unseeded.length) {
         out.push("");
-        out.push(`NOT MEASURED   ${unseeded.length} seed(s) produced no visible change, so nothing was asked of the check:`);
+        out.push(`NOT MEASURED   ${unseeded.length} of ${all.length} seeded runs asked the check nothing:`);
         for (const r of unseeded)
-            out.push(`  — ${r.variant.padEnd(20)} the injection did not land. Fix the seed, not the checklist.`);
+            out.push(`  \u2014 ${r.variant.padEnd(20)} ${r.why ?? r.error ?? "the injection did not land"}. Fix the harness, not the checklist.`);
     }
     out.push("");
-    if (control) {
+    // The control is the half that needs no injection, so it is the half that
+    // travels — and the only one that can speak to false positives. If it did
+    // not record, nothing here may be claimed, in either direction.
+    if (!control) {
+        out.push("FALSE POSITIVES   not measured \u2014 no control was run, so no rate can be claimed");
+    }
+    else if (!control.seeded) {
+        out.push(`FALSE POSITIVES   NOT MEASURED \u2014 on the control, ${control.why ?? control.error ?? "the run did not record"}. No rate can be claimed from this run, and neither can the recall above: every variant recorded under the same conditions.`);
+    }
+    else {
         out.push(control.kinds.length
             ? `FALSE POSITIVES   ${control.kinds.length} finding(s) on the control, where nothing is wrong: ${control.kinds.join(", ")}`
             : "FALSE POSITIVES   none on the control");
     }
-    else {
-        out.push("FALSE POSITIVES   not measured — no control was run, so no rate can be claimed");
-    }
     const noise = seeded.reduce((n, r) => n + r.other, 0);
     if (noise)
         out.push(`                  and ${noise} extra finding(s) across the variants, beyond the fault seeded in each`);
     out.push("");
-    out.push("What this is and is not: the seeds were written by someone who has read the checklist, so recall here is an upper bound — a fault nobody thought to seed is still unmeasured. Injected faults are also cleaner than the ones real apps produce. Treat it as a floor for trust, not a score.");
+    // Promised in this file's own header for two releases and never produced.
+    // A number nobody measures is a claim, and this harness exists because
+    // claims about the checks were not good enough.
+    if (!stability) {
+        out.push("STABILITY   not measured this run \u2014 the control was asked once, so nothing here says whether the same frames give the same answer twice.");
+    }
+    else {
+        const a = [...stability.first].sort().join(", ") || "nothing";
+        const b = [...stability.again].sort().join(", ") || "nothing";
+        out.push(a === b
+            ? `STABILITY   the control gave the same answer twice: ${a}`
+            : `STABILITY   the control gave DIFFERENT answers to the same frames \u2014 first ${a}, then ${b}. Treat single sweep results on this app as one opinion, not a reading.`);
+    }
+    out.push("");
+    const gaps = uncovered();
+    if (gaps.length) {
+        // The count is of what this run attempted, not of the catalogue — `--only`
+        // makes those different numbers, and printing the catalogue's would
+        // overstate a narrow run.
+        const tried = all.length || DEFECTS.length;
+        out.push(`NOT COVERED   ${tried} seed${tried === 1 ? "" : "s"} against a ${LOOK_FOR.length}-item checklist. Nothing here measures ${gaps.join(" or ")} at all, so the recall above says nothing about ${gaps.length === 1 ? "it" : "them"}.`);
+        out.push("");
+    }
+    out.push("What this is and is not: the seeds were written by someone who has read the checklist, so recall here is an upper bound \u2014 a fault nobody thought to seed is still unmeasured. Injected faults are also cleaner than the ones real apps produce. Treat it as a floor for trust, not a score.");
     return out;
 }

package/dist/operator/tools.js

@@ -708,19 +708,21 @@ server.registerTool("intent", {
     return text(`saved to ${path.relative(ROOT, f)} — every visual check reads it from now on.`);
 });
 server.registerTool("calibrate", {
-    description: "HOW MUCH TO TRUST `sweep`. Reads the last measurement: a working demo is recorded once per known visual defect — clipped text, overlap, unreadable contrast, content off the edge, a doubled element, a stuck spinner, broken media, a dev badge — plus a control where nothing is wrong. Recall is how many seeded faults were found; false positives are findings on the control. Read this BEFORE telling somebody how much a sweep result is worth, and quote the numbers rather than your impression. Reading is instant. `run: true` measures again, which records nine full takes and takes about ten minutes and needs the app running — do not do that without being asked. Its limits are printed with it and should be repeated: the seeds were written by somebody who has read the checklist, so recall is an upper bound, and injected faults are cleaner than real ones.",
-    inputSchema: { name: z.string().describe("the demo to read (or measure) the calibration of"), run: z.boolean().optional() },
+    // It used to take `run: true` and answer, always, with a sentence telling
+    // you to run the CLI instead. An advertised parameter that cannot do the
+    // thing it names is a worse lie than an absent one: an agent plans around
+    // it, calls it, and reports back that it measured something.
+    description: "HOW MUCH TO TRUST `sweep`. READS the last measurement; it cannot make one, because measuring records a full take per defect and takes about ten minutes — that is `retake calibrate demos/<name>.yaml` at a terminal. A working demo is recorded once per known visual defect — clipped text, overlap, unreadable contrast, content off the edge, a doubled element, a stuck spinner, broken media, a dev badge — plus a control where nothing is wrong. Recall is how many seeded faults were found; false positives are findings on the control; stability is whether the control gave the same answer twice. Read this BEFORE telling somebody how much a sweep result is worth, and quote the numbers rather than your impression. Its limits are printed with it and should be repeated: the seeds were written by somebody who has read the checklist, so recall is an upper bound; injected faults are cleaner than real ones; and the run names outright which checklist items nothing seeds.",
+    inputSchema: { name: z.string().describe("the demo whose calibration to read") },
     annotations: READ_ONLY,
-}, async ({ name, run }) => {
+}, async ({ name }) => {
     if (!safe(name))
         return text(`no demo "${name}"`);
     const file = path.join(OUT, ".calibrate", name, "report.json");
-    if (run === true)
-        return text(`Measuring takes about ten minutes and records nine takes, so it is not run from here. Ask the person to run:\n\n  retake calibrate demos/${name}.yaml`);
     if (!fs.existsSync(file))
-        return text(`${name} has never been calibrated, so there is no measured answer to how much its sweep results are worth. \`retake calibrate demos/${name}.yaml\` produces one.`);
+        return text(`${name} has never been calibrated, so there is no measured answer to how much its sweep results are worth. \`retake calibrate demos/${name}.yaml\` produces one — at a terminal, not from here.`);
     const r = JSON.parse(fs.readFileSync(file, "utf8"));
-    return text([...describeCalibration(r.results), "", `measured ${r.at}`].join("\n"));
+    return text([...describeCalibration(r.results, r.stability ?? null), "", `measured ${r.at}`].join("\n"));
 });
 server.registerTool("done", { description: "Call when the demo is recorded and acceptable (or when you are stopping). One sentence for the person.", inputSchema: { summary: z.string(), demo: z.string().optional() }, annotations: RETAKE_WRITE }, async ({ summary, demo }) => {
     await tell(`Done: ${summary}`);

package/dist/ui/chat.html

@@ -11,7 +11,7 @@
   /* The review surface. Retake is driven from an agent (or the workshop);
      this page is where a person watches, judges, and collects the output.
      It accepts no prose on purpose. */
-  :root { --paper:#edefe8; --card:#f8f9f5; --ink:#191d19; --muted:#767e74; --rule:#dbdfd3; --rule2:#c9cec0; --accent:#1a1c1e; --amber:#e8b04b; --ok:#2f5d3f; --bad:#a23b2c; }
+  :root { --paper:#edefe8; --card:#f8f9f5; --ink:#191d19; --muted:#656c63; --rule:#dbdfd3; --rule2:#c9cec0; --accent:#1a1c1e; --amber:#e8b04b; --ok:#2f5d3f; --bad:#a23b2c; }
   * { box-sizing:border-box; }
   html,body { margin:0; height:100%; background:var(--paper); color:var(--ink); font:15px/1.6 -apple-system, BlinkMacSystemFont, "SF Pro Text", "Helvetica Neue", Inter, Arial, sans-serif; -webkit-font-smoothing:antialiased; }
   button, input { font:inherit; color:inherit; }
@@ -105,7 +105,9 @@
      the recording that were missing; they are optional services you can run. */
   .review { margin-top:14px; border:1px solid var(--rule); border-radius:12px; padding:10px 14px 12px; background:var(--card); }
   .rhead { font-size:11.5px; letter-spacing:.04em; text-transform:uppercase; color:var(--muted); display:flex; gap:10px; align-items:baseline; flex-wrap:wrap; }
-  .rhint { text-transform:none; letter-spacing:0; font-size:12px; opacity:.85; }
+  /* No opacity. It took a colour already at the AA line and pushed it under.
+     Case and letter-spacing separate this from the label beside it already. */
+  .rhint { text-transform:none; letter-spacing:0; font-size:12px; }
   .checked { margin-top:8px; font-size:12.5px; color:var(--muted); display:flex; gap:14px; flex-wrap:wrap; align-items:baseline; }
   /* One per row on a phone: four of these side by side break into fragments
      that read as unrelated words. */
@@ -116,7 +118,6 @@
   .checked .c { display:inline-flex; gap:5px; align-items:baseline; }
   .checked .c b { font-weight:500; color:var(--ink); }
   .checked .c.none b { color:var(--muted); }
-  .checked .c.old { opacity:.6; }
   .checked .c.bad b { color:var(--bad); }
   .checked .why { font-size:12px; }
   .flagged { margin-top:16px; border:1px solid var(--rule); background:var(--card); border-radius:16px; padding:14px 16px; }
@@ -396,7 +397,9 @@ $('newsBtn').onclick = async () => {
   localStorage.setItem(SEEN_KEY, rs[0].version);
   $('newsBtn').querySelector('.ndot')?.remove();
   veil.onclick = (e) => { if (e.target === veil) veil.remove(); };
-  document.addEventListener('keydown', function esc2(e) { if (e.key === 'Escape') { shut(); document.removeEventListener('keydown', esc2); } });
+  // `shut()` does not exist here — Escape threw a ReferenceError and left the
+  // modal sitting there. Copied from a dialog that had one.
+  document.addEventListener('keydown', function esc2(e) { if (e.key === 'Escape') { veil.remove(); document.removeEventListener('keydown', esc2); } });
 };
 
 document.getElementById('gremlinBtn').onclick = async () => {
@@ -480,9 +483,12 @@ async function pin(name) {
   $('vidName').textContent = name;
   // What the RECORDING did — separate from anything optional that looked at it.
   const stateEl = $('vidState');
-  if (t.brisk) { stateEl.className = 'vstate part'; stateEl.textContent = 'Brisk take'; stateEl.title = 'All the steps, none of the pacing. For iterating, not for keeping.'; }
+  // Failure first, always. `brisk` was tested before `ok`, so a brisk take
+  // whose steps fell over displayed the neutral "Brisk take" and nothing said
+  // it had failed — on the one path people use while iterating fast.
+  if (t.ok === false) { stateEl.className = 'vstate bad'; stateEl.textContent = t.brisk ? 'Brisk take — steps failed' : 'Steps failed'; stateEl.title = 'Some steps did not pass — see the proof log.'; }
+  else if (t.brisk) { stateEl.className = 'vstate part'; stateEl.textContent = 'Brisk take'; stateEl.title = 'All the steps, none of the pacing. For iterating, not for keeping.'; }
   else if (t.partial) { stateEl.className = 'vstate part'; stateEl.textContent = 'Partial'; stateEl.title = t.partial; }
-  else if (t.ok === false) { stateEl.className = 'vstate bad'; stateEl.textContent = 'Steps failed'; stateEl.title = 'Some steps did not pass — see the proof log.'; }
   else { stateEl.className = 'vstate done'; stateEl.textContent = 'Recording complete'; stateEl.title = 'The take is sound: every step passed and the artifacts check out.'; }
   $('vidMeta').textContent = `${(t.duration - t.trimBefore).toFixed(0)}s · ${t.ok ? 'all steps passed' : failed ? `stopped at step ${failed.index}: ${failed.summary}` : 'some steps failed'}${d.facts ? ` · ${d.facts.width}×${d.facts.height}` : ''}`;
   $('vidMeta').title = failed?.screen ? 'On screen at that moment: ' + failed.screen : '';

package/dist/ui/guide.html

@@ -6,7 +6,7 @@
 <title>How Retake works</title>
 <link rel="icon" href="/favicon.svg" type="image/svg+xml" />
 <style>
-  :root { --paper:#edefe8; --card:#f8f9f5; --ink:#191d19; --muted:#767e74; --rule:#dbdfd3; --amber:#e8b04b; --accent:#1a1c1e; }
+  :root { --paper:#edefe8; --card:#f8f9f5; --ink:#191d19; --muted:#656c63; --rule:#dbdfd3; --amber:#e8b04b; --accent:#1a1c1e; }
   * { box-sizing:border-box; }
   body { margin:0; background:var(--paper); color:var(--ink); font:16px/1.7 -apple-system, BlinkMacSystemFont, "SF Pro Text", "Helvetica Neue", Inter, Arial, sans-serif; -webkit-font-smoothing:antialiased; }
   .top { display:flex; align-items:center; gap:10px; padding:14px 22px; --rule2:#c9cec0; }

package/dist/ui/server.js

@@ -202,14 +202,31 @@ function listDemos(project) {
         return [];
     const wanted = project?.trim() ? projectKey(project) : null;
     const assignments = demoProjects();
+    // The precedence for what a demo's folder is called, in one place, because
+    // it was three places and the release note described a fourth:
+    //
+    //   1. a folder you assigned by hand
+    //   2. a folder assigned by hand to another demo of the same app
+    //   3. the name in this demo's own product note
+    //   4. the name in a product note written for another demo of the same app
+    //   5. the app's address, which is where this started and helps nobody
+    //
+    // Four is new. Writing `retake intent --demo checkout "# Acme"` named the
+    // checkout folder and left the other six Acme demos in a fold called
+    // "localhost:3200", which is the exact complaint the naming was added to
+    // answer.
     const byUrl = new Map();
+    const namedByUrl = new Map();
     for (const f of fs.readdirSync(DEMOS).filter((x) => /\.ya?ml$/.test(x))) {
         const mm = cachedManifest(path.join(DEMOS, f));
-        if (mm) {
-            const asg = assignments[mm.name];
-            if (asg && mm.url && !byUrl.has(mm.url))
-                byUrl.set(mm.url, asg);
-        }
+        if (!mm)
+            continue;
+        const asg = assignments[mm.name];
+        if (asg && mm.url && !byUrl.has(mm.url))
+            byUrl.set(mm.url, asg);
+        const named = productName(DEMOS, mm.name);
+        if (named && mm.url && !namedByUrl.has(mm.url))
+            namedByUrl.set(mm.url, named);
     }
     const listed = fs
         .readdirSync(DEMOS)
@@ -243,7 +260,7 @@ function listDemos(project) {
         // A product that has said what it is called is filed under that name.
         // Grouping by URL gave folders like "localhost:3200" — true, and no help
         // to anybody looking for their charter demos.
-        const group = assigned ? path.basename(assigned) : (productName(DEMOS, name) ?? shortGroup(url));
+        const group = assigned ? path.basename(assigned) : (productName(DEMOS, name) ?? (url ? namedByUrl.get(url) : undefined) ?? shortGroup(url));
         // Heal a folder whose run was killed mid-recording: the previous take is
         // in its stash and nothing has put it back yet. The window must never
         // show someone an empty demo when their recording is safe on disk.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "retake-demos",
-  "version": "0.13.1",
+  "version": "0.13.2",
   "description": "Demo-as-code for coding agents: a YAML manifest in, a product walkthrough video out. Rerun the demo instead of re-recording it.",
   "keywords": [
     "demo",

package/site/releases.json

@@ -1,6 +1,20 @@
 {
   "_readme": "What's new, written for the person using Retake — not for whoever wrote it. Both the landing page and the Retake window read THIS file; there is no second copy. Rules for adding one: say what changed for them, name no files, no flags they will not type, no words like refactor or regression. If a line only makes sense to someone who has read the source, it does not belong here. Newest first. Add an entry on every release that changes what people see.",
   "releases": [
+    {
+      "version": "0.13.2",
+      "date": "2026-08-28",
+      "headline": "The thing that measures the checks was not measuring",
+      "notes": [
+        "Calibration is the number that says how much a visual finding is worth. Run against an app that was not even running, it used to print \"no false positives on the control\" and finish happily — because nothing had happened, so nothing was wrong. It now refuses: a run that fell over, recorded no steps, or produced no frames measures nothing, says which, and does not pretend otherwise.",
+        "One of its eight seeded faults could never have worked. A typo in the unreadable-contrast seed meant its own self-check could never be true, so that fault reported \"did not land\" on every app it was ever tried on. Fixed, and every seed is now tested in a real browser so a silently dead one cannot happen again.",
+        "Two more honest things it now says out loud: that two of the ten things it looks for have no seeded test at all, so the score says nothing about them; and whether asking the same question about the same pictures twice gives the same answer. That second one was promised in the code for two releases and never actually measured.",
+        "The checks run in a browser, and the browser was never installed on the build server — so every automated run since those tests were written failed before it started, and the build and packaging checks after them never ran. Installed now.",
+        "Fixed: pressing Escape on the What's New window did nothing. Fixed: a quick take whose steps failed showed a neutral \"Brisk take\" and never said it had failed. Fixed: the small print in the review area was too faint to meet the readability standard for text that size. Fixed: naming one demo's product now names the folder for every demo of the same app, not just that one. Fixed: a dry run now really scrolls when the demo says to scroll.",
+        "The agent tool for calibration used to advertise a setting that would run a fresh measurement, and always answered by telling you to go and run it yourself. That setting is gone.",
+        "And the landing page said \"nothing uploaded\", which was true of recording and not of the optional visual checks — those send the frames they look at to whichever model you point them at. It now says so."
+      ]
+    },
     {
       "version": "0.13.1",
       "date": "2026-08-28",

package/skill/SKILL.md

@@ -134,13 +134,18 @@ Three things about reading what it says:
 - **A clean sweep is a floor, not a ceiling.** A closed checklist cannot find
   what is not on it. It catches the ten things that go wrong in every app; it
   does not certify the frame.
-- **Say what it is worth, if anybody has measured.** `calibrate` seeds each
-  defect on the checklist into a real recording of the app and counts what
-  `sweep` finds. On Retake's own guide page: seven or eight of eight found,
-  and no false positives on the control across repeated runs. Read the report
-  before telling somebody how much a finding is worth, and repeat its limits
-  — the seeds were written by somebody who had read the checklist, so recall
-  is an upper bound. Never run it unasked: nine takes, about ten minutes.
+- **Say what it is worth, if anybody has measured.** `calibrate` seeds known
+  defects into a real recording of the app and counts what `sweep` finds. Read
+  the report before telling somebody how much a finding is worth, and quote its
+  limits rather than only its number: the seeds were written by somebody who
+  had read the checklist, so recall is an upper bound; two of the ten checklist
+  items have no seed at all, so the number says nothing about them; and a run
+  whose control did not record cleanly measured nothing. Earlier versions of
+  this file quoted "seven or eight of eight, no false positives" — one of those
+  eight seeds could never have landed, because its proof was broken, so the
+  denominator was wrong and the claim about repeated runs had never been
+  measured. Quote the report you have, not a remembered figure. Never run it
+  unasked: nine takes, about ten minutes, and only from a terminal.
 - **One pass is not reliable, and this is measured.** On a frame with a real
   overlap on it, three consecutive sweeps missed it and a fourth found it. The
   judge is not deterministic. So a frame that has already been looked at is