@bongos/core 1.24.94 → 1.24.96

package/release-notes.json

@@ -11677,5 +11677,17 @@
       "id": "1005220",
       "text": "The game's parties now have one agreed design: any group that plays together gets the same voice channel, member list and chat, whether it's a party you form, a quest party or a meeting room."
     }
+  ],
+  "1.24.95": [
+    {
+      "id": "1005218",
+      "text": "The three characters have a new look: space-faring aliens made of two animals each, drawn at a larger size. Each has its own colour, and in the game the visor now takes your character's colour and shows your character wearing"
+    }
+  ],
+  "1.24.96": [
+    {
+      "id": "1005243",
+      "text": "In game mode, tap a goal tower on Home to send your Autobongos runner there with one visor button; the tower then shows your runner at work, and tapping it shows tasks done, tokens used, time left and a Recall button."
+    }
   ]
 }

package/scripts/hall-preview/server.js

@@ -112,6 +112,8 @@ let liveWhy = null;
 // me__recent-ships.json. Query strings are ignored when matching. Id-bearing
 // paths fall back to the generic names below so one fixture serves any id.
 const FIXTURE_FALLBACKS = [
+  // Home's runner card (task 1005243): one goal's runner numbers, the same for every goal
+  [/^autonomy\/me\/goals\/\d+\/stats$/, 'autonomy__me__goals__stats'],
   [/^goals\/\d+\/conflicts$/, 'goals__conflicts'],
   [/^goals\/\d+\/dependency-forest$/, 'goals__dependency-forest'],
   [/^goals\/\d+\/requests$/, 'goals__requests'],
@@ -221,6 +223,8 @@ const CANNED_WRITES = [
   ['POST', /^auth\/runner-code\/issue$/, 'auth__runner-code__issue.post'],
   ['POST', /^me\/sessions\/revoke$/, 'me__sessions__revoke.post'],
   ['DELETE', /^autonomy\/runners\/[^/]+$/, 'autonomy__runners.delete'],
+  // Home's runner card (task 1005243): Send runner here writes the one pick.
+  ['PUT', /^autonomy\/me\/goals$/, 'autonomy__me__goals.put'],
 ];
 
 // A DATE THAT ROTS CANNOT DEMO AN AGE SIGNAL (task 1004041). The help-request

package/src/module-api.js

@@ -81,7 +81,7 @@ const { sleep } = require('./sleep');
 // MAJOR (see allowBoxScope below): passes the request through untouched.
 function deprecatedNoopMiddleware(_req, _res, next) { next(); }
 
-const CORE_VERSION = '1.24.94'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.24.96'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('discord'); log.info('mounted');

package/tests/autonomy_runner_goal_stats.mjs

@@ -0,0 +1,92 @@
+// tests/autonomy_runner_goal_stats.mjs — one goal, seen from the caller's runner
+// (task 1005243): the numbers the game's runner card on Home shows.
+//
+// The route is driven as a REAL request through the assembled router with only the
+// auth gates stubbed, and the SQL against a stubbed pool (the
+// autonomy_builder_scope precedent). DB-free, no network.
+// Run:  node --test tests/autonomy_runner_goal_stats.mjs
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const req = createRequire(import.meta.url);
+const express = req('express');
+const { attachFail } = req(path.join(ROOT, 'src/bongos/middleware/error-envelope.js'));
+const api = req(path.join(ROOT, 'src/module-api.js'));
+const db = req(path.join(ROOT, 'modules/autonomy/db.js'));
+
+const permStub = (key) => { const mw = (_q, _s, next) => next(); mw.permKey = key; return mw; };
+const passBuilder = (q, _s, next) => { q.builder = { id: 7, rank: 'metic' }; next(); };
+
+function router() {
+  const saved = { b: api.requireBuilder, p: api.requirePermission };
+  api.requireBuilder = passBuilder;
+  api.requirePermission = permStub;
+  const p = req.resolve(path.join(ROOT, 'modules/autonomy/routes/autonomy.js'));
+  delete req.cache[p];
+  try { return req(p)(); } finally { api.requireBuilder = saved.b; api.requirePermission = saved.p; }
+}
+async function serve(r) {
+  const app = express();
+  app.use(express.json()); app.use(attachFail); app.use(r);
+  const server = app.listen(0);
+  await new Promise((ok) => server.once('listening', ok));
+  return { base: `http://127.0.0.1:${server.address().port}`, close: () => server.close() };
+}
+async function withPool(answer, fn) {
+  const saved = api.pool.query;
+  const calls = [];
+  api.pool.query = async (sql, params) => { calls.push({ sql, params }); return answer(sql, params); };
+  try { return await fn(calls); } finally { api.pool.query = saved; }
+}
+
+test('the read counts only the caller\'s RUNNER claims that shipped in that goal, and their sessions\' tokens', async () => {
+  await withPool(() => ({ rows: [{ tasks_done: 7, tokens: '4820000', avg_s: '2280.4', tasks_left: 5 }] }), async (calls) => {
+    const out = await db.readRunnerGoalStats(7, 1000090);
+    assert.deepEqual(out, { tasks_done: 7, tokens: 4820000, avg_task_seconds: 2280, tasks_left: 5 });
+    const { sql, params } = calls[0];
+    assert.deepEqual(params, [7, 1000090], 'scoped to the caller and the goal');
+    assert.match(sql, /c\.autonomous/, 'a runner\'s claim, not a person\'s');
+    assert.match(sql, /c\.outcome = 'shipped'/, 'shipped, by the ledger');
+    assert.match(sql, /sr\.builder_id = \$1/, 'only the caller\'s sessions');
+    assert.match(sql, /status IN \('ready', 'active'\)/, 'what is left is what a runner could still take');
+  });
+});
+
+test('a goal not opened to runners tells no count of what is left', async () => {
+  await withPool(() => ({ rows: [{ tasks_done: 0, tokens: '0', avg_s: null, tasks_left: null }] }), async () => {
+    assert.equal((await db.readRunnerGoalStats(7, 9)).tasks_left, null);
+  });
+});
+
+test('nothing done yet reads as zeros and no average, never a made-up pace', async () => {
+  await withPool(() => ({ rows: [{ tasks_done: 0, tokens: '0', avg_s: null, tasks_left: 3 }] }), async () => {
+    assert.deepEqual(await db.readRunnerGoalStats(7, 1), { tasks_done: 0, tokens: 0, avg_task_seconds: null, tasks_left: 3 });
+  });
+});
+
+test('GET /autonomy/me/goals/:id/stats: behind autonomy.run, the caller\'s own, a bad id refused', async () => {
+  const r = router();
+  const layer = r.stack.find((l) => l.route && l.route.path === '/autonomy/me/goals/:goalId/stats' && l.route.methods.get);
+  assert.ok(layer, 'the route is registered');
+  assert.deepEqual(layer.route.stack.map((s) => s.handle.permKey).filter(Boolean), ['autonomy.run']);
+  const s = await serve(r);
+  try {
+    await withPool(() => ({ rows: [{ tasks_done: 2, tokens: 1000, avg_s: 600, tasks_left: 1 }] }), async (calls) => {
+      const ok = await fetch(`${s.base}/autonomy/me/goals/1000090/stats`);
+      assert.equal(ok.status, 200);
+      assert.deepEqual(await ok.json(), { goal_id: 1000090, tasks_done: 2, tokens: 1000, avg_task_seconds: 600, tasks_left: 1 });
+      assert.deepEqual(calls[0].params, [7, 1000090], 'keyed by the session\'s builder, never the request');
+      const bad = await fetch(`${s.base}/autonomy/me/goals/abc/stats`);
+      assert.equal(bad.status, 400);
+    });
+    await withPool(() => { throw new Error('db down'); }, async () => {
+      const down = await fetch(`${s.base}/autonomy/me/goals/5/stats`);
+      assert.equal(down.status, 503);
+    });
+  } finally { s.close(); }
+});

package/tests/character_creation.mjs

@@ -153,7 +153,7 @@ test('a held character is the only one offered, and the top bar wears its sprite
   const sw = t.C.switchHtml();
   assert.match(sw, /craft-switch--character/);
   assert.match(sw, /data-craft-me/);
-  assert.match(sw, /\/builders\/characters\/artisan\.png/);
+  assert.match(sw, /\/builders\/characters\/artisan-face\.png/, 'the chip is the head, its own picture (task 1005218)');
   assert.ok(!/data-craft-opt=/.test(sw), 'the three-way switch is gone');
   // A session's stored mode from before the character cannot override it.
   t.session['hall-craft'] = 'patron';
@@ -162,7 +162,7 @@ test('a held character is the only one offered, and the top bar wears its sprite
 
 test('the sprite is drawn on first paint from the last held character, before /me answers', () => {
   const t = boot({ store: { 'hall-character': 'patron' } });
-  assert.match(t.C.switchHtml(), /\/builders\/characters\/patron\.png/);
+  assert.match(t.C.switchHtml(), /\/builders\/characters\/patron-face\.png/);
 });
 
 test('an older core that says nothing about characters changes nothing', () => {
@@ -187,15 +187,52 @@ test('the character section never writes `hidden` onto the nav: a character only
   assert.ok(!/nav-item|app-sidebar/.test(section), 'the character code does not touch the nav itself; applyNav does');
 });
 
-test('the owner\'s three sprites are on disk, one per character', () => {
+// task 1005218: the second look. Three pictures per character, drawn by
+// docs/design/characters/v2/draw-characters.js --hall: the whole figure (64), the head for
+// the chip (32) and the head wearing the visor for the visor's corner (32).
+test('each character\'s three pictures are on disk, at their sizes', () => {
   for (const id of ['artisan', 'artist', 'patron']) {
-    const f = path.join(HALL, 'characters', id + '.png');
-    assert.ok(fs.existsSync(f), `${id}.png`);
-    const head = fs.readFileSync(f).subarray(0, 8);
-    assert.deepEqual([...head], [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a], `${id}.png is a PNG`);
+    for (const [part, size] of [['', 64], ['-face', 32], ['-visor', 32]]) {
+      const f = path.join(HALL, 'characters', id + part + '.png');
+      assert.ok(fs.existsSync(f), `${id}${part}.png`);
+      const buf = fs.readFileSync(f);
+      assert.deepEqual([...buf.subarray(0, 8)], [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a], `${id}${part}.png is a PNG`);
+      assert.deepEqual([buf.readUInt32BE(16), buf.readUInt32BE(20)], [size, size], `${id}${part}.png is ${size} by ${size}`);
+    }
   }
 });
 
+test('the hall\'s pictures are what the drawing script draws: nobody edited one by hand', async () => {
+  const { createRequire } = await import('node:module');
+  const draw = createRequire(import.meta.url)(path.join(ROOT, 'docs/design/characters/v2/draw-characters.js'));
+  const drawn = draw.hallFiles();
+  const onDisk = fs.readdirSync(path.join(HALL, 'characters')).sort();
+  assert.deepEqual(onDisk, Object.keys(drawn).sort(), 'nine files, three per character, and nothing else');
+  // Compared pixel for pixel, not byte for byte: two zlib builds may pack the same picture differently.
+  const zlib = await import('node:zlib');
+  const pixels = (png) => {
+    const parts = [];
+    for (let at = 8; at < png.length;) {
+      const len = png.readUInt32BE(at), type = png.toString('latin1', at + 4, at + 8);
+      if (type === 'IDAT') parts.push(png.subarray(at + 8, at + 8 + len));
+      at += 12 + len;
+    }
+    return zlib.inflateSync(Buffer.concat(parts));
+  };
+  for (const [name, buf] of Object.entries(drawn)) {
+    assert.ok(pixels(buf).equals(pixels(fs.readFileSync(path.join(HALL, 'characters', name)))), name + ' is stale or hand-edited: run node docs/design/characters/v2/draw-characters.js --hall');
+  }
+});
+
+test('the three characters\' colours are mixed from the hall\'s tokens, never typed in (ADR 0405)', () => {
+  const css = fs.readFileSync(path.join(HALL, 'style.css'), 'utf8');
+  const block = css.slice(css.indexOf('--char-artisan:'), css.indexOf('--char-patron:') + 120);
+  assert.match(block, /--char-artisan: var\(--accent\);/);
+  assert.match(block, /--char-artist: color-mix\(/);
+  assert.match(block, /--char-patron: color-mix\(/);
+  assert.ok(!/#[0-9a-fA-F]{3,8}/.test(block), 'no literal colour');
+});
+
 // ---------- the server half ----------
 test('core_297 adds the account column, and the CHECK names exactly the three characters', () => {
   const sql = fs.readFileSync(path.join(ROOT, 'migrations/core_297_builder_character.sql'), 'utf8');

package/tests/hall_visor.mjs

@@ -179,7 +179,7 @@ const SCENE = `<script>
   cv.addEventListener('pointerup', () => { drag = null; });
   addEventListener('keydown', (e) => { if (e.key === 'Escape' && window.picked) { e.preventDefault(); window.picked = false; } });
   window.OTBCraftMode = { held: 'artisan', character() { return this.held; }, current() { return null; },
-    me() { return { builder: { total_credits: 56021 } }; }, spriteSrc(id) { return '/builders/characters/' + id + '.png'; }, openTool(id) { window.toolOpened = id; } };
+    me() { return { builder: { total_credits: 56021 } }; }, spriteSrc(id) { return '/builders/characters/' + id + '.png'; }, portraitSrc(id) { return '/builders/characters/' + id + '-visor.png'; }, openTool(id) { window.toolOpened = id; } };
   window.__visorScene = { name: 'test', place: 'Test city', actions: [{ label: 'Back to centre', key: '0', run() { window.centred = true; } }], keys: [{ label: 'Look around', key: 'drag' }] };
 </script>`;
 // `helm` links the hall's real sheet (the token tier) instead of the stand-in colours.
@@ -240,7 +240,7 @@ test('in game mode the glass shows the place, the main action, the key hints, th
   // task 1005195: every other control is a quiet key hint. Actions kept its key and its sheet; nothing was dropped.
   assert.deepEqual(g.hints, ['TYour thinking', 'AActions', 'EscOptions']);
   assert.equal(g.arcs, 2, 'two arcs frame the glass');
-  assert.equal(g.sprite, '/builders/characters/artisan.png');
+  assert.equal(g.sprite, '/builders/characters/artisan-visor.png', 'your picture on the glass is you wearing the visor (task 1005218)');
   assert.deepEqual(errors, []);
   await ctx.close();
 });
@@ -271,6 +271,26 @@ test('Escape closes one layer, top first: the sheet, then the scene\'s pick, the
   await ctx.close();
 });
 
+test('a scene\'s pick: the card is on the glass, its action takes the accent button, Escape closes it first (task 1005243)', { skip }, async () => {
+  const { ctx, page, errors } = await open();
+  await page.evaluate(() => OTBVisor.focus({ key: 'runner:2', title: 'Area 2', status: { text: 'Running', tone: 'ok' }, lines: ['7 tasks done here'],
+    lead: { label: 'Recall runner', run() { window.led = (window.led || 0) + 1; } }, onClose() { window.unpicked = true; } }));
+  const g = await page.evaluate(() => ({
+    title: document.querySelector('.visor__focus-title').textContent,
+    status: document.querySelector('.visor__focus-status').textContent,
+    main: document.querySelector('.visor__main').textContent,
+    takes: getComputedStyle(document.querySelector('.visor__focus')).pointerEvents,
+  }));
+  assert.deepEqual(g, { title: 'Area 2', status: 'Running', main: 'Recall runner', takes: 'auto' });
+  await page.click('[data-visor-lead]');
+  assert.equal(await page.evaluate(() => window.led), 1, 'the accent button runs the scene\'s action');
+  await page.keyboard.press('Escape');
+  const s = await page.evaluate(() => ({ focus: OTBVisor.focused(), unpicked: window.unpicked, picked: window.picked, menu: window.optionsOpened, main: document.querySelector('.visor__main').textContent }));
+  assert.deepEqual(s, { focus: null, unpicked: true, picked: true, menu: 0, main: 'Goal skyG' }, 'the card took the press; the character\'s own button is back');
+  assert.deepEqual(errors, []);
+  await ctx.close();
+});
+
 test('a lead scene action is the first key hint, and its click and its key run it (task 1005209)', { skip }, async () => {
   const { ctx, page, errors } = await open();
   await page.evaluate(() => OTBVisor.scene({ name: 'test', place: 'Test city', actions: [{ label: 'Decide 2 in a row', key: 'd', bind: true, lead: true, run() { window.decided = (window.decided || 0) + 1; } }] }));
@@ -366,6 +386,32 @@ for (const [width, height] of [[1440, 900], [390, 844], [320, 640]]) {
   });
 }
 
+// task 1005218 (ADR 0405): each character has one colour, and the glass wears the held one.
+test('the glass wears the held character\'s colour: the Artisan\'s is the accent, the Artist\'s and the Patron\'s are their own', { skip }, async () => {
+  const { ctx, page } = await open({ helm: true });
+  const g = await page.evaluate(() => {
+    const probe = (v) => { const d = document.createElement('i'); d.style.color = v; document.body.appendChild(d); const c = getComputedStyle(d).color; d.remove(); return c; };
+    const out = { accent: probe('var(--accent)') };
+    for (const id of ['artisan', 'artist', 'patron']) {
+      window.OTBCraftMode.held = id; window.OTBVisor.render();
+      const cs = (s) => getComputedStyle(document.querySelector(s));
+      out[id] = { char: probe('var(--char-' + id + ')'), main: cs('.visor__main').backgroundColor, name: cs('.visor__name').color,
+        line: cs('.visor__line:not(.visor__line--under)').stroke, rim: cs('.visor__sprite').borderTopColor, src: document.querySelector('.visor__sprite').getAttribute('src') };
+    }
+    return out;
+  });
+  assert.equal(g.artisan.main, g.accent, 'an Artisan\'s glass is the accent it always was');
+  for (const id of ['artisan', 'artist', 'patron']) {
+    assert.equal(g[id].main, g[id].char, id + ': the one button is the character\'s colour');
+    assert.equal(g[id].name, g[id].char, id + ': so is the name');
+    assert.equal(g[id].line, g[id].char, id + ': and the frame\'s lines');
+    assert.equal(g[id].rim, g[id].char, id + ': and the rim of the picture');
+    assert.equal(g[id].src, '/builders/characters/' + id + '-visor.png');
+  }
+  assert.equal(new Set([g.artisan.char, g.artist.char, g.patron.char]).size, 3, 'three characters, three colours');
+  await ctx.close();
+});
+
 test('the glass is the kit\'s: the cut accent button, ice hints with no box, the name voice, the inset focus ring', { skip }, async () => {
   const { ctx, page } = await open({ helm: true, width: 1440, height: 900 });
   const g = await page.evaluate(() => {

package/tests/home_runner.mjs

@@ -0,0 +1,115 @@
+// tests/home_runner.mjs — your Autobongos runner on Home's city (task 1005243).
+//
+// The decision is pure (home-runner.js cardFor / stateOf), so it runs here for
+// real against the same runner-button.js the Settings card draws from. The page
+// wiring is pinned by its source: the scene paints the pick, every button is the
+// visor's (ADR 0403), and only a viewer the server says may run gets any of it.
+// Run:  node --test tests/home_runner.mjs
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const HALL = path.join(ROOT, 'modules', 'hall-ui', 'public');
+const require = createRequire(import.meta.url);
+const R = require(path.join(HALL, 'home-runner.js'));
+const read = (f) => fs.readFileSync(path.join(HALL, f), 'utf8');
+
+const NOW = Date.parse('2026-11-12T10:00:00Z');
+const seen = new Date(NOW - 20000).toISOString();
+const fenceOf = (picks, allowed = [1, 2, 3], extra = {}) => ({ enabled: true, goals: picks, scope: { may_run: true, goals: picks }, project: { enabled: true, goals: allowed }, ...extra });
+const dev = (o = {}) => ({ host: 'pc', run_requested: true, run_changed_at: new Date(NOW - 3600e3).toISOString(), last_seen_at: seen, health: { state: 'alive', workingTaskId: null }, ...o });
+const STATS = { tasks_done: 7, tokens: 4820000, avg_task_seconds: 2280, tasks_left: 5 };
+const card = (o) => R.cardFor({ goal: { id: 2, title: 'Area 2' }, nowMs: NOW, titleOf: (g) => `Area ${g}`, stats: STATS, ...o });
+
+test('no permission to run, or no fence read: no card, the tower stays a link', () => {
+  assert.equal(card({ runners: [dev()], fence: null }), null);
+  assert.equal(card({ runners: [dev()], fence: { ...fenceOf([]), scope: { may_run: false, goals: [] } } }), null);
+});
+
+test('no runner set up yet: the card offers setting one up', () => {
+  const c = card({ runners: [], fence: fenceOf([]) });
+  assert.equal(c.lead.act, 'setup');
+  assert.equal(c.status.text, 'No runner yet');
+});
+
+test('a goal the project has not opened to runners: no send, only the goal', () => {
+  const c = card({ runners: [dev()], fence: fenceOf([], [1, 3]) });
+  assert.equal(c.lead.act, 'open');
+  assert.match(c.lines[0], /not opened this goal to runners/);
+});
+
+test('your runner is elsewhere or resting: Send runner here, with what it did here and what is left', () => {
+  const away = card({ runners: [dev()], fence: fenceOf([1]) });
+  assert.deepEqual(away.lead, { label: 'Send runner here', act: 'send' });
+  assert.equal(away.status.text, 'Your runner is at Area 1');
+  assert.deepEqual(away.lines, ['7 tasks done here · 4.8M tokens', '5 tasks ready · about 3 h for your runner']);
+  const off = card({ runners: [dev({ run_requested: false })], fence: fenceOf([]) });
+  assert.equal(off.status.text, 'Your runner is resting');
+  assert.equal(off.lead.act, 'send');
+});
+
+test('your runner is here and on: its device face, the numbers, and Recall runner', () => {
+  const work = card({ runners: [dev({ health: { state: 'alive', workingTaskId: '9' } })], fence: fenceOf([2]) });
+  assert.deepEqual(work.lead, { label: 'Recall runner', act: 'recall' });
+  assert.deepEqual([work.status.text, work.status.tone], ['Running', 'ok']);
+  assert.equal(work.lines[0], 'Working on task 9.');
+  const rest = card({ runners: [dev({ health: { state: 'alive', workingTaskId: null, holdUntil: new Date(NOW + 42 * 60e3).toISOString() } })], fence: fenceOf([2]) });
+  assert.match(rest.status.text, /^Resting until .+ · 42 min$/);
+  assert.equal(rest.lead.act, 'recall');
+});
+
+test('recalled here: it says so and offers to send it back', () => {
+  const c = card({ runners: [dev({ run_requested: false })], fence: fenceOf([2]) });
+  assert.equal(c.status.text, 'Recalled');
+  assert.equal(c.lead.act, 'send');
+});
+
+test('nothing done yet: no invented numbers; nothing ready: says so', () => {
+  const c = card({ runners: [dev()], fence: fenceOf([1]), stats: { tasks_done: 0, tokens: 0, avg_task_seconds: null, tasks_left: 0 } });
+  assert.deepEqual(c.lines, ['Nothing ready to build here right now.']);
+  const noPace = card({ runners: [dev()], fence: fenceOf([1]), stats: { tasks_done: 0, tokens: 0, avg_task_seconds: null, tasks_left: 4 } });
+  assert.deepEqual(noPace.lines, ['4 tasks ready'], 'no time is promised without a pace to measure it by');
+});
+
+test('the marker\'s state follows the device; several picks are not one tower', () => {
+  assert.equal(R.stateOf({ runners: [dev({ health: { state: 'alive', workingTaskId: '9' } })], fence: fenceOf([2]), nowMs: NOW }), 'working');
+  assert.equal(R.stateOf({ runners: [dev({ run_requested: false })], fence: fenceOf([2]), nowMs: NOW }), 'off');
+  assert.equal(R.stateOf({ runners: [dev({ health: { state: 'alive', holdUntil: new Date(NOW + 60e3).toISOString() } })], fence: fenceOf([2]), nowMs: NOW }), 'resting');
+  assert.equal(R.assignedGoal(fenceOf([2])), '2');
+  assert.equal(R.assignedGoal(fenceOf([1, 2])), null);
+});
+
+test('numbers read like a person would say them', () => {
+  assert.equal(R.tokensText(4820000), '4.8M tokens');
+  assert.equal(R.tokensText(340400), '340k tokens');
+  assert.equal(R.aboutText(5 * 2280), 'about 3 h');
+  assert.equal(R.aboutText(1200), 'about 20 min');
+  assert.equal(R.aboutText(3 * 86400), 'about 3 days');
+  assert.equal(R.aboutText(0), '');
+});
+
+test('source: the scene paints the pick, the visor holds every button (ADR 0403), the writes are Settings\' routes', () => {
+  const src = read('home-runner.js');
+  assert.match(src, /OTBVisor\.focus/, 'the card and its button are the visor\'s');
+  assert.doesNotMatch(src, /createElement\(['"]button/, 'no button is drawn in the scene');
+  assert.match(src, /scope\.may_run === true/, 'only a viewer the server says may run');
+  assert.match(src, /dataset\.game === 'on'/, 'game mode only: in classic a tower stays a link');
+  for (const route of ["'PUT', '/autonomy/me/goals'", '/autonomy/runners/${encodeURIComponent(r.host)}/run', '/autonomy/me/goals/${encodeURIComponent(picked)}/stats']) assert.ok(src.includes(route), route);
+  const draw = read('home-city-draw.js');
+  assert.match(draw, /'data-goal': a\.id/, 'every tower names its goal');
+  assert.match(draw, /hc-tower--picked/);
+  const html = read('index.html');
+  const at = (f) => html.indexOf(`/builders/${f}`);
+  assert.ok(at('runner-button.js') > 0 && at('runner-button.js') < at('home-runner.js') && at('home-runner.js') < at('home-city.js'), 'runner-button.js, then home-runner.js, before home-city.js');
+});
+
+test('source: the marker moves only in CSS, and the hall\'s reduced-motion rule stills it', () => {
+  const css = read('home-city.css');
+  assert.match(css, /\.hc-runner--working \.hc-runner__ring \{[^}]*animation: hc-turn/);
+  assert.doesNotMatch(read('home-runner.js'), /requestAnimationFrame|setInterval/, 'no motion in script');
+});