@bongos/core 1.24.83 → 1.24.85

package/scripts/bongos/autobongos-bootstrap.sh

@@ -59,6 +59,28 @@ esac
 
 have() { command -v "$1" >/dev/null 2>&1; }
 
+# github_remedy — what to actually DO when git cannot see the project (task 1005096).
+#
+# THE CIRCLE THIS BREAKS, found on a real Mac. "Sign in to GitHub" is the wrong advice for
+# the commonest way this fails: the person IS signed in — twice — and git picked the other
+# one. git asks its FIRST credential helper, which on a Mac is the login keychain, and that
+# answers with whichever GitHub account is active, not with one that can see this project.
+# A private project then 404s as "Repository not found", which reads as a typo rather than
+# as the wrong account, and `gh auth login` again changes nothing.
+#
+# So when the GitHub CLI is here, name the account that is actually active and the one
+# command that changes it. With no gh, the old advice is still the right advice.
+github_remedy() {
+  if have gh; then
+    active="$(gh auth status --active 2>/dev/null | sed -n 's/.*account \([A-Za-z0-9-]*\).*/\1/p' | head -n 1)"
+    if [ -n "${active:-}" ]; then
+      echo "git is using your '$active' GitHub account, which may not be able to see this project. Switch with  gh auth switch  (it lists the accounts signed in here), then paste the setup command again. If the right account is not listed, add it with  gh auth login  first."
+      return
+    fi
+  fi
+  echo "Sign in to GitHub on this device with an account that can see the project (the GitHub CLI's  gh auth login  is the simplest way), then paste the setup command again."
+}
+
 # The setup command is piped into bash, so the keyboard is /dev/tty, not stdin.
 # OPENED, not just tested: with no terminal at all (CI, a remote command) the
 # device node still exists and reads as readable, and opening it is what fails.
@@ -133,12 +155,12 @@ mkdir -p "$RUNNER_HOME"
 if [ -d "$REPO_DIR/.git" ]; then
   echo "The runner's copy is already here; bringing it up to date..."
   if [ "$HAVE_TTY" = 1 ]; then git -C "$REPO_DIR" fetch --quiet origin main </dev/tty; else git -C "$REPO_DIR" fetch --quiet origin main; fi \
-    || stop_setup "this device could not fetch the project's code from GitHub." "Sign in to GitHub on this device (the GitHub CLI's  gh auth login  is the simplest way), then paste the setup command again."
+    || stop_setup "this device could not fetch the project's code from GitHub." "$(github_remedy)"
   git -C "$REPO_DIR" reset --quiet --hard origin/main
 else
   echo "Making the runner's own copy of the project (GitHub may ask you to sign in)..."
   if [ "$HAVE_TTY" = 1 ]; then git clone --quiet "$REPO" "$REPO_DIR" </dev/tty; else git clone --quiet "$REPO" "$REPO_DIR"; fi \
-    || stop_setup "this device could not copy the project from GitHub." "Sign in to GitHub on this device with an account that can see the project (the GitHub CLI's  gh auth login  is the simplest way), then paste the setup command again."
+    || stop_setup "this device could not copy the project from GitHub." "$(github_remedy)"
 fi
 
 HOST_JS="$REPO_DIR/scripts/bongos/autobongos-host.js"

package/scripts/bongos/autobongos-host.js

@@ -125,6 +125,28 @@ class Stop extends Error {
   constructor(what, fix) { super(what); this.name = 'Stop'; this.fix = fix || null; }
 }
 
+// githubRemedy — what to DO when git cannot see the project (task 1005096). The JS twin of
+// autobongos-bootstrap.sh's github_remedy; the two say the same thing because a person can
+// meet either one, and the bootstrap's own header carries the full reasoning.
+//
+// IN SHORT: "sign in to GitHub" is the wrong advice for the commonest failure. git asks its
+// FIRST credential helper — on a Mac, the login keychain — which answers with whichever
+// GitHub account is ACTIVE, not with one that can see this project. A private project then
+// 404s as "Repository not found", which reads as a typo rather than as the wrong account,
+// and signing in again changes nothing. So name the active account when the GitHub CLI can
+// tell us, and give the one command that changes it.
+const GITHUB_REMEDY_GENERIC = 'Sign in to GitHub on this device with an account that can see the project (the GitHub CLI\'s  gh auth login  is the simplest way), then run the setup command again.';
+function githubRemedy(run = spawnSync) {
+  try {
+    const r = run('gh', ['auth', 'status', '--active'], { encoding: 'utf8', windowsHide: true, timeout: 10000 });
+    const m = /account ([A-Za-z0-9-]+)/.exec(String((r && r.stdout) || '') + String((r && r.stderr) || ''));
+    if (m) {
+      return `git is using your '${m[1]}' GitHub account, which may not be able to see this project. Switch with  gh auth switch  (it lists the accounts signed in here), then run the setup command again. If the right account is not listed, add it with  gh auth login  first.`;
+    }
+  } catch (_) { /* no gh, or it could not answer — the generic line is still right */ }
+  return GITHUB_REMEDY_GENERIC;
+}
+
 // ── the runner's own copy ──────────────────────────────────────────────────
 
 function runnerCopyMarkPath(repoRoot = REPO_ROOT) { return path.join(repoRoot, '.git', RUNNER_COPY_MARK); }
@@ -289,7 +311,14 @@ function git(args, opts = {}) {
 function refreshCheckout(log = () => {}) {
   assertRunnerCopy();
   const f = git(['fetch', '--quiet', 'origin', 'main']);
-  if (f.status !== 0) { log(`git fetch failed — running the code already here (${String(f.stderr || '').trim().slice(0, 200)})`); return false; }
+  if (f.status !== 0) {
+    // The log is the ONLY place this is said (the card reads check-ins, not fetches), so it
+    // carries the remedy too — a fetch that fails for a credential reason fails every loop,
+    // and the runner then works forever on the code it happens to have (task 1005096).
+    log(`git fetch failed — running the code already here (${String(f.stderr || '').trim().slice(0, 200)})`);
+    log(`  if that keeps happening, it is not transient: ${githubRemedy()}`);
+    return false;
+  }
   const r = git(['reset', '--quiet', '--hard', 'origin/main']);
   if (r.status !== 0) { log(`git reset failed (${String(r.stderr || '').trim().slice(0, 200)})`); return false; }
   return true;
@@ -726,7 +755,7 @@ async function setup(argv, { paths = hostPaths(), say = console.log } = {}) {
 
   say('4/5  Checking this device can fetch the project’s code…');
   if (git(['ls-remote', 'origin', 'refs/heads/main'], { timeout: 60000 }).status !== 0) {
-    throw new Stop('This device could not fetch the project’s code from GitHub.', 'Sign in to GitHub on this device (run  git fetch  in the runner’s folder and follow the sign-in), then run the setup command again.');
+    throw new Stop('This device could not fetch the project’s code from GitHub.', githubRemedy());
   }
 
   say('5/5  Starting the runner…');
@@ -895,4 +924,5 @@ module.exports = {
   windowsRunArgv, windowsRunCommand, windowsStartSpawn, legacyBootTaskInstalled, launchdPlist,
   stopRunner, stopReport, exchangeCode, claudeState, waitForCheckIn,
   signIn, cleanBase, install, removeStartEntry, installedState, status, digestArgv,
+  githubRemedy, GITHUB_REMEDY_GENERIC,
 };

package/scripts/bongos/wedge-remedy.js

@@ -90,12 +90,19 @@ function planRemedy(inst, reason, o = {}) {
     if (!SHELL_SAFE_RE.test(backupDir)) return { refused: 'the backup folder is not a path this runner will put in a command' };
     // EXACTLY db-backup-nightly.sh's name, so this never touches a sibling project's dumps
     // (`test` must not prune `test-nk`'s — task 1003948). The timestamp sorts by name, so
-    // `sort | head -n -K` drops all but the newest K. Nothing is deleted when K or fewer exist.
+    // dropping all but the last K leaves the newest K. Nothing is deleted when K or fewer exist.
+    //
+    // ALL-BUT-THE-LAST-K IN POSIX awk, NOT `head -n -K` (task 1005096). `head -n -K` is a GNU
+    // extension: BSD/macOS head answers `illegal line count`, exits 1, and the pipeline then
+    // deletes nothing — and `xargs -r` is GNU-only too. Same family as the `stat -c` sweep
+    // (task 1004170): the command runs on a Linux box, but the test that runs it for real runs
+    // wherever a builder builds, so on a Mac it could never pass. POSIX `xargs` with no input
+    // may still run `rm -f --`, which succeeds with no operands, so `-r` is not needed.
     const D = '[0-9]';
     const glob = `${db}-${D}${D}${D}${D}-${D}${D}-${D}${D}T${D}${D}${D}${D}${D}${D}Z.sql.gz`;
     return {
       reason, cwd: null, env: null,
-      cmd: `find ${backupDir} -maxdepth 1 -type f -name '${glob}' | sort | head -n -${DUMP_KEEP_FLOOR} | xargs -r rm -f --`,
+      cmd: `find ${backupDir} -maxdepth 1 -type f -name '${glob}' | sort | awk -v k=${DUMP_KEEP_FLOOR} '{a[NR]=$0} END{for(i=1;i<=NR-k;i++) print a[i]}' | xargs rm -f --`,
       describe: `pruned ${db}'s old database backups in ${backupDir}, keeping the newest ${DUMP_KEEP_FLOOR}`,
     };
   }

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.83'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.24.85'; // 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/autobongos_host.mjs

@@ -663,3 +663,36 @@ test('the digest is read from the RUNNER’s run log: bare, the digest CLI looks
   assert.equal(bare.status, 0, 'the digest never fails a morning');
   assert.equal(bare.stdout.includes('424242'), false, 'which is why the guide sends people through the device program');
 });
+
+// --- "sign in to GitHub" is the wrong advice when you already are (task 1005096) -------
+//
+// Found by running the real setup on a real Mac. The device had TWO GitHub accounts signed
+// in through the GitHub CLI; git asks its first credential helper — the login keychain —
+// which answers with whichever is ACTIVE, and that one could not see the private project.
+// git then says "Repository not found", which reads as a typo, and the setup answered
+// "Sign in to GitHub … gh auth login is the simplest way" — advice that changes nothing,
+// because the person is signed in. The remedy has to NAME the account git is using.
+test('githubRemedy names the active GitHub account, and the command that changes it', () => {
+  const said = host.githubRemedy(() => ({ stdout: 'github.com\n  ✓ Logged in to github.com account mcip-labs (keyring)\n', stderr: '' }));
+  assert.match(said, /'mcip-labs'/, 'the account git is actually using must be named, or the advice is a circle');
+  assert.match(said, /gh auth switch/, 'and the one command that changes it');
+  assert.notEqual(said, host.GITHUB_REMEDY_GENERIC);
+});
+
+test('githubRemedy falls back to the plain advice when gh cannot answer', () => {
+  // No GitHub CLI on the device, it failed, or it is signed in to nothing: there is no
+  // account to name, and "sign in" is then exactly the right thing to say.
+  assert.equal(host.githubRemedy(() => ({ stdout: '', stderr: 'command not found' })), host.GITHUB_REMEDY_GENERIC);
+  assert.equal(host.githubRemedy(() => { throw new Error('ENOENT'); }), host.GITHUB_REMEDY_GENERIC);
+  assert.equal(host.githubRemedy(() => ({ stdout: 'You are not logged into any GitHub hosts.\n', stderr: '' })), host.GITHUB_REMEDY_GENERIC);
+});
+
+test('the shell bootstrap gives the same remedy, so either half says the same thing', () => {
+  const sh = readFileSync(fileURLToPath(new URL('../scripts/bongos/autobongos-bootstrap.sh', import.meta.url)), 'utf8');
+  assert.match(sh, /github_remedy\(\)/, 'the bootstrap has the twin');
+  assert.match(sh, /gh auth switch/);
+  // Both clone/fetch stops route through it rather than re-typing the old line.
+  const stops = sh.split('\n').filter((l) => /stop_setup "this device could not (copy|fetch)/.test(l));
+  assert.equal(stops.length, 2, 'the two GitHub stops');
+  for (const l of stops) assert.match(l, /\$\(github_remedy\)/, l.trim());
+});

package/tests/hall_visor.mjs

@@ -8,6 +8,8 @@
 //   - in game mode the last Escape reaches the options menu, never the visor.
 // Plus the criterion's own proof half that is the visor's: an Artisan and an Artist
 // are offered DIFFERENT actions on the glass. The pure parts run in a vm.
+// The minimal visor (Helm look 3, task 1005195) adds the look's own pins: the sheet spends
+// tokens only, and over the hall's real sheets the foot row holds at a desk, 390 and 320.
 import assert from 'node:assert/strict';
 import { test, after } from 'node:test';
 import { createRequire } from 'node:module';
@@ -87,6 +89,35 @@ test('source: the visor loads after the shell on every scene page, with its shee
   assert.match(read('visor.css'), /pointer-events: none/, 'the glass lets the pointer through');
 });
 
+// Helm look 3 (task 1005195): the glass is the kit's, and nothing on it is typed in.
+test('source: the minimal visor spends the Helm tokens and types in no colour, size, corner, shadow or breakpoint', () => {
+  const css = read('visor.css').replace(/\/\*[\s\S]*?\*\//g, '');
+  assert.doesNotMatch(css, /#[0-9a-f]{3,8}\b|\brgba?\(|\bhsla?\(/i, 'no colour literal');
+  assert.doesNotMatch(css, /font-size:\s*[\d.]/, 'every size is a --ds-text-* step');
+  assert.doesNotMatch(css, /border-radius:(?!\s*var\(--press-radius\))/, 'no corner but the press corner: Helm draws no pill');
+  assert.doesNotMatch(css, /@media|@container/, 'the phone rules live in style.css (the design-count ratchet)');
+  assert.doesNotMatch(css, /animation|@keyframes/, 'nothing on the glass moves by itself');
+  for (const m of css.match(/(?:box|text)-shadow:[^;]+/g) || []) assert.match(m, /^(?:box|text)-shadow:\s*(?:none|var\(--[a-z-]+\))$/, `${m}: a shadow is a token`);
+  for (const m of css.match(/transition:[^;]+/g) || []) assert.match(m, /var\(--ds-dur-/, `${m}: a duration token, so reduced motion stills it`);
+  assert.match(css, /\.visor__main \{[^}]*background: var\(--accent\)[^}]*clip-path: var\(--cut-path\)/, 'the one accent button is cut');
+  assert.match(css, /\.visor__main:focus-visible[^{]*\{[^}]*box-shadow: var\(--press-focus\)/, 'a cut control takes the inset ring');
+  assert.match(css, /\.visor__hint \{[^}]*background: none; border: 0/, 'a key hint has no box');
+  assert.match(css, /\.visor__place, \.visor__name, \.visor__unit, \.visor__main, \.visor__hint[^{]*\{\s*font-family: var\(--name-face\)/, 'names are in the name voice');
+  // it reads over any sky with one treatment, never a per-hour style
+  assert.match(css, /html\[data-game="on"\] \.visor:not\(\[hidden\]\) \{[^}]*background: linear-gradient\(to bottom, var\(--night-glass\), transparent[^;]*var\(--night-glass\)\)/, 'the glass darkens toward its edges');
+  assert.match(css, /text-shadow: var\(--type-halo\); -webkit-text-stroke: 4px var\(--night-glass\); paint-order: stroke fill/, 'type wears the halo over a stroke of the night');
+  assert.match(css, /\.visor__line--under \{ stroke: var\(--night-glass\)/, 'every line is drawn over the night');
+  assert.doesNotMatch(css, /data-hour|data-time|data-sky/, 'no per-hour style');
+  // the frame is two arcs, a notch and a sight; the compass, the side lines and the pills are gone
+  assert.equal((VISOR.match(/svgOpen\('visor__frame /g) || []).length, 2, 'two arcs');
+  assert.doesNotMatch(VISOR + css, /visor__cell|visor__mark|visor__line--side|visor__pill/, 'the old frame and the pills are gone');
+  const phone = read('style.css').match(/tasks 1005148 and 1005195, the visor[\s\S]*?\n\}/);
+  assert.ok(phone, 'the phone rules sit in the shared phone block');
+  assert.match(phone[0], /\.visor__hint:not\(\[data-visor-sheet\]\) \{ display: none; \}/, 'a phone keeps only Actions of the hints');
+  assert.doesNotMatch(read('home-city.css'), /visor-on/, 'Home has no top-right pill to clear any more');
+  assert.match(read('city.css'), /\nhtml\.visor-on \.city-door \{ bottom: 150px; \}/, 'the city\'s door clears the centred button at every width');
+});
+
 // ---------- in a browser: the glass over a stand-in scene ----------
 const lib = require(path.join(ROOT, 'modules', 'ui-design', 'kit', 'lib.js'));
 let browser = null;
@@ -95,7 +126,7 @@ after(() => browser && browser.close());
 const skip = !browser && 'no system Edge or Chrome';
 
 const ORIGIN = 'http://hall.test';
-const TYPES = { '.js': 'text/javascript', '.css': 'text/css', '.png': 'image/png' };
+const TYPES = { '.js': 'text/javascript', '.css': 'text/css', '.png': 'image/png', '.svg': 'image/svg+xml' };
 // The stand-in scene: a canvas filling the window that pans on drag, and the sky's Escape rule.
 const SCENE = `<script>
   window.cam = { x: 0, y: 0 }; window.picked = true; window.optionsOpened = 0;
@@ -109,18 +140,23 @@ const SCENE = `<script>
     me() { return { builder: { total_credits: 56021 } }; }, spriteSrc(id) { return '/builders/characters/' + id + '.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>`;
-const PAGE = (game) => `<!doctype html><html${game ? ' data-game="on"' : ''}><head><meta charset="utf-8">
+// `helm` links the hall's real sheet (the token tier) instead of the stand-in colours.
+const PAGE = (game, helm) => helm ? `<!doctype html><html data-theme="dark" data-faces="helm"${game ? ' data-game="on"' : ''}><head><meta charset="utf-8">
+<link rel="stylesheet" href="/builders/style.css"><link rel="stylesheet" href="/builders/visor.css">
+<style>body{margin:0}#world{position:fixed;inset:0;width:100vw;height:100vh;display:block}</style></head>
+<body><canvas id="world"></canvas>${SCENE}<script src="/builders/shell-game.js"></script><script src="/builders/visor.js"></script></body></html>`
+  : `<!doctype html><html${game ? ' data-game="on"' : ''}><head><meta charset="utf-8">
 <link rel="stylesheet" href="/builders/visor.css"><style>:root{--ink:#111;--ink-soft:#555;--ink-faint:#777;--rule:#ccc;--rule-soft:#ddd;--bg-card:#fff;--bg-deep:#eee;--accent:#fb9569;--accent-on:#111;--accent-deep:#a3481a;--focus:#a3481a}
 body{margin:0}#world{position:fixed;inset:0;width:100vw;height:100vh;display:block}</style></head>
 <body><canvas id="world"></canvas>${SCENE}<script src="/builders/shell-game.js"></script><script src="/builders/visor.js"></script></body></html>`;
 
-async function open({ game = true } = {}) {
-  const ctx = await browser.newContext({ viewport: { width: 1280, height: 800 } });
+async function open({ game = true, helm = false, width = 1280, height = 800 } = {}) {
+  const ctx = await browser.newContext({ viewport: { width, height } });
   await ctx.route(ORIGIN + '/**', (route) => {
     const p = new URL(route.request().url()).pathname;
-    if (p === '/' ) return route.fulfill({ contentType: 'text/html', body: PAGE(game) });
-    const f = path.join(HALL, p.replace(/^\/builders\//, ''));
-    if (p.startsWith('/builders/') && TYPES[path.extname(p)] && fs.existsSync(f)) return route.fulfill({ contentType: TYPES[path.extname(p)], body: fs.readFileSync(f) });
+    if (p === '/' ) return route.fulfill({ contentType: 'text/html', body: PAGE(game, helm) });
+    const f = p.startsWith('/modules/') ? path.join(ROOT, p) : path.join(HALL, p.replace(/^\/builders\//, ''));
+    if ((p.startsWith('/builders/') || p.startsWith('/modules/')) && TYPES[path.extname(p)] && fs.existsSync(f)) return route.fulfill({ contentType: TYPES[path.extname(p)], body: fs.readFileSync(f) });
     return route.fulfill({ status: 404, body: '' });
   });
   const page = await ctx.newPage();
@@ -139,12 +175,16 @@ test('outside game mode the hall is as it was: no glass', { skip }, async () =>
   await ctx.close();
 });
 
-test('in game mode the glass shows the place, the main action, the sprite and the credits', { skip }, async () => {
+test('in game mode the glass shows the place, the main action, the key hints, the sprite and the credits', { skip }, async () => {
   const { ctx, page, errors } = await open();
   const g = await page.evaluate(() => ({
     shown: getComputedStyle(document.getElementById('visor')).display,
     place: document.querySelector('.visor__place').textContent,
-    main: document.querySelector('.visor__pill--main').textContent,
+    main: document.querySelector('.visor__main').textContent,
+    hints: [...document.querySelectorAll('.visor__hints .visor__hint')].map((h) => h.textContent),
+    num: document.querySelector('.visor__num').textContent,
+    unit: document.querySelector('.visor__unit').textContent,
+    arcs: document.querySelectorAll('.visor__frame').length,
     who: document.querySelector('.visor__name').textContent,
     credits: document.querySelector('.visor__credits').textContent,
     sprite: document.querySelector('.visor__sprite').getAttribute('src'),
@@ -154,6 +194,10 @@ test('in game mode the glass shows the place, the main action, the sprite and th
   assert.match(g.main, /^Goal sky/, 'Claim a task opens a classic page, so it is off the glass in game mode (task 1005200)');
   assert.equal(g.who, 'Artisan');
   assert.equal(g.credits, '56,021 credits');
+  assert.deepEqual([g.num, g.unit], ['56,021', 'credits'], 'the count and its word are two spans of the same text');
+  // 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.deepEqual(errors, []);
   await ctx.close();
@@ -199,7 +243,10 @@ test('the sheet lists the character\'s actions, then this place, and runs a scen
 test('an Artist\'s glass offers other actions, and its keys open the Artist\'s tools', { skip }, async () => {
   const { ctx, page } = await open();
   await page.evaluate(() => { OTBCraftMode.held = 'artist'; OTBVisor.render(); });
-  assert.match(await page.textContent('.visor__pill--main'), /^Review this page/);
+  assert.match(await page.textContent('.visor__main'), /^Review this page/);
+  assert.deepEqual(await page.$$eval('.visor__hints [data-visor-act]', (h) => h.map((x) => x.getAttribute('data-visor-act'))), ['words', 'idea'], 'the Artist\'s other tools are key hints');
+  await page.click('.visor__hints [data-visor-act="idea"]');
+  assert.equal(await page.evaluate(() => window.toolOpened), 'lightbulb', 'a hint runs its action, like its row in the sheet');
   await page.keyboard.press('e');
   assert.equal(await page.evaluate(() => window.toolOpened), 'paintbrush');
   await ctx.close();
@@ -223,3 +270,74 @@ test('no character, or no scene: no glass', { skip }, async () => {
   assert.equal(await page.evaluate(() => document.getElementById('visor').hidden), true);
   await ctx.close();
 });
+
+// ---------- Helm look 3 (task 1005195): the foot row over the hall's real sheets ----------
+const box = (sel) => `(() => [...document.querySelectorAll(${JSON.stringify(sel)})].filter((e) => e.getClientRects().length).map((e) => { const b = e.getBoundingClientRect(); return { l: b.left, t: b.top, r: b.right, b: b.bottom, w: b.width, h: b.height }; }))()`;
+const apart = (a, b) => a.r <= b.l + 0.5 || b.r <= a.l + 0.5 || a.b <= b.t + 0.5 || b.b <= a.t + 0.5;
+
+for (const [width, height] of [[1440, 900], [390, 844], [320, 640]]) {
+  test(`at ${width}px the foot row fits: no sideways scroll, nothing collides, every control clears 24px`, { skip }, async () => {
+    for (const who of ['artisan', 'artist', 'patron']) {
+      const { ctx, page, errors } = await open({ helm: true, width, height });
+      await page.evaluate((w) => { OTBCraftMode.held = w; OTBVisor.render(); }, who);
+      assert.equal(await page.evaluate(() => document.documentElement.scrollWidth - document.documentElement.clientWidth), 0, `${who}: no sideways scroll`);
+      const [me] = await page.evaluate(box('.visor__me'));
+      const [main] = await page.evaluate(box('.visor__main'));
+      const hints = await page.evaluate(box('.visor__hint'));
+      const parts = [me, main, ...hints];
+      for (const p of parts) assert.ok(p.l >= 0 && p.r <= width + 0.5 && p.b <= height, `${who}: every part is inside the window`);
+      for (let i = 0; i < parts.length; i++) for (let j = i + 1; j < parts.length; j++) assert.ok(apart(parts[i], parts[j]), `${who}: parts ${i} and ${j} keep apart`);
+      for (const p of [main, ...hints]) assert.ok(p.w >= 24 && p.h >= 24, `${who}: a control is at least 24px both ways (${Math.round(p.w)}x${Math.round(p.h)})`);
+      assert.equal(await page.evaluate(() => document.querySelector('[data-visor-sheet]').getClientRects().length), 1, `${who}: Actions is on the glass at every width`);
+      if (width <= 640) {
+        assert.equal(hints.length, 1, `${who}: a phone keeps only Actions of the hints`);
+        assert.equal(await page.evaluate(() => document.querySelectorAll('.visor__place, .visor__frame--top, .visor__notch').length), 3);
+        assert.equal(await page.evaluate(() => [...document.querySelectorAll('.visor__place, .visor__frame--top, .visor__notch')].filter((e) => e.getClientRects().length).length), 0, `${who}: the top of a phone is the scene's`);
+        assert.ok(height - main.b >= 52 - 0.5 && height - main.b < 76, `${who}: the foot row sits lower on a phone`);
+      } else {
+        const [place] = await page.evaluate(box('.visor__place'));
+        const [arc] = await page.evaluate(box('.visor__frame--top'));
+        assert.ok(place && Math.abs((place.l + place.r) / 2 - width / 2) < 1, `${who}: the place is centred under the top arc`);
+        assert.ok(arc.t >= 0 && place.b <= 64, `${who}: the arc and the place keep inside the top inset, above a scene's own top row`);
+      }
+      await page.click('[data-visor-sheet]');
+      const [sheet] = await page.evaluate(box('.visor__sheet'));
+      assert.ok(sheet.l >= 0 && sheet.r <= width && sheet.t >= 0 && sheet.b <= Math.min(...parts.map((p) => p.t)) + 0.5, `${who}: the sheet stands inside the window, over the foot row`);
+      assert.deepEqual(errors, []);
+      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(() => {
+    const cs = (s) => getComputedStyle(document.querySelector(s));
+    const root = getComputedStyle(document.documentElement);
+    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; };
+    return {
+      mainBg: cs('.visor__main').backgroundColor, accent: probe('var(--accent)'), mainClip: cs('.visor__main').clipPath,
+      mainCase: cs('.visor__main').textTransform, hintBg: cs('.visor__hint').backgroundColor, hintBorder: cs('.visor__hint').borderTopWidth,
+      hintColor: cs('.visor__hint').color, ice: probe('var(--ink-soft)'), num: cs('.visor__num').color, unit: cs('.visor__unit').color, white: probe('var(--ink)'),
+      placeShadow: cs('.visor__place').textShadow, radius: cs('.visor__sprite').borderTopLeftRadius, spriteClip: cs('.visor__sprite').clipPath,
+      cut: root.getPropertyValue('--cut-path').trim() !== '',
+    };
+  });
+  assert.equal(g.mainBg, g.accent, 'the one accent fill is the button you press');
+  assert.match(g.mainClip, /^polygon\(/, 'cut corner');
+  assert.equal(g.mainCase, 'uppercase', 'the name voice');
+  assert.equal(g.hintBg, 'rgba(0, 0, 0, 0)');
+  assert.equal(g.hintBorder, '0px', 'a hint has no box');
+  assert.equal(g.hintColor, g.ice, 'hints are ice');
+  assert.equal(g.num, g.white, 'the count is white');
+  assert.equal(g.unit, g.ice, 'its word is ice');
+  assert.notEqual(g.placeShadow, 'none', 'type over the scene wears the halo');
+  assert.equal(g.radius, '0px', 'no round thing on the glass');
+  assert.match(g.spriteClip, /^polygon\(/, 'the sprite sits in a cut box');
+  await page.keyboard.press('Tab');
+  const f = await page.evaluate(() => { const a = document.activeElement; const s = getComputedStyle(a); return { cls: a.className, outline: s.outlineStyle, ring: s.boxShadow }; });
+  assert.equal(f.cls, 'visor__main', 'the accent button is the first stop');
+  assert.equal(f.outline, 'none');
+  assert.match(f.ring, /inset/, 'focus is the inset two-tone ring (--press-focus)');
+  await ctx.close();
+});

package/tests/shell_stat_portability.mjs

@@ -47,3 +47,37 @@ test('the rule catches a lone GNU or BSD stat, and passes the paired form and pr
   assert.equal(offending('U=$(stat -c %U "$d" 2>/dev/null || stat -f %Su "$d" 2>/dev/null)').length, 0);
   assert.equal(offending("  # was stat -c '%s', which BSD refuses").length, 0, 'a comment is not a call');
 });
+
+// --- `head -n -K` — the same bug, a different GNU extension (task 1005096) ------------
+//
+// `head -n -K` means "all but the last K" to GNU and is an ERROR to BSD/macOS head
+// ("illegal line count", exit 1). wedge-remedy.js's disk-full prune used it, so on a Mac
+// the pipeline deleted nothing and the test that runs that command for real could never
+// pass. The command itself runs on a Linux box — but a builder builds wherever they are,
+// so a one-dialect idiom still reds their suite. POSIX awk answers it everywhere:
+//   … | sort | awk -v k=K '{a[NR]=$0} END{for(i=1;i<=NR-k;i++) print a[i]}'
+//
+// Scanned in the .js files too, not only *.sh: this one lived inside a shell string a
+// Node script builds, which the stat scan above would never have seen.
+const GNU_HEAD = /(^|[^\w-])head\s+(-n\s*-\d|--lines[\s=]-\d|-\s*-\d)/;
+
+test('no tracked script asks for `head -n -K`, which BSD/macOS head refuses', () => {
+  const files = execFileSync('git', ['ls-files', '*.sh', 'scripts/*.js', 'scripts/**/*.js'], { cwd: ROOT, encoding: 'utf8' })
+    .split('\n').filter(Boolean);
+  assert.ok(files.length > 20, `the scan must see the scripts, got ${files.length}`);
+  const hits = files.flatMap((f) => fs.readFileSync(path.join(ROOT, f), 'utf8')
+    .split('\n').map((l, i) => ({ n: i + 1, l }))
+    .filter(({ l }) => !/^\s*(#|\/\/)/.test(l) && GNU_HEAD.test(l))
+    .map(({ n, l }) => `${f}:${n}: ${l.trim()}`));
+  assert.deepEqual(hits, [], "all but the last K: sort | awk -v k=K '{a[NR]=$0} END{for(i=1;i<=NR-k;i++) print a[i]}'");
+});
+
+test('the head rule catches the GNU forms and leaves an ordinary head alone', () => {
+  const hit = (s) => GNU_HEAD.test(s);
+  assert.equal(hit("… | head -n -7 | xargs rm -f --"), true);
+  assert.equal(hit('… | head -n-7'), true);
+  assert.equal(hit('… | head --lines=-7'), true);
+  assert.equal(hit('… | head -n 7'), false, 'the ordinary form is portable');
+  assert.equal(hit('… | head -7'), false);
+  assert.equal(hit('git log | head -n 20'), false);
+});

package/tests/ship_vendored_instance.mjs

@@ -76,7 +76,11 @@ function writeFile(p, body) {
 
 // Build one fixture. `mainAt`: 'primary' | 'linked' | 'none'.
 function buildFixture(mainAt) {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), `bongos-vendored-${mainAt}-`));
+  // realpath'd (task 1005096): on a Mac os.tmpdir() is /var/folders/…, a symlink to
+  // /private/var/folders/…, and resolveRoots answers with git's own answer — the /private
+  // form. Comparing the two spellings failed on every Mac and passed on CI's Linux, which
+  // has no such link. The fixture names the path the code under test will name.
+  const root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), `bongos-vendored-${mainAt}-`)));
   const origin = path.join(root, 'origin.git');
   const inst = path.join(root, 'instance');
   git(root, 'init', '--bare', '-b', 'main', origin);

package/tests/update_sweep_home.mjs

@@ -14,7 +14,7 @@ import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { createRequire } from 'node:module';
 import { spawnSync } from 'node:child_process';
-import { mkdtempSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, realpathSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -23,6 +23,12 @@ const require = createRequire(import.meta.url);
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const SWEEP = path.join(ROOT, 'scripts', 'bongos', 'update-sweep.js');
 const sweep = require(SWEEP);
+
+// A temp folder the code under test and this test can BOTH name the same way (task 1005096).
+// On a Mac os.tmpdir() is /var/folders/…, a symlink to /private/var/folders/…: anything that
+// resolves a real path — as the sweep's resolver and git both do — answers the /private form,
+// and the comparison failed on every Mac while passing on CI's Linux, which has no such link.
+const tmpRoot = (prefix) => realpathSync(mkdtempSync(path.join(tmpdir(), prefix)));
 const { isPublishable } = require('../scripts/bongos/publish-manifest.js');
 
 test('the sweep and every core file it requires are in the published package', () => {
@@ -50,7 +56,7 @@ test('its target-instance resolver searches the same packages, in the same order
 });
 
 test('coreModulePathFrom finds a target instance\'s INSTALLED core, root first', () => {
-  const inst = mkdtempSync(path.join(tmpdir(), 'sweep-home-'));
+  const inst = tmpRoot('sweep-home-');
   const pkg = path.join(inst, 'node_modules', '@bongos', 'core', 'scripts', 'bongos');
   mkdirSync(pkg, { recursive: true });
   writeFileSync(path.join(pkg, 'upgrade.js'), '');
@@ -62,11 +68,11 @@ test('coreModulePathFrom finds a target instance\'s INSTALLED core, root first',
 });
 
 test('run from elsewhere, it reads the roster named by --instance and says which core is sweeping', () => {
-  const rosterRoot = mkdtempSync(path.join(tmpdir(), 'sweep-roster-'));
+  const rosterRoot = tmpRoot('sweep-roster-');
   mkdirSync(path.join(rosterRoot, 'config'));
   writeFileSync(path.join(rosterRoot, 'config', 'update-subscriptions.json'),
     JSON.stringify({ instances: [{ slug: 'held', dir: path.join(rosterRoot, 'nowhere'), channel: 'pinned' }] }));
-  const cwd = mkdtempSync(path.join(tmpdir(), 'sweep-cwd-'));
+  const cwd = tmpRoot('sweep-cwd-');
   const r = spawnSync(process.execPath, [SWEEP, '--instance', rosterRoot], { cwd, encoding: 'utf8', env: { ...process.env, DATABASE_URL: '', PGDATABASE: '' } });
   assert.equal(r.status, 0, r.stderr);
   assert.match(r.stdout, new RegExp(`update-sweep · running from .+ \\(core \\d+\\.\\d+\\.\\d+\\) · roster ${rosterRoot.replace(/[\\^$.*+?()[\]{}|]/g, '\\$&')}`));
@@ -75,7 +81,7 @@ test('run from elsewhere, it reads the roster named by --instance and says which
 });
 
 test('without --instance it reads the roster in its working directory (the unit\'s WorkingDirectory)', () => {
-  const cwd = mkdtempSync(path.join(tmpdir(), 'sweep-cwd-'));
+  const cwd = tmpRoot('sweep-cwd-');
   const r = spawnSync(process.execPath, [SWEEP], { cwd, encoding: 'utf8', env: { ...process.env, DATABASE_URL: '', PGDATABASE: '' } });
   assert.equal(r.status, 0, r.stderr);
   assert.match(r.stdout, /no roster file — nothing subscribed/);

package/tests/wedge_remedy.mjs

@@ -75,7 +75,11 @@ await t('a cloud-host project is fixed in ITS folder, not the control plane\'s',
 await t('disk full: prunes only THIS database\'s dumps, keeping the newest week', () => {
   const p = W.planRemedy(inst(), 'disk_full', { selfRoot, backupDir: '/var/backups/gds' });
   assert.match(p.cmd, /^find \/var\/backups\/gds -maxdepth 1 -type f -name 'charter-\[0-9\]/);
-  assert.match(p.cmd, new RegExp(`head -n -${W.DUMP_KEEP_FLOOR} \\| xargs -r rm -f --$`));
+  // All-but-the-last-K in POSIX awk, never `head -n -K`: that is a GNU extension BSD/macOS
+  // head refuses outright, so the pipeline deleted nothing on a Mac (task 1005096).
+  assert.match(p.cmd, new RegExp(`awk -v k=${W.DUMP_KEEP_FLOOR} `));
+  assert.match(p.cmd, /\| xargs rm -f --$/);
+  assert.doesNotMatch(p.cmd, /head -n -/, 'GNU-only; BSD head answers "illegal line count"');
   assert.equal(W.DUMP_KEEP_FLOOR, 7);
 });