@bongos/core 1.19.1081 → 1.20.2

package/tests/core_262_drop_box_blocked_db.mjs

@@ -0,0 +1,143 @@
+// tests/core_262_drop_box_blocked_db.mjs
+//
+// task 1004360 — core_262 drops the four builders.box_blocked* columns migration 104
+// added, and re-runs cleanly.
+//
+// HOW THIS PROVES IT. The lane database is already migrated, so core_262 has run: the
+// first case asserts `builders` carries no box_blocked column, which is the done-when's
+// `\d builders` check. The second case, inside ONE transaction that is ALWAYS rolled
+// back, puts the columns back the way migration 104 had them (with a blocked builder
+// whose box_blocked_by points at another builder, so the foreign key is live), runs
+// core_262's own statements (its BEGIN and COMMIT stripped so they join this
+// transaction), and then runs them a second time. Nothing is committed.
+//
+// Real-DB (self-skips without Postgres; belongs in the INTEGRATION set).
+//
+// Run:  DATABASE_URL=postgres://... node tests/core_262_drop_box_blocked_db.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const require = createRequire(import.meta.url);
+const { Pool } = require('pg');
+
+const root = join(dirname(fileURLToPath(import.meta.url)), '..');
+const migrationText = readFileSync(join(root, 'migrations/core_262_drop_builder_box_blocked.sql'), 'utf8');
+const addedBy104 = readFileSync(join(root, 'migrations/104_builder_box_blocked.sql'), 'utf8')
+  .match(/ALTER TABLE builders[\s\S]*?;/)[0];
+
+const wrapper = /^\s*(BEGIN|COMMIT);\s*$/gm;
+assert.equal((migrationText.match(wrapper) || []).length, 2, 'core_262 is expected to carry exactly one BEGIN and one COMMIT');
+const migrationBody = migrationText.replace(wrapper, '');
+
+const COLUMNS = ['box_blocked', 'box_blocked_reason', 'box_blocked_at', 'box_blocked_by'];
+
+const pool = new Pool({ connectionString: process.env.DATABASE_URL || undefined });
+
+let passed = 0;
+let failed = 0;
+let client;
+async function test(name, fn) {
+  await client.query('SAVEPOINT t');
+  try {
+    await fn();
+    passed++; console.log(`  ok  ${name}`);
+    await client.query('RELEASE SAVEPOINT t');
+  } catch (err) {
+    failed++; console.error(`  FAIL ${name}\n    ${err.message}`);
+    await client.query('ROLLBACK TO SAVEPOINT t');
+  }
+}
+
+// Schema-driven insert (the helper of tests/session_earnings_mirror_db.mjs): fills any
+// NOT NULL column with no default. Identifiers come from this file or information_schema.
+const schemaCache = new Map();
+async function insertRow(table, explicit = {}) {
+  if (!schemaCache.has(table)) {
+    const { rows } = await client.query(
+      `SELECT column_name, data_type, is_nullable, column_default, is_identity
+         FROM information_schema.columns WHERE table_schema = 'public' AND table_name = $1`, [table]);
+    schemaCache.set(table, rows);
+  }
+  const cols = schemaCache.get(table);
+  if (cols.length === 0) throw new Error(`table ${table} not found — is this database migrated?`);
+  const values = { ...explicit };
+  for (const c of cols) {
+    if (c.column_name in values || c.is_nullable === 'YES' || c.column_default !== null || c.is_identity === 'YES') continue;
+    switch (c.data_type) {
+      case 'integer': case 'bigint': case 'smallint': case 'numeric': case 'real': case 'double precision':
+        values[c.column_name] = 0; break;
+      case 'boolean': values[c.column_name] = false; break;
+      case 'timestamp with time zone': case 'timestamp without time zone': case 'date':
+        values[c.column_name] = new Date(); break;
+      case 'json': case 'jsonb': values[c.column_name] = {}; break;
+      case 'ARRAY': values[c.column_name] = []; break;
+      default: values[c.column_name] = `c261-${c.column_name}`;
+    }
+  }
+  const names = Object.keys(values);
+  const { rows } = await client.query(
+    `INSERT INTO ${table} (${names.map((n) => `"${n}"`).join(', ')})
+     VALUES (${names.map((_, i) => `$${i + 1}`).join(', ')}) RETURNING *`,
+    names.map((n) => values[n]));
+  return rows[0];
+}
+
+async function boxColumns() {
+  const { rows } = await client.query(
+    `SELECT column_name FROM information_schema.columns
+      WHERE table_schema = 'public' AND table_name = 'builders' AND column_name LIKE 'box\\_blocked%'
+      ORDER BY column_name`);
+  return rows.map((r) => r.column_name);
+}
+
+async function main() {
+  try {
+    client = await pool.connect();
+  } catch {
+    console.log('core_262_drop_box_blocked_db: no Postgres (DATABASE_URL unset/unreachable) — skipping');
+    process.exit(0);
+  }
+
+  await client.query('BEGIN');
+  try {
+    await test('the migrated database has no box_blocked column on builders', async () => {
+      assert.deepEqual(await boxColumns(), []);
+    });
+
+    await test('core_262 drops the columns migration 104 added, FK and all, and re-runs as a no-op', async () => {
+      await client.query(addedBy104);
+      assert.deepEqual(await boxColumns(), [...COLUMNS].sort(), 'migration 104 should have put all four back');
+
+      const tag = `c261-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+      const builder = (n) => insertRow('builders', { github_id: `${tag}-${n}`, github_login: `${tag}-${n}`, display_name: tag, total_credits: 0 });
+      const archon = await builder('a');
+      const blocked = await builder('b');
+      await client.query(
+        `UPDATE builders SET box_blocked = true, box_blocked_reason = 'test', box_blocked_at = now(), box_blocked_by = $1
+          WHERE id = $2`, [archon.id, blocked.id]);
+
+      await client.query(migrationBody);
+      assert.deepEqual(await boxColumns(), [], 'every box_blocked column must be gone');
+      const { rows } = await client.query('SELECT id FROM builders WHERE id = ANY($1::bigint[])', [[archon.id, blocked.id]]);
+      assert.equal(rows.length, 2, 'dropping the columns must not touch the builder rows');
+
+      await client.query(migrationBody);
+      assert.deepEqual(await boxColumns(), [], 'a re-run must be a clean no-op');
+    });
+  } finally {
+    await client.query('ROLLBACK');
+    client.release();
+    await pool.end();
+  }
+
+  console.log(`\ncore_262_drop_box_blocked_db: ${passed} passed, ${failed} failed`);
+  // Let the socket close before exiting (a libuv abort otherwise on some boxes).
+  await new Promise((r) => setTimeout(r, 100));
+  process.exit(failed === 0 ? 0 : 1);
+}
+
+main().catch((err) => { console.error(err); process.exit(1); });

package/tests/core_upgrade_runner.mjs

@@ -1184,6 +1184,7 @@ function pinDeps({ served = '1.19.762', token = OWNER_TOKEN, branch = 'main', pu
     d.ran.push(cmd);
     if (/upgrade\.js/.test(cmd) && upgradeThrows) throw new Error('health check failed after restart — rolled back');
     if (/\/version/.test(cmd)) return { ok: true, stdout: JSON.stringify({ coreVersion: served }) };
+    if (/^id -u /.test(cmd)) return { ok: true, stdout: '1001\n' };   // the project has its own account (ADR 0350)
     if (/symbolic-ref/.test(cmd)) {
       return branch ? { ok: true, stdout: `${branch}\n` } : { ok: true, softFailed: true, stdout: '', stderr: 'fatal: ref HEAD is not a symbolic ref' };
     }

package/tests/dependency_writes_atomic.mjs

@@ -0,0 +1,191 @@
+// tests/dependency_writes_atomic.mjs
+//
+// DB-free guard for the dependency WRITE paths (task 1004191, the audit of the
+// nine never-verified findings split out of task 1000379):
+//
+//   findings 63 / 81  POST /tasks/:id/dependencies wrote edge-by-edge on the pool,
+//                     so an error on the Nth id left ids 1..N-1 committed and the
+//                     caller got an error that did not mention them.
+//   finding 75        the cycle check and the INSERT ran on different pool
+//                     connections, so two concurrent writers (A->B and B->A) could
+//                     each pass the check and together commit a cycle.
+//   finding 64        PUT /tasks/:id/dependencies never checked the task or the
+//                     dependency ids existed (there is no FK — the target table
+//                     varies by kind), so a typo wrote an orphan edge that blocks
+//                     the task forever, and a non-numeric id surfaced as a 500.
+//
+// Every writer now runs in ONE transaction that first takes one advisory lock over
+// the whole graph, then checks existence and cycles on the SAME client it inserts
+// with. These tests pin that shape with a recording fake pool — the same posture as
+// dependencies_polymorphic.mjs (no local DB; the SQL runtime is proven at deploy).
+//
+// Run:  node tests/dependency_writes_atomic.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import { readFileSync } from 'node:fs';
+import { makeRunner } from './helpers.mjs';
+
+process.env.NODE_ENV = 'test';
+const require = createRequire(import.meta.url);
+const db = require('../modules/lifecycle/db.js');
+const { addTaskDependencies, addTaskDependency, setTaskDependencies, addDependency } = db;
+
+const { test, summary } = makeRunner();
+
+// A fake pool whose connect() hands out ONE recording client. `existing` is the set
+// of task ids the fake tasks table holds; `cycleFor` returns a path (or null) for a
+// (fromId, toId) cycle probe; `nodes` (when set) is the id set for generic nodes.
+function fakePool({ existing = [], cycleFor = () => null, nodes = null } = {}) {
+  const log = [];
+  let connects = 0;
+  const norm = (s) => String(s).replace(/\s+/g, ' ').trim();
+  const client = {
+    query: async (sql, params = []) => {
+      const s = norm(sql);
+      log.push({ sql: s, params });
+      if (/^SELECT id FROM tasks WHERE id = ANY/.test(s)) {
+        const want = params[0].map(Number);
+        return { rows: want.filter((id) => existing.includes(id)).map((id) => ({ id: String(id) })) };
+      }
+      if (/^SELECT 1 FROM (tasks|goals|done_when_criteria) WHERE id = \$1/.test(s)) {
+        const ok = nodes ? nodes.includes(Number(params[0])) : true;
+        return { rows: ok ? [{ '?column?': 1 }] : [] };
+      }
+      if (/WITH RECURSIVE walk/.test(s)) {
+        // params: [toKind, toId, fromKind, fromId]
+        const path = cycleFor(Number(params[3]), Number(params[1]));
+        return { rows: path ? [{ path }] : [] };
+      }
+      return { rows: [], rowCount: 0 };
+    },
+    release: () => {},
+  };
+  return {
+    log,
+    get connects() { return connects; },
+    connect: async () => { connects += 1; return client; },
+    // Anything that reaches for the pool directly (not the tx client) is the bug.
+    query: async (sql) => { throw new Error(`write path used the bare pool, not the tx client: ${norm(sql)}`); },
+  };
+}
+const idx = (log, re) => log.findIndex((q) => re.test(q.sql));
+const has = (log, re) => log.some((q) => re.test(q.sql));
+
+// ============================ POST (findings 63/81 + 75) ============================
+
+await test('addTaskDependencies: one transaction, lock BEFORE the reads, inserts on the same client', async () => {
+  const p = fakePool({ existing: [1, 2, 3] });
+  const out = await addTaskDependencies(1, [2, 3], { pool: p });
+  assert.deepEqual(out, [2, 3]);
+  assert.equal(p.connects, 1, 'exactly one connection for the whole batch');
+  const L = p.log;
+  assert.equal(L[0].sql, 'BEGIN');
+  const lock = idx(L, /pg_advisory_xact_lock/);
+  const exist = idx(L, /SELECT id FROM tasks WHERE id = ANY/);
+  const cycle = idx(L, /WITH RECURSIVE walk/);
+  const insert = idx(L, /INSERT INTO dependencies/);
+  assert.ok(lock > 0 && lock < exist && exist < cycle && cycle < insert,
+    `order must be BEGIN, lock, existence, cycle, insert — got ${L.map((q) => q.sql.slice(0, 20)).join(' | ')}`);
+  assert.equal(L.filter((q) => /INSERT INTO dependencies/.test(q.sql)).length, 2);
+  assert.equal(L[L.length - 1].sql, 'COMMIT');
+});
+
+await test('addTaskDependencies: a cycle on the 2nd id ROLLS BACK the 1st (no partial write)', async () => {
+  const p = fakePool({ existing: [1, 2, 3], cycleFor: (from, to) => (to === 3 ? ['task:3', 'task:1'] : null) });
+  await assert.rejects(addTaskDependencies(1, [2, 3], { pool: p }), (e) => e.code === 'CYCLE');
+  assert.ok(has(p.log, /INSERT INTO dependencies/), 'the first edge was written inside the tx…');
+  assert.ok(has(p.log, /^ROLLBACK$/), '…and the tx rolled it back');
+  assert.ok(!has(p.log, /^COMMIT$/), 'nothing committed');
+});
+
+await test('addTaskDependencies: a missing dependency id is TASK_NOT_FOUND naming it, before any INSERT', async () => {
+  const p = fakePool({ existing: [1, 2] });
+  await assert.rejects(addTaskDependencies(1, [2, 99], { pool: p }),
+    (e) => e.code === 'TASK_NOT_FOUND' && JSON.stringify(e.missing) === '[99]');
+  assert.ok(!has(p.log, /INSERT INTO dependencies/));
+  assert.ok(has(p.log, /^ROLLBACK$/));
+});
+
+await test('addTaskDependencies: self-dep and bad ids refuse without opening a connection', async () => {
+  const p = fakePool({ existing: [1, 2] });
+  await assert.rejects(addTaskDependencies(1, [2, 1], { pool: p }), (e) => e.code === 'SELF_DEP');
+  await assert.rejects(addTaskDependencies(1, ['abc'], { pool: p }), (e) => e.code === 'BAD_ID');
+  await assert.rejects(addTaskDependencies(1, [0], { pool: p }), (e) => e.code === 'BAD_ID');
+  assert.equal(p.connects, 0);
+});
+
+await test('addTaskDependency (singular, goals.js caller) keeps its return shape and goes through the tx', async () => {
+  const p = fakePool({ existing: [5, 6] });
+  const out = await addTaskDependency(5, 6, { pool: p });
+  assert.deepEqual(out, { task_id: 5, depends_on_task_id: 6 });
+  assert.ok(has(p.log, /pg_advisory_xact_lock/));
+});
+
+// ============================ PUT (finding 64 + 75) ============================
+
+await test('setTaskDependencies: a missing TASK is TASK_NOT_FOUND before the DELETE (was: 200 + orphan edges)', async () => {
+  const p = fakePool({ existing: [2] });
+  await assert.rejects(setTaskDependencies(424242, [2], { pool: p }),
+    (e) => e.code === 'TASK_NOT_FOUND' && e.missing.includes(424242));
+  assert.ok(!has(p.log, /^DELETE FROM dependencies/), 'never deletes for a task that does not exist');
+  assert.ok(!has(p.log, /INSERT INTO dependencies/));
+});
+
+await test('setTaskDependencies: a missing DEP id is TASK_NOT_FOUND, not an orphan edge', async () => {
+  const p = fakePool({ existing: [1] });
+  await assert.rejects(setTaskDependencies(1, [77], { pool: p }), (e) => e.code === 'TASK_NOT_FOUND');
+  assert.ok(!has(p.log, /INSERT INTO dependencies/));
+});
+
+await test('setTaskDependencies: a non-numeric id is BAD_ID (was: a pg cast error surfacing as 500)', async () => {
+  const p = fakePool({ existing: [1] });
+  await assert.rejects(setTaskDependencies(1, ['nope'], { pool: p }), (e) => e.code === 'BAD_ID');
+  assert.equal(p.connects, 0);
+});
+
+await test('setTaskDependencies: lock precedes existence + DELETE; empty list still clears', async () => {
+  const p = fakePool({ existing: [1] });
+  const out = await setTaskDependencies(1, [], { pool: p });
+  assert.deepEqual(out, []);
+  const lock = idx(p.log, /pg_advisory_xact_lock/);
+  assert.ok(lock > 0 && lock < idx(p.log, /SELECT id FROM tasks/) && lock < idx(p.log, /^DELETE FROM dependencies/));
+});
+
+// ============================ generic edge (finding 75) ============================
+
+await test('addDependency: existence, cycle check and insert share one locked transaction', async () => {
+  const p = fakePool();
+  await addDependency('task', 1, 'goal', 2, { pool: p });
+  assert.equal(p.connects, 1);
+  const lock = idx(p.log, /pg_advisory_xact_lock/);
+  assert.ok(lock > 0 && lock < idx(p.log, /WITH RECURSIVE walk/) && lock < idx(p.log, /INSERT INTO dependencies/));
+  assert.equal(p.log[p.log.length - 1].sql, 'COMMIT');
+});
+
+await test('addDependency: a missing node rolls back with NODE_NOT_FOUND', async () => {
+  const p = fakePool({ nodes: [1] });
+  await assert.rejects(addDependency('task', 1, 'goal', 2, { pool: p }), (e) => e.code === 'NODE_NOT_FOUND');
+  assert.ok(!has(p.log, /INSERT INTO dependencies/));
+});
+
+// ============================ routes map the new codes ============================
+
+await test('routes/tasks.js: POST uses the atomic batch writer and both writers map TASK_NOT_FOUND→404, BAD_ID→400', () => {
+  const src = readFileSync(new URL('../modules/lifecycle/routes/tasks.js', import.meta.url), 'utf8');
+  const post = src.slice(src.indexOf("router.post('/tasks/:id/dependencies'"), src.indexOf("router.delete('/tasks/:id/dependencies/:depId'"));
+  const put = src.slice(src.indexOf("router.put('/tasks/:id/dependencies'"), src.indexOf('task↔criterion links'));
+  assert.match(post, /db\.addTaskDependencies\(/, 'POST writes the whole list in one call');
+  assert.doesNotMatch(post, /for \(const depId of depIds\)/, 'no per-id write loop left in the route');
+  for (const [name, body] of [['POST', post], ['PUT', put]]) {
+    assert.match(body, /mapTaskDepError\(/, `${name} maps writer errors through the shared mapper`);
+  }
+  const at = src.indexOf('function mapTaskDepError');
+  assert.ok(at >= 0, 'mapTaskDepError is defined');
+  const mapper = src.slice(at, at + 900);
+  assert.match(mapper, /TASK_NOT_FOUND[\s\S]*404/);
+  assert.match(mapper, /BAD_ID[\s\S]*400/);
+  assert.match(mapper, /CYCLE[\s\S]*409/);
+});
+
+summary();

package/tests/deploy_page_projects.mjs

@@ -616,7 +616,8 @@ test('when the fix is reconnecting GitHub, the page links straight to it and com
     const html = b.panel();
     assert.match(html, /href="\/api\/bongos\/auth\/web\/start\?repos=1&return=%2Fdeploy%3Fproject%3Dmercury"/,
       `${code}: the repo-access sign-in, returning to this project's deploy page — got ${html}`);
-    assert.match(html, /within the hour/i, `${code}: and it says the access is short-lived, rather than promising a fix`);
+    assert.match(html, /lasting/i, `${code}: and it says reconnecting sets up LASTING access (task 1004291)`);
+    assert.doesNotMatch(html, /within the hour|about an hour/i, `${code}: no more one-hour promise`);
   }
 });
 

package/tests/effective_visibility_predicate.mjs

@@ -130,6 +130,21 @@ const SPELLING_EXEMPTIONS = [
     obligation: (code) => /require\(\s*'\.\/account-visibility'\s*\)/.test(code),
     demands: 'still imports the shared predicate rather than re-deriving one',
   },
+  {
+    // task 1004259: the kit's DB-less stub answers the hub account page's own-scoped
+    // GET/PATCH /me/cross-project from ONE fixture account, so a probe that saves
+    // "private" re-reads what the real route would answer. It mirrors the route's
+    // DERIVED answer (recruiter_discoverable_effective) and setAccountPrivacy's
+    // consent reset for that fixture — it gates no read of any real account and
+    // serves no public surface, so it is a test double, not a variant.
+    file: 'modules/ui-design/kit/serve.js',
+    allow: [
+      { text: "account_visibility !== '", count: 2, why: "effectiveReach (the fixture's recruiter_discoverable_effective, the stand-in for isRecruiterDiscoverable) and the 'was it public before this PATCH' half of the consent reset — both over the one fixture account a render or probe edits, never a real row." },
+      { text: "account_visibility === '", count: 1, why: "the other half of that consent reset: going private without naming reach clears it, as setAccountPrivacy does — a write-side mirror over the fixture, gating no read." },
+    ],
+    obligation: (code) => !/\.query\s*\(/.test(code) && !/require\(\s*'pg'\s*\)/.test(code),
+    demands: 'issues no database query and loads no database driver — it answers from fixtures only',
+  },
   {
     file: 'scripts/gds/seed-bv1-privacy-invites-tasks.js',
     allow: [

package/tests/est_advisory.mjs

@@ -167,6 +167,33 @@ await t('buildEstAdvisory returns the advisory on the happy path', async () => {
   assert.match(a.next_step, /PATCH \/tasks\/77/);
 });
 
+// ---- 6. the population is cached, not re-aggregated on every create (task 1003656) ----
+await t('calibrationSummary caches the aggregate for a TTL, coalesces, and never caches a failure', async () => {
+  const { calibrationSummary, resetCalibrationCache, CALIBRATION_TTL_MS } = require('../modules/lifecycle/est-advisory.js');
+  assert.ok(CALIBRATION_TTL_MS > 0);
+  resetCalibrationCache();
+  let queries = 0;
+  let fail = false;
+  const pool = { query: async () => { queries++; if (fail) throw new Error('pg down'); return { rows: SUMMARY }; } };
+  let clock = 1000;
+  const now = () => clock;
+  // Concurrent creates share ONE query.
+  await Promise.all([calibrationSummary({ pool, now }), calibrationSummary({ pool, now }), calibrationSummary({ pool, now })]);
+  assert.equal(queries, 1, 'concurrent callers coalesce onto one aggregate');
+  assert.deepEqual(await calibrationSummary({ pool, now }), SUMMARY);
+  assert.equal(queries, 1, 'within the TTL the cached rows are served');
+  clock += CALIBRATION_TTL_MS + 1;
+  await calibrationSummary({ pool, now });
+  assert.equal(queries, 2, 'after the TTL it recomputes');
+  // A failure propagates and is not cached: the next call retries.
+  clock += CALIBRATION_TTL_MS + 1; fail = true;
+  await assert.rejects(calibrationSummary({ pool, now }), /pg down/);
+  fail = false;
+  assert.deepEqual(await calibrationSummary({ pool, now }), SUMMARY);
+  assert.equal(queries, 4, 'a failed read left nothing cached');
+  resetCalibrationCache();
+});
+
 await t('the route attaches est_advisory to the 201 body, non-blocking', () => {
   // Mirrors the goal_advisory contract test. The call is folded into the response
   // literal because modules/lifecycle/routes/tasks.js is over the size ratchet's

package/tests/goal_map_page.mjs

@@ -446,5 +446,31 @@ await test('the ledger drawer accessible name matches its visible heading (docs/
   assert.equal(label, 'The ledger');
 });
 
+// task 1004342: "the sky got skewed left". The stage clipped its overflow with
+// `overflow: hidden`, and a hidden-overflow box is still a SCROLL container: the
+// footer's one-line hint (#alt, white-space: nowrap) ran past the stage's right
+// edge, and when focus moved (skipping the tour did it) the browser scrolled the
+// stage sideways to show it, sliding the whole sky left, 233px at 1024 wide. A
+// zoomed-in window is narrower, so more of the hint overflowed and it got worse.
+// `overflow: clip` clips the same pixels and is NOT scrollable, so nothing can
+// slide the sky again whatever overflows; and the hint now shrinks instead.
+await test('the sky cannot be scrolled sideways: its box clips, it does not hide (task 1004342)', () => {
+  const css = read('thinking.css');
+  const rule = /body\[data-page="goal-map"\], body\[data-page="thinking"\] \.sky-stage \{ margin: 0;[^}]*\}/.exec(css);
+  assert.ok(rule, 'the shared stage rule is still there');
+  // hidden first as the fallback for an engine without clip, then clip, which wins where supported
+  assert.match(rule[0], /overflow: hidden; overflow: clip;/, 'the stage clips (not scrollable), with hidden only as a fallback');
+  assert.match(css, /body\[data-page="thinking"\] \{ overflow: hidden; overflow: clip; \}/, 'and so does the page body');
+});
+
+await test('the footer hint shrinks with an ellipsis instead of running past the stage (task 1004342)', () => {
+  const css = read('thinking.css');
+  const alt = /\n\.alt \{[^}]*\}/.exec(css);
+  assert.ok(alt, 'the .alt rule');
+  assert.match(alt[0], /min-width: 0/, 'a flex child only shrinks below its content with min-width: 0');
+  assert.match(alt[0], /overflow: hidden/);
+  assert.match(alt[0], /text-overflow: ellipsis/);
+});
+
 console.log('');
 summary();