@bongos/core 1.23.19 → 1.23.21

package/release-notes.json

@@ -10503,5 +10503,17 @@
       "id": "1004902",
       "text": "The community page now opens on a Community home: the builder of the week, of the month and of the year side by side, how they are chosen, and a button to each community page. The leaderboard has its own page now, and Communit"
     }
+  ],
+  "1.23.20": [
+    {
+      "id": "1002983",
+      "text": "The Community home now shows a rising builder and the projects on the move this month, under the builders of the week, month and year."
+    }
+  ],
+  "1.23.21": [
+    {
+      "id": "1004904",
+      "text": "In Tweak Mode, the shared top bar, navigation, footer and skip link no longer clutter every page; each is now its own page to review once."
+    }
   ]
 }

package/scripts/bongos/copy-apply.js

@@ -62,6 +62,7 @@ const ci = require('./copy-inventory.js');
 const proposals = require('../../modules/copy-desk/proposals.js');
 // The page tweak format's one reader and writer (ADR 0341 D4), for --batch.
 const pages = require('../../modules/copy-desk/pages.js');
+const chromePages = require('../../modules/copy-desk/chrome-pages.js');
 const { apiCall, arg, hasFlag, cliExit } = require('./cli-lib.js');
 
 const REPO_ROOT = path.resolve(__dirname, '..', '..');
@@ -559,7 +560,8 @@ function rereadStalePages({ spawn = spawnSync } = {}) {
 function readingFor(pageId, { readFile = (p) => fs.readFileSync(p, 'utf8') } = {}) {
   try {
     const doc = JSON.parse(readFile(path.join(REPO_ROOT, 'docs', 'page-readings.json')));
-    return (doc.pages || []).find((p) => p.id === pageId) || null;
+    // A shared-chrome page (task 1004904) exists only in the derived reading.
+    return (chromePages.splitReadings(doc).readings.pages || []).find((p) => p.id === pageId) || null;
   } catch { return null; }
 }
 

package/scripts/bongos/run-unit-tests.js

@@ -79,6 +79,10 @@ const INTEGRATION = new Set([
   // keeps the week's baseline rule, the year counts from a row's first snapshot inside
   // it, the pin under a hide and two racing writers. The DB-free sibling is community_crowns.
   'community_crowns_db',
+  // task 1002983: the rising builder and the projects on the move against real SQL — the
+  // year's baseline over 30 days, a quiet row's live total, hidden and private left out.
+  // The DB-free sibling is community_movers.
+  'community_movers_db',
   // bfg, bfg_write, memory_isolation, memory_pull and setup_smoke LEFT this set under task
   // 1004865: none of them ever needed a database. Each failed on a stale test harness (a fake
   // server without res.fail, a stub on the wrong module, an old error shape, a renamed session

package/scripts/bongos/tweak-renders.js

@@ -87,10 +87,17 @@ function slotFilesIn(dir, { exists = (p) => fs.existsSync(p) } = {}) {
 
 // ---- the browser half --------------------------------------------------------
 
+// The inventory as Tweak Mode sees it, shared-chrome pages included (task 1004904):
+// the committed file does not list them, so planning from it alone is unknown_page.
+function derivedInventory() {
+  const r = require('../../modules/copy-desk/page-data.js').loadInventory();
+  return r.ok ? r.data : { pages: [] };
+}
+
 async function shoot({ pageId, phase, out }) {
   const reader = require('./page-reader.js');
   const kit = require('../../modules/ui-design/kit/lib');
-  const inventory = JSON.parse(fs.readFileSync(path.join(REPO_ROOT, reader.INVENTORY_REL), 'utf8'));
+  const inventory = derivedInventory();
   const planned = planForPage(pageId, { inventory, planRenders: reader.planRenders });
   if (!planned.ok) { console.error(`tweak-renders: ${planned.code} (${pageId})`); return 2; }
   const { page, plan } = planned;
@@ -172,7 +179,7 @@ async function main(args) {
     if (!pageId) { console.error('usage: node scripts/bongos/tweak-renders.js shoot --page <id> --phase before|after --out <dir>'); return 2; }
     if (cmd === 'plan') {
       const reader = require('./page-reader.js');
-      const inventory = JSON.parse(fs.readFileSync(path.join(REPO_ROOT, reader.INVENTORY_REL), 'utf8'));
+      const inventory = derivedInventory();
       const planned = planForPage(pageId, { inventory, planRenders: reader.planRenders });
       if (!planned.ok) { console.error(`tweak-renders: ${planned.code} (${pageId})`); return 2; }
       for (const phase of taskVisuals.TWEAK_RENDER_PHASES) for (const s of shotsFor(phase, planned.plan)) console.log(`${s.slot}\t${s.width}px\t${s.renderMode}\t${planned.plan.url}`);

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

@@ -0,0 +1,280 @@
+// tests/community_movers.mjs — the rising builder and the projects on the move behind the
+// row under the crowns on the hub's /community home (task 1002983).
+//
+// DB-free. A fake pool answers each statement by its shape. Which snapshots open and close
+// the 30 days, and the baseline a quiet row brings, need a real Postgres:
+// tests/community_movers_db.mjs.
+//
+// What this pins:
+//   1. the statement: the crowns' period rows by the year's rule over the last 30 days, the
+//      numbers predicate, and a quiet row's live total as its baseline.
+//   2. the rising builder: under RISING_BASE_MAX before, at least one work, the crowns' tie
+//      order; a builder who may not be shown is not counted.
+//   3. the projects: named only on the map with the Public door, ranked by works then
+//      credits, at most PROJECTS_MAX, counting only builders who may be shown.
+//   4. the memo: the 30 days computed once per MOVERS_TTL_MS, who and which projects asked
+//      on every read.
+//   5. the route: no-store, the same body with or without credentials, the 500 envelope,
+//      and its own rate-limit scope.
+//
+// Run:  node tests/community_movers.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import http from 'node:http';
+
+const require = createRequire(import.meta.url);
+const express = require('express');
+
+let passed = 0;
+let failed = 0;
+async function t(name, fn) {
+  try { await fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (e) { failed++; console.error(`  FAIL ${name}\n       ${e.message}`); }
+}
+
+const { rollupVisibleSql } = require('../modules/platform-identity/account-visibility.js');
+const { onMapSql } = require('../modules/platform-identity/projects-feed.js');
+const flat = (s) => s.replace(/\s+/g, ' ').trim();
+const NUMBERS = flat(rollupVisibleSql('pa'));
+const ON_MAP = flat(onMapSql('p'));
+
+// ---- fake engine ------------------------------------------------------------
+
+const isRows = (sql) => /^WITH act AS/.test(sql) && /LEFT JOIN per_project pp/.test(sql);
+const isWho = (sql) => /FROM platform_identity_accounts pa WHERE pa\.github_id = ANY\(\$1::bigint\[\]\)/.test(sql);
+const isNamed = (sql) => /FROM platform_identity_sso_clients c JOIN platform_identity_projects p/.test(sql);
+
+const engine = {
+  calls: [],
+  rows: [],          // the 30 days' statement's rows
+  shown: new Set(),  // github_ids the numbers predicate admits
+  named: {},         // client_id → { name, origin } on the map with the Public door
+  throwOn: null,
+  query: async (text, params = []) => {
+    const sql = flat(String(text));
+    engine.calls.push({ sql, params });
+    if (engine.throwOn && engine.throwOn(sql)) { engine.throwOn = null; throw new Error('boom'); }
+    if (isRows(sql)) return { rows: engine.rows };
+    if (isWho(sql)) {
+      const rows = params[0].filter((id) => engine.shown.has(id))
+        .map((id) => ({ github_id: id, handle: `h${id}`, github_login: `l${id}`, display_name: `D${id}`, avatar_url: null }));
+      return { rows };
+    }
+    if (isNamed(sql)) {
+      const rows = params[0].filter((c) => engine.named[c]).map((c) => ({ client_id: c, ...engine.named[c] }));
+      return { rows };
+    }
+    throw new Error(`fake pool: unexpected statement ${sql.slice(0, 80)}`);
+  },
+};
+function reset() {
+  Object.assign(engine, { calls: [], rows: [], shown: new Set(), named: {}, throwOn: null });
+  movers.clearMoversMemo();
+}
+const callsOf = (pred) => engine.calls.filter((c) => pred(c.sql));
+// One (project, builder) row as the statement returns it: deltas null for a quiet row.
+const r = (client, id, credits, ships, base, karma = 0) => ({
+  client_id: client, github_id: id, credits: credits == null ? null : String(credits),
+  tasks_shipped: ships == null ? null : String(ships), karma: credits == null ? null : String(karma), base_credits: String(base),
+});
+
+// Pin the module doorway (ADR 0083) BEFORE the modules load.
+const moduleApiPath = require.resolve('../src/module-api.js');
+require.cache[moduleApiPath] = {
+  id: moduleApiPath, filename: moduleApiPath, loaded: true,
+  exports: {
+    pool: engine,
+    corsPublicGet: () => (_req, res, next) => { res.set('Access-Control-Allow-Origin', '*'); next(); },
+    logger: () => ({ error: () => {}, info: () => {}, warn: () => {} }),
+  },
+};
+
+const movers = require('../modules/platform-identity/community-movers.js');
+const { attachFail } = require('../src/bongos/middleware/error-envelope.js');
+const buildRoutes = require('../modules/platform-identity/routes/community-leaderboard.js');
+
+const NOW = '2026-10-28T09:30:00.000Z';
+const read = (now = NOW) => movers.readMovers({ now: new Date(now), pool: engine });
+
+// ---- 1. the statement ---------------------------------------------------------
+
+await t('the 30 days: the crowns’ period rows by the year’s rule, the numbers predicate, a quiet row’s live total as its baseline', async () => {
+  reset();
+  const out = await read();
+  const [s] = callsOf(isRows);
+  assert.ok(s.sql.includes(NUMBERS), 'the leaderboard’s numbers predicate');
+  assert.match(s.sql, /COALESCE\(e\.credits, 0\)::bigint - COALESCE\(b\.credits, CASE WHEN act\.first_seen_at >= \$1::timestamptz THEN 0 ELSE f\.credits END, 0\) AS credits/, 'the year’s baseline: never a lifetime');
+  assert.match(s.sql, /WHERE b\.credits IS NOT NULL OR act\.first_seen_at >= \$1::timestamptz OR f\.credits IS NOT NULL \)/);
+  assert.match(s.sql, /COALESCE\(pp\.base_credits, a\.credits::bigint\) AS base_credits/, 'a row with no history in the 30 days brings its live total');
+  assert.match(s.sql, /LEFT JOIN per_project pp ON pp\.client_id = act\.client_id AND pp\.github_id = act\.github_id$/);
+  assert.deepEqual(s.params.map((d) => d.toISOString()), ['2026-09-28T09:30:00.000Z', NOW], 'rolling: the 30 days up to now');
+  assert.deepEqual(out, { window: { start: '2026-09-28T09:30:00.000Z', end: NOW }, rising: null, projects: [] });
+});
+
+// ---- 2. the rising builder ----------------------------------------------------
+
+await t('the rising builder: most credits among those under the base cap with a shipped work', async () => {
+  reset();
+  engine.rows = [
+    r('p1', '1', 900, 4, 500),            // a veteran: over the cap
+    r('p1', '2', 300, 2, movers.RISING_BASE_MAX - 1),
+    r('p1', '3', 400, 0, 0),              // no work shipped
+    r('p1', '4', 250, 1, 0),
+  ];
+  engine.shown = new Set(['1', '2', '3', '4']);
+  const { rising } = await read();
+  assert.deepEqual(rising, { handle: 'h2', github_login: 'l2', display_name: 'D2', avatar_url: null, credits: 300, tasks_shipped: 2 });
+  assert.doesNotMatch(JSON.stringify(rising), /github_id|karma/, 'the crown’s fields and no more');
+});
+
+await t('the base is summed across every project, a quiet one included, and exactly the cap is over it', async () => {
+  reset();
+  engine.rows = [
+    r('p1', '2', 300, 2, 40),
+    r('p2', '2', null, null, 60),         // quiet: its live total is its baseline
+    r('p1', '4', 250, 1, 0),
+  ];
+  engine.shown = new Set(['2', '4']);
+  assert.equal((await read()).rising.handle, 'h4', '40 + 60 is not under 100');
+});
+
+await t('ties go to works shipped, then karma, then handle', async () => {
+  reset();
+  engine.rows = [r('p1', '5', 200, 1, 0, 9), r('p1', '6', 200, 2, 0, 0), r('p1', '7', 200, 2, 0, 1)];
+  engine.shown = new Set(['5', '6', '7']);
+  assert.equal((await read()).rising.handle, 'h7');
+  reset();
+  engine.rows = [r('p1', '8', 200, 2, 0, 1), r('p1', '7', 200, 2, 0, 1)];
+  engine.shown = new Set(['7', '8']);
+  assert.equal((await read()).rising.handle, 'h7', 'handle, by code unit');
+});
+
+await t('a builder who may not be shown is not the rising builder, and nobody takes it in their place unless they qualify', async () => {
+  reset();
+  engine.rows = [r('p1', '2', 300, 2, 0), r('p1', '4', 250, 1, 0)];
+  engine.shown = new Set(['4']);
+  assert.equal((await read()).rising.handle, 'h4');
+  const [who] = callsOf(isWho);
+  assert.ok(who.sql.includes(NUMBERS), 'who is shown: the numbers predicate');
+  assert.deepEqual(who.params[0].sort(), ['2', '4']);
+  reset();
+  engine.rows = [r('p1', '2', 300, 2, 0)];
+  assert.equal((await read()).rising, null);
+});
+
+// ---- 3. the projects on the move ------------------------------------------------
+
+await t('the projects: named only on the map with the Public door, by works then credits, at most PROJECTS_MAX', async () => {
+  reset();
+  engine.shown = new Set(['1', '2', '3']);
+  engine.rows = [
+    r('a', '1', 100, 3, 0), r('a', '2', 50, 1, 0),   // 4 works, 150
+    r('b', '1', 900, 4, 0),                          // 4 works, 900
+    r('c', '3', 10, 1, 0),
+    r('d', '3', 10, 1, 0),
+    r('e', '3', 20, 1, 0),
+    r('f', '3', 5, 1, 0),
+    r('g', '3', 0, 0, 0),                            // nothing shipped
+    r('hidden', '3', 999, 9, 0),                     // private or stealth: not named
+  ];
+  for (const c of ['a', 'b', 'c', 'd', 'e', 'f', 'g']) engine.named[c] = { name: c.toUpperCase(), origin: `https://${c}.example` };
+  const { projects } = await read();
+  assert.deepEqual(projects.map((p) => p.name), ['B', 'A', 'E', 'C', 'D'], 'works, then credits, then name');
+  assert.equal(projects.length, movers.PROJECTS_MAX);
+  assert.deepEqual(projects[1], { name: 'A', origin: 'https://a.example', tasks_shipped: 4, credits: 150 });
+  const [named] = callsOf(isNamed);
+  assert.ok(named.sql.includes(`${ON_MAP} AND p.visibility = 'public'`), 'a profile’s naming rule (task 1003558)');
+  assert.doesNotMatch(JSON.stringify(projects), /client_id|github_id|"hidden"/);
+});
+
+await t('a project counts only the builders who may be shown', async () => {
+  reset();
+  engine.shown = new Set(['1']);
+  engine.rows = [r('a', '1', 100, 1, 0), r('a', '2', 500, 5, 0), r('b', '2', 900, 9, 0)];
+  engine.named = { a: { name: 'A', origin: 'https://a.example' }, b: { name: 'B', origin: 'https://b.example' } };
+  const { projects } = await read();
+  assert.deepEqual(projects, [{ name: 'A', origin: 'https://a.example', tasks_shipped: 1, credits: 100 }]);
+  assert.deepEqual(callsOf(isNamed)[0].params[0], ['a'], 'a project only a hidden builder moved is not even asked about');
+});
+
+// ---- 4. the memo ------------------------------------------------------------------
+
+await t('the 30 days are computed once per MOVERS_TTL_MS; who and which projects are asked every read', async () => {
+  reset();
+  engine.rows = [r('a', '2', 300, 2, 0)];
+  engine.shown = new Set(['2']);
+  engine.named = { a: { name: 'A', origin: 'https://a.example' } };
+  const t0 = Date.parse(NOW);
+  assert.equal((await read(t0)).rising.handle, 'h2');
+  engine.shown = new Set();            // the builder hides
+  delete engine.named.a;               // and the project closes its door
+  const hid = await read(t0 + movers.MOVERS_TTL_MS - 1);
+  assert.equal(hid.rising, null, 'a hide beats the memo');
+  assert.deepEqual(hid.projects, [], 'so does a closed door');
+  assert.equal(hid.window.end, NOW, 'inside the memo: the window it was computed for');
+  assert.equal(callsOf(isRows).length, 1);
+  assert.equal(callsOf(isWho).length, 2);
+  await read(t0 + movers.MOVERS_TTL_MS);
+  assert.equal(callsOf(isRows).length, 2, 'stale: computed again');
+  await read(t0 - 1000);
+  assert.equal(callsOf(isRows).length, 3, 'a clock that runs backwards is never served from the memo');
+});
+
+// ---- 5. the route -----------------------------------------------------------------
+
+function serve() {
+  const app = express();
+  app.use(attachFail);
+  app.use('/api/bongos', buildRoutes());
+  const server = app.listen(0, '127.0.0.1');
+  return new Promise((resolve) => server.once('listening', () => resolve(server)));
+}
+function get(server, path_, headers = {}) {
+  return new Promise((resolve, reject) => {
+    http.get({ host: '127.0.0.1', port: server.address().port, path: path_, headers }, (res) => {
+      let body = '';
+      res.on('data', (c) => (body += c));
+      res.on('end', () => resolve({ status: res.statusCode, headers: res.headers, body, json: body ? JSON.parse(body) : null }));
+    }).on('error', reject);
+  });
+}
+
+const server = await serve();
+const URL_ = '/api/bongos/community/movers';
+
+await t('GET /community/movers: the window, the rising builder and the projects; no-store; CORS-open; the same for every viewer', async () => {
+  reset();
+  engine.rows = [r('a', '2', 300, 2, 0)];
+  engine.shown = new Set(['2']);
+  engine.named = { a: { name: 'A', origin: 'https://a.example' } };
+  const anon = await get(server, URL_);
+  assert.equal(anon.status, 200);
+  assert.equal(anon.headers['cache-control'], 'no-store');
+  assert.equal(anon.headers['access-control-allow-origin'], '*');
+  assert.deepEqual(Object.keys(anon.json), ['window', 'rising', 'projects']);
+  assert.equal(anon.json.rising.handle, 'h2');
+  assert.equal(anon.json.projects[0].name, 'A');
+  assert.doesNotMatch(anon.body, /github_id|client_id/);
+  const signedIn = await get(server, URL_, { Cookie: 'bongos_session=x', Authorization: 'Bearer y' });
+  assert.equal(signedIn.body, anon.body, 'the route reads no session');
+});
+
+await t('a failure is the 500 envelope, never a stack', async () => {
+  reset();
+  engine.throwOn = isRows;
+  const res = await get(server, URL_);
+  assert.equal(res.status, 500);
+  assert.equal(res.json.error.code, 'community_movers_failed');
+  assert.doesNotMatch(res.body, /boom/);
+});
+
+await t('its own rate-limit budget, not the board’s, the week’s or the crowns’', () => {
+  const { _internals } = buildRoutes;
+  assert.equal(_internals.MOVERS_READ_RATE_SCOPE, 'community-movers-read');
+  assert.equal(new Set([_internals.MOVERS_READ_RATE_SCOPE, _internals.CROWNS_READ_RATE_SCOPE, _internals.READ_RATE_SCOPE, _internals.WEEK_READ_RATE_SCOPE]).size, 4);
+});
+
+server.close();
+console.log(`\n${passed} passed, ${failed} failed`);
+if (failed) process.exit(1);

package/tests/community_movers_db.mjs

@@ -0,0 +1,147 @@
+// tests/community_movers_db.mjs — task 1002983 (the rising builder and the projects on the
+// move; real DB).
+//
+// Proves against real SQL what a fake pool cannot (tests/community_movers.mjs): the 30 days
+// keep the year's baseline rule (a lifetime brought into them counts from its first snapshot
+// inside, a row first seen inside from zero), a quiet row's live total counts toward the
+// "under 100 before" test, a hidden builder counts nowhere, and a private project is never
+// named, however much it shipped.
+//
+// The read is global (every eligible builder on the hub), so the fixture's 30 days end in
+// March 2099: a shared database's real builders have no snapshot there, so they ship nothing
+// in them and the shipped-work floor keeps them out.
+//
+// Real-DB integration test: self-skips without a reachable Postgres; in the INTEGRATION set
+// (scripts/bongos/run-unit-tests.js) so the DB-free lane never runs it.
+//
+// Run:  DATABASE_URL=... node tests/community_movers_db.mjs
+
+import { createRequire } from 'node:module';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { strict as assert } from 'node:assert';
+const require = createRequire(import.meta.url);
+const { Pool } = require('pg');
+const { readMovers, clearMoversMemo } = require('../modules/platform-identity/community-movers.js');
+
+const here = dirname(fileURLToPath(import.meta.url));
+const MIG_DIR = join(here, '..', 'modules', 'platform-identity', 'migrations');
+const migrationSql = (f) => readFileSync(join(MIG_DIR, f), 'utf8');
+
+const pool = new Pool({ connectionString: process.env.DATABASE_URL || undefined });
+try {
+  await pool.query('SELECT 1');
+} catch (e) {
+  console.log(`community_movers_db.mjs SKIPPED — no reachable Postgres (${e.code || e.message}).`);
+  await pool.end().catch(() => {});
+  process.exit(0);
+}
+
+const R = 90298301, V = 90298302, Q = 90298303, L = 90298304, N = 90298305, S = 90298306, HIDDEN = 90298307;
+const IDS = [R, V, Q, L, N, S, HIDDEN];
+const P1 = 't1002983-p1', P2 = 't1002983-p2', P3 = 't1002983-p3', PRIV = 't1002983-priv';
+const CLIENTS = [P1, P2, P3, PRIV];
+const origin = (c) => `https://${c}.example`;
+const NOW = new Date('2099-03-12T10:00:00.000Z'); // the 30 days open 2099-02-10T10:00Z
+const OLD = new Date('2098-06-01T00:00:00Z');
+const d = (iso) => new Date(iso);
+const q = (sql, params) => pool.query(sql, params);
+
+async function cleanup() {
+  await q(`DELETE FROM platform_identity_activity_snapshots WHERE github_id = ANY($1::bigint[])`, [IDS]).catch(() => {});
+  await q(`DELETE FROM platform_identity_builder_project_activity WHERE github_id = ANY($1::bigint[])`, [IDS]).catch(() => {});
+  await q(`DELETE FROM platform_identity_accounts WHERE github_id = ANY($1::bigint[])`, [IDS]).catch(() => {});
+  await q(`DELETE FROM platform_identity_projects WHERE origin = ANY($1::text[])`, [CLIENTS.map(origin)]).catch(() => {});
+  await q(`DELETE FROM platform_identity_sso_clients WHERE client_id = ANY($1::text[])`, [CLIENTS]).catch(() => {});
+}
+async function account(id, handle, { hide = false } = {}) {
+  await q(
+    `INSERT INTO platform_identity_accounts
+       (github_id, github_login, display_name, handle, profile_state, account_visibility, hide_stats, terms_accepted_at)
+     VALUES ($1, $2, $2, $2, 'active', 'public', $3, now())`,
+    [id, handle, hide],
+  );
+}
+async function project(client, name, visibility) {
+  await q(`INSERT INTO platform_identity_sso_clients (client_id, secret_hash, name, origin) VALUES ($1, 'x', $2, $3)`, [client, name, origin(client)]);
+  await q(
+    `INSERT INTO platform_identity_projects (origin, name, description, featured, status, visibility, visibility_source)
+     VALUES ($1, $2, 'described', false, 'active', $3, 'control-plane')`,
+    [origin(client), name, visibility],
+  );
+}
+// One (project, builder) row: its live totals, when the hub first saw it, and its snapshots.
+async function row(client, id, live, firstSeen, history) {
+  await q(
+    `INSERT INTO platform_identity_builder_project_activity (client_id, github_id, credits, tasks_shipped, karma, first_seen_at) VALUES ($1, $2, $3, 0, 0, $4)`,
+    [client, id, live, firstSeen],
+  );
+  for (const [when, credits, ships] of history) {
+    await q(
+      `INSERT INTO platform_identity_activity_snapshots (client_id, github_id, credits, tasks_shipped, karma, reported_at) VALUES ($1, $2, $3, $4, 0, $5)`,
+      [client, id, credits, ships, d(when)],
+    );
+  }
+}
+const read = () => { clearMoversMemo(); return readMovers({ now: NOW, pool }); };
+const who = (w) => w && [w.handle, w.credits, w.tasks_shipped];
+const strip = (ps) => ps.map((p) => [p.name, p.tasks_shipped, p.credits]);
+
+let pass = 0;
+const same = (actual, expected, msg) => { assert.deepEqual(actual, expected, msg); pass++; console.log(`  ok - ${msg}`); };
+
+try {
+  for (const f of [
+    'platform_identity_001_tables.sql', 'platform_identity_004_projects.sql', 'platform_identity_005_builder_activity.sql',
+    'platform_identity_007_profile_consent.sql', 'platform_identity_008_handle.sql',
+    'platform_identity_011_project_visibility.sql', 'platform_identity_012_account_privacy.sql',
+    'platform_identity_019_terms_acceptance.sql', 'platform_identity_020_visibility_pull.sql',
+    'platform_identity_022_activity_snapshots.sql', 'platform_identity_032_weekly_features.sql',
+  ]) await q(migrationSql(f));
+  await cleanup();
+
+  for (const [id, h] of [[R, 'r'], [V, 'v'], [Q, 'q'], [L, 'l'], [N, 'n'], [S, 's']]) await account(id, `t1002983-${h}`);
+  await account(HIDDEN, 't1002983-hidden', { hide: true });
+  await project(P1, 'Alpha', 'public');
+  await project(P2, 'Beta', 'public');
+  await project(PRIV, 'Shut', 'private');
+
+  // R: 40 before the 30 days, then 300 and two works in them — the rising builder.
+  await row(P1, R, 340, OLD, [['2099-02-01T00:00:00Z', 40, 0], ['2099-03-01T00:00:00Z', 340, 2]]);
+  // V: a veteran — 5000 before, 900 and four works in them.
+  await row(P1, V, 5900, OLD, [['2099-02-01T00:00:00Z', 5000, 50], ['2099-03-01T00:00:00Z', 5900, 54]]);
+  // Q: 400 and three works on a project first seen inside (from zero), but 800 on a project
+  // with no history in the 30 days at all, so Q had 800 before them and is not rising.
+  await row(P2, Q, 400, d('2099-02-14T00:00:00Z'), [['2099-02-15T00:00:00Z', 400, 3]]);
+  await row(P3, Q, 800, OLD, []);
+  // L: a lifetime brought into the 30 days — no snapshot before them, seen before
+  // first_seen_at existed. Counted from its first snapshot inside: 150 and a work, never 90150.
+  await row(P1, L, 90150, null, [['2099-02-20T00:00:00Z', 90000, 40], ['2099-03-02T00:00:00Z', 90150, 41]]);
+  // N: first seen inside, so from zero: 250 and a work.
+  await row(P2, N, 250, d('2099-02-12T00:00:00Z'), [['2099-02-12T00:00:00Z', 250, 1]]);
+  // S: seven works on the private project.
+  await row(PRIV, S, 70, d('2099-02-11T00:00:00Z'), [['2099-02-11T00:00:00Z', 70, 7]]);
+  // HIDDEN out-earns and out-ships everyone on Alpha, and the leaderboard may not show them.
+  await row(P1, HIDDEN, 9000, OLD, [['2099-02-01T00:00:00Z', 0, 0], ['2099-03-01T00:00:00Z', 9000, 9]]);
+
+  const first = await read();
+  same([first.window.start, first.window.end], ['2099-02-10T10:00:00.000Z', '2099-03-12T10:00:00.000Z'], 'the 30 days up to now');
+  same(who(first.rising), ['t1002983-r', 300, 2], 'rising: R’s 300 — V, Q and L had 100 or more before (Q by a quiet project, L by its first snapshot), and hidden counts nowhere');
+  same(strip(first.projects), [['Alpha', 7, 1350], ['Beta', 4, 650]],'projects: works then credits; L counted from its first snapshot, hidden not counted, the private project never named');
+  same(first.projects[0].origin, origin(P1), 'a project links to its own address');
+  same(JSON.stringify(first).match(/github_id|client_id/), null, 'github_id and client_id never cross');
+
+  await q(`UPDATE platform_identity_accounts SET hide_stats = true WHERE github_id = $1`, [R]);
+  const hid = await readMovers({ now: NOW, pool }); // inside the memo
+  same(who(hid.rising), ['t1002983-n', 250, 1], 'R hides: the next one under the cap rises, without waiting for the memo');
+  same(strip(hid.projects), [['Alpha', 5, 1050], ['Beta', 4, 650]], 'and R’s numbers leave Alpha too');
+
+  await q(`UPDATE platform_identity_projects SET visibility = 'stealth' WHERE origin = $1`, [origin(P1)]);
+  same(strip((await readMovers({ now: NOW, pool })).projects), [['Beta', 4, 650]],'a project that goes stealth leaves the strip on the next read');
+
+  console.log(`\ncommunity_movers_db.mjs: ${pass} passed`);
+} finally {
+  await cleanup();
+  await pool.end();
+}

package/tests/copy_desk_page_docx.mjs

@@ -75,12 +75,12 @@ const errDetail = (b) => (b && b.error && b.error.details) || {};
 
 const L = (key, section, text, placement, row) => ({ key, section, text, placement, ...(row || {}) });
 const STUDIO_LINES = [
-  L('L0001', 'top bar', 'Studio', 'shared', { file: 'modules/hall-ui/public/shell.js', line: 40, string_id: 'sh0001' }),
-  L('L0002', 'top bar', 'Ctrl K', 'shared'),
+  L('L0001', 'shell bar', 'Studio', 'shared', { file: 'modules/hall-ui/public/shell.js', line: 40, string_id: 'sh0001' }),
+  L('L0002', 'shell bar', 'Ctrl K', 'shared'),
   L('L0003', 'greeting', 'Welcome back', 'placed', { file: 'modules/hall-ui/public/studio.html', line: 12, string_id: 'st0003' }),
   L('L0004', 'greeting', '{…} pages tweaked', 'placed', { file: 'modules/hall-ui/public/studio.js', line: 88, string_id: 'st0004' }),
   L('L0005', 'greeting', 'Your desk is quiet today', 'unplaced'),
-  L('L0006', 'footer', 'Resume where you left off', 'placed', { file: 'modules/hall-ui/public/studio.html', line: 90, string_id: 'st0006' }),
+  L('L0006', 'shell foot', 'Resume where you left off', 'placed', { file: 'modules/hall-ui/public/studio.html', line: 90, string_id: 'st0006' }),
 ];
 const INDEX_LINES = [
   L('L0001', 'hero', 'Build here', 'placed', { file: 'modules/public-landing/public/index.html', line: 3, string_id: 'ix0001' }),

package/tests/copy_desk_page_editor.mjs

@@ -64,11 +64,11 @@ const errCode = (b) => (b && b.error && b.error.code) || null;
 
 const L = (key, section, text, placement, row) => ({ key, section, text, placement, ...(row || {}) });
 const STUDIO_LINES = [
-  L('L0001', 'top bar', 'Studio', 'shared', { file: 'modules/hall-ui/public/shell.js', line: 40, string_id: 'sh0001' }),
-  L('L0002', 'top bar', 'Ctrl K', 'shared'),
+  L('L0001', 'shell bar', 'Studio', 'shared', { file: 'modules/hall-ui/public/shell.js', line: 40, string_id: 'sh0001' }),
+  L('L0002', 'shell bar', 'Ctrl K', 'shared'),
   L('L0003', 'greeting', 'Welcome back', 'placed', { file: 'modules/hall-ui/public/studio.html', line: 12, string_id: 'st0003' }),
   L('L0004', 'greeting', 'Your desk is quiet today', 'unplaced'),
-  L('L0005', 'footer', 'Resume where you left off', 'placed', { file: 'modules/hall-ui/public/studio.html', line: 90, string_id: 'st0005' }),
+  L('L0005', 'shell foot', 'Resume where you left off', 'placed', { file: 'modules/hall-ui/public/studio.html', line: 90, string_id: 'st0005' }),
 ];
 const readingsWith = (studioHash, lines = STUDIO_LINES) => ({
   schema: 1,
@@ -96,13 +96,13 @@ try {
     assert.equal(r.body.page.surface_word, 'builders hall');
     assert.equal(r.body.reading.reading_hash, 'studio-h1');
     assert.deepEqual(r.body.reading.lines.map((l) => [l.key, l.section, l.text, l.note]), [
-      ['L0001', 'top bar', 'Studio', 'shared'],
+      ['L0001', 'shell bar', 'Studio', 'shared'],
       // Shared shell text with no registry row cannot be applied mechanically,
       // so it goes to an engineer at submit, and the note says so.
-      ['L0002', 'top bar', 'Ctrl K', 'engineer'],
+      ['L0002', 'shell bar', 'Ctrl K', 'engineer'],
       ['L0003', 'greeting', 'Welcome back', null],
       ['L0004', 'greeting', 'Your desk is quiet today', 'engineer'],
-      ['L0005', 'footer', 'Resume where you left off', null],
+      ['L0005', 'shell foot', 'Resume where you left off', null],
     ]);
     assert.deepEqual(r.body.notes, { shared: 'changes this on every page', engineer: 'goes to an engineer', guarded: 'must still say' });
     assert.equal(r.body.round, null);

package/tests/copy_desk_page_next.mjs

@@ -101,7 +101,8 @@ try {
 
     const { status, body } = await getNext(ALICE);
     assert.equal(status, 200, JSON.stringify(body));
-    assert.deepEqual(order(body), ['landing:projects', 'status:explore', 'builders:studio', 'landing:index']);
+    assert.deepEqual(order(body), ['landing:projects', 'status:explore', 'builders:studio', 'landing:index', 'landing:skip-link']);
+    // landing:skip-link is the surface's shared chrome, a page of its own, untweaked
     assert.equal(body.recommended.why, '2 people asked for it');
     assert.equal(body.recommended.why_line, 'landing · 2 people asked for it · untweaked');
     assert.equal(body.alternatives[1].why, '1 line changed since your last pass', 'the round artist is the web claim, alice');
@@ -145,7 +146,7 @@ try {
     assert.equal(take.body.page_id, 'status:explore');
     const after = (await getNext(CAROL)).body;
     assert.deepEqual(after.skipped.map((s) => s.page_id).sort(), ['landing:projects', 'status:explore']);
-    assert.deepEqual(order(after), ['builders:studio', 'landing:index']);
+    assert.deepEqual(order(after), ['builders:studio', 'landing:index', 'landing:skip-link', 'builders:top-bar']);
   });
 
   await test('a submitted round is in flight: skipped, and the claim agrees', async () => {

package/tests/copy_desk_page_reads.mjs

@@ -115,7 +115,8 @@ try {
     assert.equal(p('builders:studio').status_label, 'Text tweaked 1x');
     assert.equal(p('builders:studio').drift.changed_count, 1);
     assert.equal(p('builders:studio').open_round.state, 'writing');
-    assert.deepEqual(body.surfaces.map((s) => s.line), ['1 of 2 tweaked', '1 of 1 tweaked', '0 of 1 tweaked']);
+    // Each surface's shared chrome is a page of its own now: landing gains a skip link page, builders a top bar page.
+    assert.deepEqual(body.surfaces.map((s) => s.line), ['1 of 3 tweaked', '1 of 2 tweaked', '0 of 1 tweaked']);
     assert.deepEqual(body.readings, { ok: true, at: 'docs/page-readings.json' });
     assert.deepEqual(body.inventory, { at: 'docs/page-inventory.json' });
   });