@bongos/core 1.24.26 → 1.24.27

package/tests/update_pill.mjs

@@ -0,0 +1,431 @@
+// tests/update_pill.mjs — the Update pill: a newer core, taken in place from the hall (task 1005041).
+//
+// The owner, 2026-11-03: the upgrade was "way too obstructing and not obvious what to do"; it
+// should feel like the Claude app's "restart to update". The pill replaced the full-width
+// banner (task 1004045) and the trip to the deploy door, so the rules the banner's suite
+// pinned are re-pinned here against the pill: said only from an answer, only to the viewers
+// the door would admit, never a link to the page you are on, and never "update" to a version
+// that was just rolled back. These EXECUTE the real shell.js and the real update-pill.js in a
+// DOM stub (core_update_banner.mjs's reason: the 1003159 grade's guards that read source text).
+import assert from 'node:assert/strict';
+import { test, afterEach } from 'node:test';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { realOTB } from './helpers.mjs';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const require_ = createRequire(import.meta.url);
+const PILL_PATH = path.join(ROOT, 'modules/hall-ui/public/update-pill.js');
+const SHELL = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/shell.js'), 'utf8');
+const PILL = fs.readFileSync(PILL_PATH, 'utf8');
+const P = require_(PILL_PATH);
+
+const BEHIND = { running: '1.19.861', latest: '1.19.871', behind: true, reading: 'ok' };
+const HUB = 'https://cloudbongos.com/deploy?project=hoodify-finance';
+const SW = (door, extra = {}) => ({
+  ok: true,
+  update: {
+    running: '1.19.861', offered: '1.19.871', reading: 'ok',
+    whats_new: { ok: true, count: 2, more: 0, versions: [
+      { version: '1.19.871', entries: [{ id: '1', text: 'Faster boards — and fewer clicks' }, { id: '2', text: 'A fix' }] },
+      { version: '1.19.870', entries: [{ id: '3', text: 'Clearer errors' }] },
+    ] },
+  },
+  door, can_update: true, ask: { available: false }, held: null, history: null, ...extra,
+});
+// objects built inside the vm carry its prototypes, so compare their JSON
+const plain = (x) => JSON.parse(JSON.stringify(x));
+const settle = (ms = 0) => new Promise((r) => setTimeout(r, ms));
+// Every timer a booted page arms is cleared after its case: an update left "running" polls
+// forever, and would hold the process open.
+const armed = new Set();
+const timers = {
+  setTimeout: (fn, ms) => { const id = setTimeout(() => { armed.delete(id); fn(); }, ms); armed.add(id); return id; },
+  clearTimeout: (id) => { armed.delete(id); clearTimeout(id); },
+  setInterval: (fn, ms) => { const id = setInterval(fn, ms); armed.add(id); return id; },
+  clearInterval: (id) => { armed.delete(id); clearInterval(id); },
+};
+afterEach(() => { for (const id of armed) { clearTimeout(id); clearInterval(id); } armed.clear(); });
+
+// ── the pure half ─────────────────────────────────────────────────────────────
+
+test('the pill is said only from an answer that is behind', () => {
+  assert.equal(P.pillState({ update: BEHIND }), 'ready');
+  assert.equal(P.pillState({ update: { ...BEHIND, reading: 'no_answer' } }), 'none', 'no answer is not "update ready"');
+  assert.equal(P.pillState({ update: { ...BEHIND, behind: false } }), 'none');
+  assert.equal(P.pillState({ update: { ...BEHIND, latest: 'next' } }), 'none', 'only a real version is offered');
+  assert.equal(P.pillState({}), 'none');
+});
+
+test('a version this project already tried and rolled back is "held", never offered again', () => {
+  assert.equal(P.pillState({ update: BEHIND, held: { version: '1.19.871' } }), 'held');
+  assert.equal(P.pillState({ update: BEHIND, held: { version: '1.19.800' } }), 'ready', 'an older hold leaves the newer release offered');
+});
+
+test('a remembered run is "running" until the server runs its version, then it has landed', () => {
+  const run = { to: '1.19.871', from: '1.19.861', at: 1 };
+  assert.equal(P.pillState({ update: BEHIND, run }), 'running');
+  assert.equal(P.pillState({ update: { ...BEHIND, running: '1.19.871' }, run }), 'landed');
+  // mid-restart the read can fail entirely; the run still speaks
+  assert.equal(P.pillState({ update: null, run }), 'running');
+});
+
+test('progress is read off /version and the hold, never guessed', () => {
+  const run = { to: '1.19.871', from: '1.19.861', at: 1000 };
+  assert.equal(P.stageOf(run, { version: '1.19.871' }, 2000), 'done');
+  assert.equal(P.stageOf(run, { version: '1.19.861', held: '1.19.871' }, 2000), 'failed');
+  assert.equal(P.stageOf(run, { version: '1.19.861' }, 2000), 'starting');
+  assert.equal(P.stageOf(run, { version: null }, 2000), 'restarting', 'no answer is the restart');
+  assert.equal(P.stageOf({ ...run, down: true }, { version: '1.19.861' }, 2000), 'restarting', 'back up on the old version is not "starting" again');
+  assert.equal(P.stageOf(run, { version: '1.19.861' }, 1000 + P.SLOW_MS + 1), 'slow');
+});
+
+test('what the update brings: the first lines, dashes as commas (V4), and an honest count', () => {
+  const h = P.highlights(SW({}).update.whats_new, 2);
+  assert.deepEqual(h.lines, ['Faster boards, and fewer clicks', 'A fix']);
+  assert.equal(h.count, 3);
+  assert.equal(h.more, false);
+  const long = P.highlights({ versions: [{ entries: [{ text: 'word '.repeat(60) }] }], more: 4 }, 3);
+  assert.ok(long.lines[0].length <= 120 && long.lines[0].endsWith('…'), 'a long line is clipped at a word');
+  assert.equal(long.more, true, 'older versions left out make the count a floor');
+});
+
+test('the door decides the button: local, hub (by its origin), ask, the command, or none', () => {
+  assert.deepEqual(P.doorPlan(SW({ kind: 'local', url: '/deploy' })), { kind: 'local' });
+  assert.deepEqual(P.doorPlan(SW({ kind: 'hub', url: HUB })), { kind: 'hub', url: HUB, origin: 'https://cloudbongos.com' });
+  assert.equal(P.doorPlan(SW({ kind: 'hub', url: 'https://cloudbongos.com/elsewhere' })).kind, 'none', 'only a hub /deploy address');
+  assert.equal(P.doorPlan(SW({ kind: 'hub', url: 'javascript:alert(1)' })).kind, 'none');
+  assert.equal(P.doorPlan(SW({ kind: 'cli', url: null })).kind, 'cli');
+  assert.equal(P.doorPlan(SW({ kind: 'cli', url: null }, { ask: { available: true } })).kind, 'ask');
+  assert.equal(P.doorPlan(SW({ kind: 'local', url: '/deploy' }, { can_update: 'yes' })).kind, 'none', 'can_update is strictly true');
+  assert.equal(P.doorPlan(null).kind, 'none');
+});
+
+test('a remembered run expires, and storage that throws costs only the memory', () => {
+  const box = new Map();
+  const storage = { getItem: (k) => box.get(k) || null, setItem: (k, v) => box.set(k, v), removeItem: (k) => box.delete(k) };
+  P.keepRun(storage, { to: '1.19.871', from: '1.19.861', at: 1000 });
+  assert.equal(P.readRun(storage, 2000).to, '1.19.871');
+  assert.equal(P.readRun(storage, 1000 + P.GIVE_UP_MS + 1), null);
+  assert.equal(box.has(P.RUN_KEY), false, 'and is forgotten');
+  storage.setItem(P.RUN_KEY, JSON.stringify({ to: 'latest', at: 1 }));
+  assert.equal(P.readRun(storage, 2), null, 'only a real version is remembered');
+  const broken = { getItem() { throw new Error('private'); }, setItem() { throw new Error('private'); }, removeItem() { throw new Error('private'); } };
+  assert.equal(P.readRun(broken, 1), null);
+  assert.doesNotThrow(() => P.keepRun(broken, { to: '1.0.0', at: 1 }));
+});
+
+// ── the real shell + the real pill, in a DOM stub ─────────────────────────────
+
+function boot({
+  permissions = { 'core.pin.move': true }, update = BEHIND, held = null, status = 200, coreFails = false,
+  sw = SW({ kind: 'local', url: '/deploy' }), preview = { instance_id: '41', recommended_version: '1.19.871' },
+  post = { ok: true, status: 200, data: { ok: true } }, run = null, version = () => '1.19.861',
+  pathname = '/goals', hash = '', openResult = 'popup',
+} = {}) {
+  const ids = new Map();
+  const inserted = [];
+  const requests = [];
+  const opened = [];
+  const posted = [];
+  const store = new Map();
+  if (run) store.set('bongos.update.run', JSON.stringify(run));
+  let pillLoads = 0;
+  const listeners = {};
+
+  const stub = (id) => {
+    const s = { id, textContent: '', disabled: false, _on: {}, addEventListener(ev, fn) { (s._on[ev] ||= []).push(fn); }, focus() {} };
+    return s;
+  };
+  const el = (tag) => {
+    const e = {
+      tagName: String(tag).toUpperCase(), id: '', className: '', type: '', title: '', hidden: false,
+      style: {}, dataset: {}, _attrs: {}, _on: {}, children: [], parentNode: null, _html: '', _stubs: new Map(), textContent: '',
+      classList: { add() {}, remove() {}, toggle() { return false; }, contains() { return false; } },
+      setAttribute(k, v) { this._attrs[k] = String(v); }, getAttribute(k) { return k in this._attrs ? this._attrs[k] : null; },
+      removeAttribute(k) { delete this._attrs[k]; },
+      addEventListener(ev, fn) { (this._on[ev] ||= []).push(fn); },
+      appendChild(c) { c.parentNode = this; this.children.push(c); return c; },
+      insertBefore(c) { c.parentNode = this; this.children.unshift(c); return c; },
+      insertAdjacentElement(_pos, x) { inserted.push(x); },
+      remove() { if (this.parentNode) this.parentNode.children = this.parentNode.children.filter((k) => k !== this); },
+      contains(x) { return x === this; }, focus() {}, click() {}, scrollIntoView() {},
+      getBoundingClientRect() { return { left: 400, right: 480, top: 20, bottom: 48 }; },
+      querySelector(sel) {
+        const m = /^#([\w-]+)$/.exec(sel) || (sel === '.upd-btn--go' ? [null, (this._html.match(/class="upd-btn upd-btn--go" id="([\w-]+)"/) || [])[1]] : null);
+        if (!m || !m[1] || !this._html.includes(`id="${m[1]}"`)) return null;
+        if (!this._stubs.has(m[1])) this._stubs.set(m[1], stub(m[1]));
+        return this._stubs.get(m[1]);
+      },
+      querySelectorAll() { return []; },
+      set innerHTML(v) { this._html = String(v); this._stubs = new Map(); }, get innerHTML() { return this._html; },
+    };
+    return e;
+  };
+  const side = el('div');
+  const body = el('body');
+  body.dataset = { page: 'goals' };
+  const documentObj = {
+    body,
+    head: {
+      appendChild(tag) {
+        if (/update-pill\.js/.test(tag.src)) { pillLoads++; vm.runInContext(PILL, sandbox, { filename: 'update-pill.js' }); }
+        if (tag.onload) tag.onload();
+      },
+    },
+    documentElement: { dataset: {}, style: {}, setAttribute() {}, classList: { add() {}, remove() {}, toggle() { return false; }, contains() { return false; } } },
+    getElementById(id) { if (!ids.has(id)) ids.set(id, el('div')); return ids.get(id); },
+    querySelector(sel) { return sel === '#app-topbar .topbar-side' ? side : null; },
+    querySelectorAll() { return []; },
+    createElement: (tag) => el(tag),
+    addEventListener() {}, dispatchEvent() {},
+    get cookie() { return ''; }, set cookie(_v) {},
+  };
+  const location = { hostname: 'h', origin: 'https://h', pathname, hash, search: '', assign() {}, replace() {}, reload() { location.reloaded = true; } };
+  const popup = { closed: false, postMessage(msg, origin) { posted.push({ msg, origin }); } };
+  const windowObj = {
+    OTB: realOTB(), __BRANDING__: {}, __MODULES__: { enabled: { provisioning: true } }, __updatePollMs: 1,
+    BongosClient: {
+      createClient: () => ({
+        request: (method, p, opts) => {
+          requests.push({ method, path: p, body: opts && opts.body });
+          if (p === '/api/bongos/core-update') {
+            if (coreFails) return Promise.reject(new Error('restarting'));
+            return Promise.resolve({ status, ok: status === 200, data: update || held ? { ok: true, update, held } : null });
+          }
+          if (p === '/api/bongos/software-update') return Promise.resolve({ ok: true, status: 200, data: sw });
+          if (p === '/api/bongos/provisioning/control-plane') return Promise.resolve({ ok: true, status: 200, data: { ok: true, preview } });
+          if (/\/core-upgrade$/.test(p)) return Promise.resolve(post);
+          return new Promise(() => {});
+        },
+      }),
+    },
+    fetch: async () => { const v = version(); if (v === null) throw new Error('down'); return { ok: true, json: async () => ({ coreVersion: v }) }; },
+    open: (url, name, feats) => { opened.push({ url, name, feats }); return openResult === 'popup' ? popup : null; },
+    addEventListener: (ev, fn) => { (listeners[ev] ||= []).push(fn); },
+    matchMedia: () => ({ matches: false, addEventListener() {} }),
+    localStorage: { getItem: (k) => (store.has(k) ? store.get(k) : null), setItem: (k, v) => store.set(k, String(v)), removeItem: (k) => store.delete(k) },
+    requestAnimationFrame() {}, scrollTo() {}, location, innerWidth: 1280,
+    ...timers,
+  };
+  windowObj.document = documentObj;
+  const sandbox = { window: windowObj, document: documentObj, location, console, ...timers, queueMicrotask, Promise, JSON, URL,
+    CustomEvent: class { constructor(ty, i) { this.type = ty; Object.assign(this, i); } } };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(SHELL, sandbox, { filename: 'shell.js' });
+  windowObj.OTBShell.applyAccess({ authed: true, rank: 'archon', permissions });
+  const pill = () => side.children.find((c) => c.id === 'upd-pill');
+  const card = () => body.children.find((c) => c.id === 'upd-card');
+  return {
+    pill, card, side, inserted, requests, opened, posted, popup, store, location, windowObj,
+    pillLoads: () => pillLoads,
+    press: (node) => { for (const fn of node._on.click || []) fn({ currentTarget: node, target: node, preventDefault() {} }); },
+    pressIn: (id) => { const b = card().querySelector('#' + id); assert.ok(b, `#${id} is in the card`); for (const fn of b._on.click || []) fn({ currentTarget: b, target: b, preventDefault() {} }); },
+    message: (data, { source = popup, origin = 'https://cloudbongos.com' } = {}) => { for (const fn of listeners.message || []) fn({ data, source, origin }); },
+  };
+}
+
+test('an owner who is behind sees a quiet pill in the top bar, not a strip across the page', async () => {
+  const b = boot();
+  await settle();
+  assert.equal(b.pillLoads(), 1, 'the pill script is loaded once');
+  const pill = b.pill();
+  assert.ok(pill, 'the pill is in the top bar');
+  assert.match(pill.innerHTML, />Update</);
+  assert.equal(b.inserted.length, 0, 'nothing is inserted after the top bar any more');
+});
+
+test('no answer from the registry draws nothing, and loads nothing', async () => {
+  const b = boot({ update: { running: '1.19.861', latest: null, behind: false, reading: 'no_answer' } });
+  await settle();
+  assert.equal(b.pill(), undefined);
+  assert.equal(b.pillLoads(), 0);
+});
+
+test('a builder without the atom is never asked, and sees no pill', async () => {
+  const b = boot({ permissions: { 'task.create': true } });
+  await settle();
+  assert.ok(!b.requests.some((r) => r.path === '/api/bongos/core-update'));
+  assert.equal(b.pill(), undefined);
+});
+
+// task 1004118's lesson, kept: derive the map /me really sends rather than writing one here.
+test('the pill renders from the projection /me ACTUALLY sends', async () => {
+  const meSrc = fs.readFileSync(path.join(ROOT, 'src/bongos/routes/me.js'), 'utf8');
+  const m = meSrc.match(/NAV_PERMISSION_ATOMS = Object\.freeze\(\[([^\]]*)\]\)/);
+  assert.ok(m, 'NAV_PERMISSION_ATOMS is readable');
+  const permissions = Object.fromEntries(m[1].split(',').map((x) => x.trim().replace(/^'|'$/g, '')).filter(Boolean).map((a) => [a, true]));
+  const b = boot({ permissions });
+  await settle();
+  assert.ok(b.pill(), 'core.pin.move is outside NAV_PERMISSION_ATOMS, so the pill is dead for everyone (task 1004118)');
+});
+
+// task 1004145's lesson: a control that only navigates to the page you are on does nothing.
+// The pill is a button that acts in place on every page, the deploy door's and Settings' included.
+test('the pill is a button that acts, never a link to the page you are on', async () => {
+  for (const [pathname, hash] of [['/deploy', ''], ['/deploy/', ''], ['/settings', '#software-update'], ['/goals', '']]) {
+    const b = boot({ pathname, hash });
+    await settle();
+    assert.equal(b.pill().tagName, 'BUTTON', pathname);
+    assert.equal(b.pill().getAttribute('href'), null, pathname);
+  }
+});
+
+test('opening the card reads what the update brings, once, and names both versions', async () => {
+  const b = boot();
+  await settle();
+  b.press(b.pill());
+  await settle();
+  b.press(b.pill()); b.press(b.pill());
+  await settle();
+  assert.equal(b.requests.filter((r) => r.path === '/api/bongos/software-update').length, 1);
+  const html = b.card().innerHTML;
+  assert.match(html, /A new version of Bongos is ready/);
+  assert.match(html, /3 improvements:/, 'every line shown when there are only three');
+  assert.match(html, /Faster boards, and fewer clicks/, 'quoted notes have their dashes turned to commas');
+  assert.match(html, /1\.19\.861<\/span> → <span class="upd-ver">1\.19\.871/);
+  assert.match(html, /id="upd-go"/);
+  assert.equal(b.pill().getAttribute('aria-expanded'), 'true');
+});
+
+test('the platform\'s own hall: Update now moves its own row to the version the card showed', async () => {
+  const b = boot();
+  await settle();
+  b.press(b.pill());
+  await settle();
+  b.pressIn('upd-go');
+  await settle(5);
+  const post = b.requests.find((r) => r.method === 'POST');
+  assert.equal(post.path, '/api/bongos/provisioning/instances/41/core-upgrade');
+  assert.deepEqual(plain(post.body), { to: '1.19.871' });
+  assert.equal(JSON.parse(b.store.get('bongos.update.run')).to, '1.19.871', 'the run is remembered for the next page');
+  assert.match(b.pill().innerHTML, /Updating…/);
+});
+
+test('a door that names another version: it is shown, never sent, and the next press takes it', async () => {
+  const b = boot({ preview: { instance_id: '41', recommended_version: '1.19.900' } });
+  await settle();
+  b.press(b.pill());
+  await settle();
+  b.pressIn('upd-go');
+  await settle(5);
+  assert.ok(!b.requests.some((r) => r.method === 'POST'), 'nothing moves to a version nobody was shown');
+  assert.match(b.card().innerHTML, /The update door offers version 1\.19\.900/);
+  assert.match(b.card().innerHTML, /1\.19\.861<\/span> → <span class="upd-ver">1\.19\.900/, 'the card now names the door\'s version');
+  b.pressIn('upd-go');
+  await settle(5);
+  const post = b.requests.find((r) => r.method === 'POST');
+  assert.deepEqual(plain(post.body), { to: '1.19.900' }, 'the version shown, once it was shown');
+});
+
+test('a refusal from the door is said in the server\'s own words', async () => {
+  const b = boot({ post: { ok: false, status: 409, data: { error: { code: 'intent_conflict', message: 'A restart is running for this project.' } } } });
+  await settle();
+  b.press(b.pill());
+  await settle();
+  b.pressIn('upd-go');
+  await settle(5);
+  assert.match(b.card().innerHTML, /A restart is running for this project\./);
+  assert.equal(b.store.has('bongos.update.run'), false);
+  assert.match(b.pill().innerHTML, />Update</, 'back to ready, not stuck on "Updating…"');
+});
+
+test('a hosted project: Update now opens the hub\'s window and moves nothing from this page', async () => {
+  const b = boot({ sw: SW({ kind: 'hub', url: HUB }) });
+  await settle();
+  b.press(b.pill());
+  await settle();
+  assert.match(b.card().innerHTML, /A small window from cloudbongos\.com opens for a moment/);
+  b.pressIn('upd-go');
+  assert.equal(b.opened.length, 1);
+  assert.equal(b.opened[0].url, HUB + '&handoff=1');
+  assert.ok(!b.requests.some((r) => r.method === 'POST'), 'the project\'s own server never moves its pin');
+
+  // a message from anywhere but that window, on the hub's origin, is not heard
+  b.message({ tag: 'bongos-update', step: 'ready' }, { origin: 'https://evil.example' });
+  b.message({ tag: 'bongos-update', step: 'ready' }, { source: {} });
+  assert.equal(b.posted.length, 0);
+
+  b.message({ tag: 'bongos-update', step: 'ready' });
+  assert.deepEqual(plain(b.posted), [{ msg: { tag: 'bongos-update', step: 'go', to: '1.19.871' }, origin: 'https://cloudbongos.com' }],
+    'the version shown, and only to the hub');
+
+  b.message({ tag: 'bongos-update', step: 'started', to: '1.19.871' });
+  assert.equal(JSON.parse(b.store.get('bongos.update.run')).to, '1.19.871');
+  assert.match(b.pill().innerHTML, /Updating…/);
+});
+
+test('a hub refusal is said in its own words, and nothing is remembered', async () => {
+  const b = boot({ sw: SW({ kind: 'hub', url: HUB }) });
+  await settle();
+  b.press(b.pill()); await settle();
+  b.pressIn('upd-go');
+  b.message({ tag: 'bongos-update', step: 'refused', message: 'Only the project\'s owner can update it.' });
+  assert.match(b.card().innerHTML, /Only the project&#39;s owner can update it\.|Only the project's owner can update it\./);
+  assert.equal(b.store.has('bongos.update.run'), false);
+});
+
+test('a blocked window is said, with a second press that opens it', async () => {
+  const b = boot({ sw: SW({ kind: 'hub', url: HUB }), openResult: null });
+  await settle();
+  b.press(b.pill()); await settle();
+  b.pressIn('upd-go');
+  assert.match(b.card().innerHTML, /blocked the update window/);
+  const again = b.card().querySelector('#upd-open') || b.card().querySelector('#upd-go');
+  assert.ok(again, 'a button to try again');
+});
+
+test('a self-hosted project names the command; an operator-run one offers to ask; a viewer who may not, nothing', async () => {
+  const cli = boot({ sw: SW({ kind: 'cli', url: null }) });
+  await settle(); cli.press(cli.pill()); await settle();
+  assert.match(cli.card().innerHTML, /<code>bongos upgrade<\/code>/);
+  assert.doesNotMatch(cli.card().innerHTML, /id="upd-go"/);
+
+  const ask = boot({ sw: SW({ kind: 'cli', url: null }, { ask: { available: true, hub_host: 'cloudbongos.com' } }) });
+  await settle(); ask.press(ask.pill()); await settle();
+  assert.match(ask.card().innerHTML, /id="upd-ask"/);
+  assert.match(ask.card().innerHTML, /the team at cloudbongos\.com/);
+
+  const no = boot({ sw: SW({ kind: 'local', url: '/deploy' }, { can_update: false }) });
+  await settle(); no.press(no.pill()); await settle();
+  assert.doesNotMatch(no.card().innerHTML, /id="upd-go"/);
+});
+
+// task 1004730's rule, kept: a version that just failed here is never offered again.
+test('a held version: the pill says so, the card says what happened, and there is no Update now', async () => {
+  const held = { version: '1.19.871', still_on: '1.19.861', message: 'Version 1.19.871 was tried on this project and did not work: health check. It is still on 1.19.861 and working.' };
+  const b = boot({ held });
+  await settle();
+  assert.match(b.pill().innerHTML, /Update held/);
+  b.press(b.pill()); await settle();
+  assert.match(b.card().innerHTML, /tried on this project and did not work/);
+  assert.match(b.card().innerHTML, /still on 1\.19\.861 and working/);
+  assert.doesNotMatch(b.card().innerHTML, /id="upd-go"/);
+});
+
+test('a remembered run follows the owner to the next page, even while the server restarts', async () => {
+  const b = boot({ coreFails: true, run: { to: '1.19.871', from: '1.19.861', at: Date.now() }, version: () => null });
+  await settle();
+  assert.ok(b.pill(), 'mid-restart the read fails, and the pill still speaks');
+  assert.match(b.pill().innerHTML, /Updating…/);
+});
+
+test('done is the Claude moment: the pill becomes Reload, and pressing it reloads', async () => {
+  const b = boot({ run: { to: '1.19.871', from: '1.19.861', at: Date.now() }, version: () => '1.19.871' });
+  await settle(20);
+  assert.match(b.pill().innerHTML, />Reload</);
+  assert.equal(b.store.has('bongos.update.run'), false, 'the run is over');
+  b.press(b.pill());
+  assert.equal(b.location.reloaded, true);
+});
+
+test('a run whose version this page already runs has landed: nothing to say', async () => {
+  const b = boot({ update: { ...BEHIND, running: '1.19.871', behind: false }, run: { to: '1.19.871', from: '1.19.861', at: Date.now() } });
+  await settle();
+  assert.equal(b.pill(), undefined);
+  assert.equal(b.store.has('bongos.update.run'), false);
+});