@bongos/core 1.23.17 → 1.23.19

package/tests/community_crowns_db.mjs

@@ -0,0 +1,164 @@
+// tests/community_crowns_db.mjs — task 1004902 (the builders of the month and the year;
+// real DB).
+//
+// Proves against real SQL what a fake pool cannot (tests/community_crowns.mjs): the month
+// keeps the week's rule (a lifetime brought into the month never counts), the year counts
+// that same row from its first snapshot inside the year and never its lifetime, a row first
+// seen in the year counts from zero, the month is pinned against a later report, a hide
+// and a race, and the year that ended is crowned on the next year's first read.
+//
+// The crowns are global (every eligible builder on the hub), so every fixture period is in
+// 2099: a shared database's real builders have no snapshot there, their delta is zero, 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_crowns_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 { clearCrownMemo } = require('../modules/platform-identity/builder-of-the-week.js');
+const { readCrowns, clearCrownsMemo } = require('../modules/platform-identity/community-crowns.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_crowns_db.mjs SKIPPED — no reachable Postgres (${e.code || e.message}).`);
+  await pool.end().catch(() => {});
+  process.exit(0);
+}
+
+const M = 90490201, L = 90490202, N = 90490203, Y = 90490204, HIDDEN = 90490205;
+const IDS = [M, L, N, Y, HIDDEN];
+const P1 = 't1004902-p1';
+const NOW = new Date('2099-03-12T10:00:00.000Z');
+const NEXT_YEAR = new Date('2100-01-02T10:00:00.000Z');
+const d = (iso) => new Date(iso);
+const q = (sql, params) => pool.query(sql, params);
+
+async function cleanup() {
+  await q(`DELETE FROM platform_identity_period_features WHERE period_start >= '2099-01-01'`).catch(() => {});
+  await q(`DELETE FROM platform_identity_weekly_features WHERE week_start >= '2099-01-01'`).catch(() => {});
+  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(() => {});
+}
+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 builder(id, history, firstSeen) {
+  await q(`INSERT INTO platform_identity_builder_project_activity (client_id, github_id, credits, tasks_shipped, karma, first_seen_at) VALUES ($1, $2, 0, 0, 0, $3)`, [P1, id, 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)`,
+      [P1, id, credits, ships, d(when)],
+    );
+  }
+}
+const recorded = async (period, start) => (await q(
+  `SELECT github_id::text AS github_id, credits_delta::int AS credits, ships_delta::int AS ships
+     FROM platform_identity_period_features WHERE period = $1 AND period_start = $2::date`,
+  [period, start],
+)).rows;
+const read = (now = NOW, p = pool) => { clearCrownMemo(); clearCrownsMemo(); return readCrowns({ now, pool: p }); };
+const who = (w) => w && [w.handle, w.credits, w.tasks_shipped];
+
+let pass = 0;
+const ok = (cond, msg) => { assert.ok(cond, msg); pass++; console.log(`  ok - ${msg}`); };
+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_005_builder_activity.sql',
+    'platform_identity_007_profile_consent.sql', 'platform_identity_008_handle.sql',
+    'platform_identity_012_account_privacy.sql', 'platform_identity_019_terms_acceptance.sql',
+    'platform_identity_022_activity_snapshots.sql', 'platform_identity_032_weekly_features.sql',
+    'platform_identity_033_period_features.sql',
+  ]) await q(migrationSql(f));
+  await cleanup();
+
+  await account(M, 't1004902-m');
+  await account(L, 't1004902-l');
+  await account(N, 't1004902-n');
+  await account(Y, 't1004902-y');
+  await account(HIDDEN, 't1004902-hidden', { hide: true });
+
+  // Y: history before the year — 400 credits and 3 works in it, all in March.
+  await builder(Y, [['2098-12-20T00:00:00Z', 0, 0], ['2099-03-05T00:00:00Z', 400, 3]], d('2098-06-01T00:00:00Z'));
+  // M: history before February — 250 credits and 2 works in February. In the year it has
+  // no snapshot before 1 January, so it counts from its first one inside (0).
+  await builder(M, [['2099-01-20T00:00:00Z', 0, 0], ['2099-02-10T00:00:00Z', 250, 2]], d('2098-06-01T00:00:00Z'));
+  // L: a lifetime brought into February — no history before it, seen before first_seen_at
+  // existed (NULL). Its first snapshot is 90000; it then earns 500 and two works. The month
+  // never counts it; the year counts 500, never 90500.
+  await builder(L, [['2099-02-03T00:00:00Z', 90000, 40], ['2099-02-12T00:00:00Z', 90500, 42]], null);
+  // N: first seen in the year, so counted from zero: 300 and a work.
+  await builder(N, [['2099-02-02T00:00:00Z', 300, 1]], d('2099-02-01T00:00:00Z'));
+  // HIDDEN out-earns everyone in both, and the leaderboard may not show them.
+  await builder(HIDDEN, [['2098-12-20T00:00:00Z', 0, 0], ['2099-02-05T00:00:00Z', 9000, 9]], d('2098-06-01T00:00:00Z'));
+
+  // 1 — the month: the week's rule
+  const first = await read();
+  same([first.month.start, first.month.end, first.month.first_crown], ['2099-02-01', '2099-03-01', null], 'the month is the last full calendar month');
+  same(who(first.month.winner), ['t1004902-n', 300, 1], 'the month: a row first seen in it counts from zero; a lifetime brought into it never counts; hidden never wins');
+  ok(!('github_id' in first.month.winner), 'github_id never crosses');
+  same(await recorded('month', '2099-02-01'), [{ github_id: String(N), credits: 300, ships: 1 }], 'the month is recorded on the first read');
+
+  // 2 — the year so far: the first snapshot inside the year is the baseline
+  same([first.year.start, first.year.since], ['2099-01-01', '2099-01-01'], 'history began before the year');
+  same(who(first.year.winner), ['t1004902-l', 500, 2], 'the year counts L from its first snapshot inside it — 500, not its 90500 lifetime — and that beats Y’s 400 and N’s 300');
+  same(await recorded('year', '2099-01-01'), [], 'a year so far is never written');
+
+  // 3 — pinned: a later report into the past month, or a builder who goes public, changes nothing
+  await q(`INSERT INTO platform_identity_activity_snapshots (client_id, github_id, credits, tasks_shipped, karma, reported_at) VALUES ($1, $2, 99999, 50, 0, $3)`, [P1, M, d('2099-02-20T00:00:00Z')]);
+  await q(`UPDATE platform_identity_accounts SET hide_stats = false WHERE github_id = $1`, [HIDDEN]);
+  same(who((await read()).month.winner), ['t1004902-n', 300, 1], 'the first decision stands');
+  await q(`UPDATE platform_identity_accounts SET hide_stats = true WHERE github_id = $1`, [HIDDEN]);
+
+  // 4 — a winner who hides is not shown, and their month goes to nobody else
+  await q(`UPDATE platform_identity_accounts SET hide_stats = true WHERE github_id = $1`, [N]);
+  same((await read()).month.winner, null, 'a hidden winner is not drawn');
+  same(await recorded('month', '2099-02-01'), [{ github_id: String(N), credits: 300, ships: 1 }], 'and the row is never re-crowned');
+  await q(`UPDATE platform_identity_accounts SET hide_stats = false WHERE github_id = $1`, [N]);
+
+  // 5 — the year that ended, crowned on the next year's first read by the year's rule
+  // (M's late February report now leads it), and shown as last
+  const later = await read(NEXT_YEAR);
+  same(await recorded('year', '2099-01-01'), [{ github_id: String(M), credits: 99999, ships: 50 }], 'the year is recorded on the next year’s first read');
+  same(later.year.last && [later.year.last.start, ...who(later.year.last.winner)], ['2099-01-01', 't1004902-m', 99999, 50], 'and shown as last year');
+  same(later.year.winner, null, 'nobody has earned in the new year yet');
+
+  // 6 — two hub processes crowning the same month at once: one row, no error
+  const other = new Pool({ connectionString: process.env.DATABASE_URL || undefined });
+  try {
+    clearCrownMemo();
+    clearCrownsMemo();
+    const at = d('2099-05-03T00:00:00Z');
+    const both = await Promise.all([readCrowns({ now: at, pool }), readCrowns({ now: at, pool: other })]);
+    same(both.map((b) => b.month.winner), [null, null], 'both answer');
+    same((await recorded('month', '2099-04-01')).length, 1, 'one row: ON CONFLICT DO NOTHING');
+  } finally { await other.end().catch(() => {}); }
+
+  console.log(`\ncommunity_crowns_db.mjs: ${pass} passed`);
+} finally {
+  clearCrownMemo();
+  clearCrownsMemo();
+  await cleanup();
+  await pool.end().catch(() => {});
+}

package/tests/copy_stuck_page_tweaks.mjs

@@ -34,8 +34,8 @@ const TASKS = [
   round(2, 'landing:account', { status: 'completed', grade_passed: true, updated_at: ago(5) }),
   // submitted yesterday: NOT stuck
   round(3, 'builders:studio', { status: 'ready', description: `${pages.roundTaskBody(pg('builders:studio'), 1)}\n\n${batch('builders:studio')}`, updated_at: ago(1) }),
-  // being written for a month: a draft is never stuck
-  round(4, 'landing:projects', { status: 'active', holder_id: '7', holder_worktree: false, updated_at: ago(30) }),
+  // being written for 3 days: not overdue (that is 7 days, task 1004901)
+  round(4, 'landing:projects', { status: 'active', holder_id: '7', holder_worktree: false, updated_at: ago(3) }),
 ];
 const stuck = () => status.stuckPageTweaks({ inventory: INVENTORY, tasks: TASKS, now: NOW });
 
@@ -46,6 +46,43 @@ await test('the composer: only stuck pages, each with where it sits, how long, a
   ]);
 });
 
+// task 1004901: every state names who moves it next and when it is overdue.
+await test('every state has an owner and a deadline: overdue only past it, told to that owner', () => {
+  const D = 86400000;
+  const p = (id) => pg(id);
+  const desc = (id, blocks) => [pages.roundTaskBody(p(id), 1), ...blocks].join('\n\n');
+  const draftBlock = (id) => pages.composeDraftBlock({ page_id: id, reading_hash: 'h', saved_at: ago(1), lines: [] });
+  const batchBlock = (id) => pages.composeBatchBlock({ page_id: id, reading_hash: 'h', submitted_at: ago(1), lines: [] });
+  const approved = pages.composeWordsApprovedBlock({ at: ago(1), by: ARTIST });
+  // [state, task shape, owner, days until overdue]
+  const table = [
+    ['draft', (id) => ({ status: 'ready', description: desc(id, [draftBlock(id)]) }), 'artist', 7],
+    ['writing', () => ({ status: 'active', holder_id: ARTIST, holder_worktree: false }), 'artist', 7],
+    ['words_review', (id) => ({ status: 'ready', description: desc(id, [batchBlock(id)]) }), 'artist', 3],
+    ['submitted', (id) => ({ status: 'ready', description: desc(id, [batchBlock(id), approved]) }), 'appliers', 3],
+    ['applying', () => ({ status: 'active', holder_id: '99', holder_worktree: true }), 'appliers', 1],
+    ['waiting_for_artist', () => ({ status: 'completed', grade_passed: true }), 'artist', 3],
+    ['landing', () => ({ status: 'confirmed' }), 'appliers', 1],
+    ['unknown', () => ({ status: 'ready' }), 'appliers', 0],
+  ];
+  for (const [state, shape, owner, days] of table) {
+    const id = 'landing:projects';
+    const at = (age) => status.composePages({ inventory: INVENTORY, readings: null, tasks: [round(50, id, { ...shape(id), updated_at: ago(age) })], now: NOW }).in_flight[0];
+    const before = at(Math.max(days - 0.5, 0));
+    assert.equal(before.state, state);
+    assert.equal(before.waits_on, owner, `${state} waits on ${owner}`);
+    assert.equal(Date.parse(before.due_at) - Date.parse(before.since), days * D, `${state} is overdue after ${days} day(s)`);
+    if (days > 0) assert.equal(before.stuck, false, `${state} is not overdue before its deadline`);
+    const after = at(days + 0.5);
+    assert.equal(after.stuck, true, `${state} is overdue after its deadline`);
+    const told = status.stuckPageTweaksFor({ builderId: ARTIST, rank: 'xenos', stuck: status.stuckPageTweaks({ inventory: INVENTORY, tasks: [round(50, id, { ...shape(id), updated_at: ago(days + 0.5) })], now: NOW }) });
+    assert.equal(told.length, owner === 'artist' ? 1 : 0, `${state}: its artist is told only when it waits on them`);
+  }
+  const draft = status.composePages({ inventory: INVENTORY, readings: null, tasks: [round(51, 'landing:projects', { status: 'ready', description: desc('landing:projects', [draftBlock('landing:projects')]), updated_at: ago(2) })], now: NOW }).in_flight[0];
+  assert.equal(Date.parse(draft.expires_at) - Date.parse(draft.since), status.DRAFT_EXPIRES_AFTER, 'a draft says when it expires');
+  assert.equal(status.DRAFT_EXPIRES_AFTER, 14 * D);
+});
+
 await test('submitted words left unreviewed wait on their artist, not the appliers (task 1004900)', () => {
   const words = round(9, 'landing:projects', { status: 'ready', description: `${pages.roundTaskBody(pg('landing:projects'), 1)}\n\n${pages.composeBatchBlock({ page_id: 'landing:projects', reading_hash: 'h', submitted_at: ago(4), lines: [] })}`, updated_at: ago(4) });
   const got = status.stuckPageTweaks({ inventory: INVENTORY, tasks: [words], now: NOW });

package/tests/hub_account_page.mjs

@@ -135,8 +135,8 @@ test('the bands say what the hub’s say and lead into /projects; Account is the
   assert.deepEqual(bandLinks(bandOf(PAGE, 'menuProjects')), [
     ['Sky', '/projects?view=map'], ['Table', '/projects?view=map&sub=table'],
     ['Your projects', '/projects?view=mine'], ['New project', '/projects?view=new'],
-    // the Community menu's four sub-pages, folded into the band under 480px (tasks 1003363, 1002981)
-    ['Leaderboard', '/community'], ['Builder of the week', '/community/week'], ['Find a builder', '/community/find'], ['Open to recruiters', '/community/recruiters'],
+    // the Community menu's five sub-pages, folded into the band under 480px (tasks 1003363, 1002981, 1004902)
+    ['Community home', '/community'], ['Leaderboard', '/community/leaderboard'], ['Builder of the week', '/community/week'], ['Find a builder', '/community/find'], ['Open to recruiters', '/community/recruiters'],
     ['Builders you may know', '/connections#connSuggest'],
   ], 'this page has no views of its own, so every item names /projects in full');
   assert.deepEqual(bandLinks(bandOf(PAGE, 'menuProfile')), [

package/tests/hub_community_page.mjs

@@ -1,11 +1,12 @@
 // tests/hub_community_page.mjs — the hub's community pages (task 1003363; ADR 0217 D1,
 // ADR 0337 D1/D3/D4.1, docs/specs/bongos-v1-community-tab.md D1/D3/D4/D8).
 //
-// One file served as four sub-pages of the bar's Community menu (owner, 2026-10-27):
-// /community the leaderboard, /community/week the builder of the week (task 1002981),
-// /community/find the builder search, /community/recruiters the name-only list of hidden
-// builders open to recruiters. They render existing platform-identity reads and add no
-// rule of their own. What this file pins:
+// One file served as five sub-pages of the bar's Community menu (owner, 2026-10-27):
+// /community the community home (task 1004902: the builders of the week, month and year,
+// and a door to each page), /community/leaderboard the leaderboard, /community/week the
+// builder of the week (task 1002981), /community/find the builder search,
+// /community/recruiters the name-only list of hidden builders open to recruiters. They
+// render existing platform-identity reads and add no rule of their own. What this file pins:
 //   • the markup: the hub's bar with the Community menu as the current section, no top
 //     block, noindex, dark only, the routes' own windows and query limits
 //   • viewing is ungated: the leaderboard and the search read the same routes for every
@@ -15,11 +16,12 @@
 //     dropdown and the crafts, the empty, failed and rate-limited board; the search and
 //     its refusals; the recruiter list as a door signed out, a refusal on a 403, and rows
 //     only from a 200 — name, face and login, never the ranked half's numbers; the builder
-//     of the week as one line on the board and as its own page, drawn as the server sent it
+//     of the week as one line on the board and as its own page, drawn as the server sent it;
+//     the home's three crowns, its empty and failed states, and its doors
 //   • the Community menu on every page that wears the hub's bar (apex-only where the page
 //     also serves a child), folded into the Projects band on phones
-//   • the routes: the four paths served on the hub's apex only
-//   • the kit: the states files, and the stub answering as the four reads do
+//   • the routes: the five paths served on the hub's apex only
+//   • the kit: the states files, and the stub answering as the five reads do
 //
 // DB-free. Run:  node --test tests/hub_community_page.mjs
 
@@ -46,8 +48,9 @@ const STYLE = PAGE.split('<style>')[1].split('</style>')[0].replace(/\/\*[\s\S]*
 const MAIN = PAGE.split('<main class="acct" id="comm">')[1].split('</main>')[0];
 const BOARD_JS = fs.readFileSync(path.join(PI, 'community-leaderboard.js'), 'utf8');
 const SEARCH_JS = fs.readFileSync(path.join(PI, 'builder-search.js'), 'utf8');
-const SUBPAGES = [['/community', 'Leaderboard'], ['/community/week', 'Builder of the week'], ['/community/find', 'Find a builder'], ['/community/recruiters', 'Open to recruiters']];
+const SUBPAGES = [['/community', 'Community home'], ['/community/leaderboard', 'Leaderboard'], ['/community/week', 'Builder of the week'], ['/community/find', 'Find a builder'], ['/community/recruiters', 'Open to recruiters']];
 const WEEK_JS = fs.readFileSync(path.join(PI, 'builder-of-the-week.js'), 'utf8');
+const CROWNS_JS = fs.readFileSync(path.join(PI, 'community-crowns.js'), 'utf8');
 
 // ── 1. the markup ────────────────────────────────────────────────────────────
 
@@ -73,9 +76,9 @@ test('the bar and bands are /connections’ but for the sign-in return and the c
   assert.equal(bar(PAGE), bar(read('connections.html')));
 });
 
-test('no top block: one visually hidden h1, then one section per sub-page, only the leaderboard shown in the markup', () => {
+test('no top block: one visually hidden h1, then one section per sub-page, only the home shown in the markup', () => {
   assert.match(MAIN, /^\s*<h1 class="vh">Community<\/h1>\s*(<!--[\s\S]*?-->\s*)?<div class="mineExtra">/, 'nothing is drawn above the first section (the /design floor)');
-  const order = ['<section id="board" data-view="leaderboard" aria-labelledby="boardH">', '<section id="week" data-view="week" aria-labelledby="weekH" hidden>', '<section id="find" data-view="find" aria-labelledby="findH" hidden>', '<section id="recruit" data-view="recruiters" aria-labelledby="recruitH" hidden>'].map((s) => MAIN.indexOf(s));
+  const order = ['<section id="home" data-view="home" aria-labelledby="homeH">', '<section id="board" data-view="leaderboard" aria-labelledby="boardH" hidden>', '<section id="week" data-view="week" aria-labelledby="weekH" hidden>', '<section id="find" data-view="find" aria-labelledby="findH" hidden>', '<section id="recruit" data-view="recruiters" aria-labelledby="recruitH" hidden>'].map((s) => MAIN.indexOf(s));
   assert.ok(order.every((i) => i > 0), 'every sub-page is real markup the script only shows');
   assert.deepEqual([...order].sort((a, b) => a - b), order);
   assert.match(MAIN, /<ol class="commRows" id="boardList" data-unit="\{\{currency\}\}" aria-labelledby="boardH"><\/ol>/, 'the unit is the instance’s own word, stamped by the server');
@@ -100,10 +103,30 @@ test('the builder of the week states its rule in full, and the rule is the modul
   assert.match(WEEK_JS, /ORDER BY sum\(credits\) DESC, sum\(tasks_shipped\) DESC, sum\(karma\) DESC,/, 'the tie order the page states is the query’s');
   assert.match(rule, /Builders who hide their numbers or keep their account private are not counted\./);
   assert.match(WEEK_JS, /rollupVisibleSql\('pa'\)/);
-  assert.match(rule, /Each week is decided once, the first time anyone opens this page after it ends, and it does not change after that\./);
+  assert.match(rule, /Each week is decided once, the first time a community page asks for it after it ends, and it does not change after that\./);
   assert.match(WEEK_JS, /ON CONFLICT \(week_start\) DO NOTHING/);
 });
 
+test('the home states the month’s and year’s rule, and it is the module’s; its doors are the other pages (task 1004902)', () => {
+  const home = MAIN.split('<section id="home"')[1].split('</section>')[0];
+  const rule = home.split('<p class="commNote" id="homeRule">')[1].split('</p>')[0];
+  assert.match(rule, /the most \{\{currency\}\} across every project in that time, among the builders who shipped at least one work in it\./, 'the week’s formula, which the month and the year reuse');
+  assert.match(CROWNS_JS, /require\('\.\/builder-of-the-week'\)/);
+  assert.match(CROWNS_JS, /computeWinner\(start, end, pool, opts\)/, 'the month and the crowned year are the week’s statement');
+  assert.match(rule, /A tie goes to whoever shipped more works, then to whoever earned more karma\./);
+  assert.match(rule, /Builders who hide their numbers or keep their account private are not counted\./);
+  assert.match(CROWNS_JS, /rollupVisibleSql\('pa'\)/);
+  assert.match(rule, /The week and the month are decided once, when they end; the year shows the leader so far, and is decided on 1 January\./);
+  assert.match(CROWNS_JS, /ON CONFLICT \(period, period_start\) DO NOTHING/);
+  assert.match(CROWNS_JS, /computeWinner\(start, now, pool, \{ fromFirstSnapshot: true \}\)/, 'the year so far is live');
+  for (const id of ['homeFailed', 'homeCrowns', 'crownYearLast']) assert.match(home, new RegExp(` id="${id}"[^>]*hidden`), `${id} waits for the route’s answer`);
+  const doors = [...home.split('<ul class="homeDoors" aria-labelledby="doorsH">')[1].split('</ul>')[0].matchAll(/<li( class="knowCell" hidden)?><a class="btn ghost" href="([^"]+)">([^<]+)<\/a><\/li>/g)];
+  assert.deepEqual(doors.map((m) => [m[2], m[3], !!m[1]]), [
+    ['/community/leaderboard', 'Leaderboard', false], ['/community/week', 'Builder of the week', false], ['/community/find', 'Find a builder', false],
+    ['/community/recruiters', 'Open to recruiters', false], ['/connections#connSuggest', 'Builders you may know', true],
+  ], 'one door per page, the menu’s order; Builders you may know signed in only, like its menu item');
+});
+
 test('the window dropdown and the query limits are the routes’ own (boundary-forced copies)', () => {
   const days = BOARD_JS.match(/const WINDOW_DAYS = Object\.freeze\(\{([^}]*)\}\);/);
   const windows = [...days[1].matchAll(/'?(\w+)'?:/g)].map((m) => m[1]);
@@ -121,12 +144,12 @@ test('the window dropdown and the query limits are the routes’ own (boundary-f
   assert.match(MAIN, new RegExp(`<input id="findQ" type="search"[^>]* maxlength="${max}"`));
 });
 
-test('the script builds no markup from strings, reads only the five routes, and never re-ranks or reads the ranked tier', () => {
+test('the script builds no markup from strings, reads only the six routes, and never re-ranks or reads the ranked tier', () => {
   assert.doesNotMatch(SCRIPT, /innerHTML|insertAdjacentHTML|outerHTML|document\.write/);
-  // every path literal in the code: the API base, the five reads, the four sub-pages, the
+  // every path literal in the code: the API base, the six reads, the five sub-pages, the
   // sign-in door and the hall's invite box the Recruit door opens (task 1002292)
   const paths = [...new Set([...CODE.matchAll(/'(\/[^'?]*)/g)].map((m) => m[1]))];
-  assert.deepEqual(paths.sort(), ['/api/bongos', '/api/bongos/auth/web/start', '/builders/watch', '/community', '/community/builder-of-the-week', '/community/find', '/community/leaderboard', '/community/recruiters', '/community/search', '/community/week', '/my-projects', '/scouting']);
+  assert.deepEqual(paths.sort(), ['/api/bongos', '/api/bongos/auth/web/start', '/builders/watch', '/community', '/community/builder-of-the-week', '/community/crowns', '/community/find', '/community/leaderboard', '/community/recruiters', '/community/search', '/community/week', '/my-projects', '/scouting']);
   assert.doesNotMatch(CODE, /method:/, 'it only reads');
   assert.doesNotMatch(CODE, /'\/me\b/, 'who is signed in is the bar’s question');
   assert.doesNotMatch(CODE, /\.sort\(|\.count\b|_count\b/, 'the server ranks; every count is a list’s length');
@@ -172,7 +195,14 @@ const WEEK = () => ({ week: { start: '2026-10-19', end: '2026-10-26' },
   past: [{ week_start: '2026-10-12', handle: 'bo', github_login: 'bo', display_name: null, avatar_url: 'data:x', credits: 300, tasks_shipped: 2 },
     { week_start: '2026-09-28', handle: 'cy', github_login: 'cy', display_name: 'Cy', avatar_url: null, credits: 90, tasks_shipped: 1 },
     { week_start: '2025-12-29', handle: 'di', github_login: 'di', display_name: 'Di', avatar_url: null, credits: 10, tasks_shipped: 1 }] });
+const WINNER = (handle, credits, ships, extra = {}) => ({ handle, github_login: handle, display_name: handle.toUpperCase(), avatar_url: `https://avatars.example/${handle}`, credits, tasks_shipped: ships, ...extra });
+const CROWNS = () => ({
+  week: { start: '2026-10-26', end: '2026-11-02', winner: WINNER('ana', 1240, 4, { display_name: 'Ana <i>L</i>' }) },
+  month: { start: '2026-10-01', end: '2026-11-01', first_crown: null, winner: WINNER('bo', 6120, 1, { display_name: null, avatar_url: 'javascript:alert(1)' }) },
+  year: { start: '2026-01-01', since: '2026-09-27', last: null, winner: WINNER('cy', 9870, 31) },
+});
 const READS = () => ({
+  '/community/crowns': { status: 200, body: CROWNS() },
   '/community/builder-of-the-week': { status: 200, body: WEEK() },
   '/community/leaderboard?window=all': { status: 200, body: { window: 'all', count: 99, results: [ROW(26, 'ana', 1200), ROW(27, 'bo', 1500, { tasks_shipped: 1, karma: 0, avatar_url: 'javascript:alert(1)', display_name: null })] } },
   '/community/leaderboard?window=30d': { status: 200, body: { window: '30d', results: [ROW(1, 'cy', 40)] } },
@@ -182,7 +212,7 @@ const READS = () => ({
   '/scouting': { status: 403, body: { error: { code: 'forbidden' } } },
 });
 
-async function boot({ pathname = '/community', me = null, reads = READS() } = {}) {
+async function boot({ pathname = '/community/leaderboard', me = null, reads = READS() } = {}) {
   const ids = new Map();
   for (const m of PAGE.matchAll(/<(\w+)([^>]* id="([^"]+)"[^>]*)>/g)) {
     const attrs = attrsOf(m[2]);
@@ -224,17 +254,84 @@ async function boot({ pathname = '/community', me = null, reads = READS() } = {}
   return { ids, requests, document, gets: () => requests.map((r) => r.url), tab, craft, pick, submit, current, $: (id) => ids.get(id) };
 }
 
-test('each path shows its one section, marks its menu items current and names itself; any other shape is the leaderboard', async () => {
-  for (const [pathname, title, section] of [['/community', 'Leaderboard', 'board'], ['/community/', 'Leaderboard', 'board'], ['/community/week', 'Builder of the week', 'week'], ['/community/find', 'Find a builder', 'find'], ['/community/recruiters/', 'Open to recruiters', 'recruit']]) {
+test('each path shows its one section, marks its menu items current and names itself; any other shape is the home', async () => {
+  for (const [pathname, item, section] of [['/community', 'Community home', 'home'], ['/community/', 'Community home', 'home'], ['/community/everyone', 'Community home', 'home'], ['/community/leaderboard/', 'Leaderboard', 'board'], ['/community/week', 'Builder of the week', 'week'], ['/community/find', 'Find a builder', 'find'], ['/community/recruiters/', 'Open to recruiters', 'recruit']]) {
     const ui = await boot({ pathname });
-    assert.deepEqual(['board', 'week', 'find', 'recruit'].filter((s) => !ui.$(s).hidden), [section], `${pathname}: one section`);
-    const href = SUBPAGES.find(([, t]) => t === title)[0];
+    assert.deepEqual(['home', 'board', 'week', 'find', 'recruit'].filter((s) => !ui.$(s).hidden), [section], `${pathname}: one section`);
+    const href = SUBPAGES.find(([, t]) => t === item)[0];
     assert.deepEqual(ui.current(), [href, href], `${pathname}: its Community item and its folded twin in the Projects band`);
-    assert.equal(ui.document.title, `Cloud Bongos — Community · ${title}`);
+    assert.equal(ui.document.title, section === 'home' ? 'Cloud Bongos — Community' : `Cloud Bongos — Community · ${item}`, 'the home is the Community page itself');
     assert.equal(ui.$('signinTop').attrs.href, `/api/bongos/auth/web/start?return=${href}&repos=1`, 'signing in comes back to this sub-page');
   }
 });
 
+// ── 2c. the community home (task 1004902) ───────────────────────────────────────
+// community-crowns.js decides and records each period; the home draws what it sent, the
+// same for every viewer.
+
+test('the home: one read, the three crowns with their periods, names as text, and nothing asked about projects', async () => {
+  const ui = await boot({ pathname: '/community' });
+  assert.deepEqual(ui.gets(), ['/api/bongos/community/crowns']);
+  assert.equal(ui.$('homeLoading').hidden, true);
+  assert.equal(ui.$('homeFailed').hidden, true);
+  assert.equal(ui.$('homeCrowns').hidden, false);
+  assert.equal(ui.$('crownWeekWhen').textContent, '26 Oct – 1 Nov 2026');
+  assert.equal(find(ui.$('crownWeek'), 'crownName').textContent, 'Ana <i>L</i>', 'a name is text, never markup');
+  assert.equal(find(ui.$('crownWeek'), 'crownNums').textContent, (1240).toLocaleString() + 'credits4works shipped');
+  assert.equal(ui.$('crownMonthWhen').textContent, 'October 2026');
+  assert.equal(find(ui.$('crownMonth'), 'crownName').textContent, 'bo', 'no display name: the handle stands in');
+  assert.equal(find(ui.$('crownMonth'), 'connAv').tag, 'span', 'an avatar that is not http(s) is never loaded');
+  assert.equal(find(ui.$('crownMonth'), 'crownNums').textContent, (6120).toLocaleString() + 'credits1work shipped', 'one work, singular');
+  assert.equal(ui.$('crownYearWhen').textContent, '2026 so far, since 27 Sep 2026', 'the year says when history began while that is inside it');
+  assert.equal(find(ui.$('crownYear'), 'mineRow__host').textContent, '@cy');
+  assert.equal(ui.$('crownYearLast').hidden, true, 'no year crowned yet');
+  const signedIn = await boot({ pathname: '/community', me: { github_login: 'owner' } });
+  assert.deepEqual(signedIn.gets(), ['/api/bongos/community/crowns'], 'signed in, the same one read: no Recruit door here');
+  assert.equal(signedIn.$('homeCrowns').textContent, ui.$('homeCrowns').textContent, 'the same crowns for every viewer');
+});
+
+test('the home: last year under the year so far, the first month’s date, and no one to show', async () => {
+  const reads = READS();
+  reads['/community/crowns'] = { status: 200, body: { ...CROWNS(),
+    year: { start: '2027-01-01', since: '2027-01-01', winner: WINNER('di', 310, 2), last: { start: '2026-01-01', winner: WINNER('cy', 11250, 38, { display_name: 'Cy <b>!</b>' }) } } } };
+  const next = await boot({ pathname: '/community', reads });
+  assert.equal(next.$('crownYearWhen').textContent, '2027 so far', 'history began before the year: no “since”');
+  assert.equal(next.$('crownYearLast').hidden, false);
+  assert.equal(next.$('crownYearLast').textContent, '2026: Cy <b>!</b>, ' + (11250).toLocaleString() + ' credits');
+  assert.equal(kids(next.$('crownYearLast'))[1].tag, 'strong');
+  reads['/community/crowns'] = { status: 200, body: {
+    week: { start: '2026-10-19', end: '2026-10-26', winner: null },
+    month: { start: '2026-09-01', end: '2026-10-01', first_crown: '2026-11-01', winner: null },
+    year: { start: '2026-01-01', since: '2026-09-27', winner: null, last: null } } };
+  const first = await boot({ pathname: '/community', reads });
+  const line = (id) => find(first.$(id), 'commMsg').textContent;
+  assert.equal(line('crownWeek'), 'No builder of the week for 19–25 Oct 2026.');
+  assert.equal(first.$('crownMonthWhen').textContent, 'September 2026');
+  assert.equal(line('crownMonth'), 'The first builder of the month is named on 1 Nov 2026.', 'a month before history is not “nobody”');
+  assert.equal(line('crownYear'), 'No builder of 2026 yet.');
+  assert.equal(find(first.$('homeCrowns'), 'crownName'), null);
+  reads['/community/crowns'] = { status: 200, body: { ...CROWNS(), month: { start: '2026-10-01', end: '2026-11-01', first_crown: null, winner: null } } };
+  assert.equal(find((await boot({ pathname: '/community', reads })).$('crownMonth'), 'commMsg').textContent, 'No builder of the month for October 2026.', 'a hidden winner and an empty month read the same (spec D8)');
+  reads['/community/crowns'] = { status: 200, body: { week: { start: 'soon' }, month: {}, year: { last: { start: 'x', winner: WINNER('ed', 1, 1) } } } };
+  const odd = await boot({ pathname: '/community', reads });
+  assert.deepEqual(['crownWeek', 'crownMonth', 'crownYear'].map((id) => find(odd.$(id), 'commMsg').textContent), ['No builder of the week yet.', 'No builder of the month yet.', 'No builder of the year yet.'], 'a date it cannot read is never drawn');
+  assert.equal(odd.$('crownYearLast').hidden, true);
+});
+
+test('the home: a failed read is an alert, never three empty crowns; a rate limit says to wait', async () => {
+  const reads = READS();
+  for (const answer of [{ status: 500, body: {} }, { reject: true }]) {
+    reads['/community/crowns'] = answer;
+    const failed = await boot({ pathname: '/community', reads });
+    assert.equal(failed.$('homeFailed').hidden, false);
+    assert.equal(failed.$('homeFailed').textContent, 'The top builders could not be read. Reload the page to try again.');
+    assert.equal(failed.$('homeCrowns').hidden, true);
+    assert.equal(failed.$('homeLoading').hidden, true);
+  }
+  reads['/community/crowns'] = { status: 429, body: {} };
+  assert.match((await boot({ pathname: '/community', reads })).$('homeFailed').textContent, /^Too many requests/);
+});
+
 test('the leaderboard, signed out: the all-time board in the server’s order with the server’s places, and nothing asked about the viewer', async () => {
   const ui = await boot();
   assert.deepEqual(ui.gets(), ['/api/bongos/community/leaderboard?window=all', '/api/bongos/community/builder-of-the-week']);
@@ -535,7 +632,8 @@ const SERVES_A_CHILD = ['privacy.html', 'terms.html', 'contact.html', 'index.htm
 const HUB_ONLY = ['account.html', 'connections.html', 'invitations.html', 'guild.html', 'community.html'];
 const wrap = (apex, s) => (apex ? `<!--apex-only:start-->${s}<!--apex-only:end-->` : s);
 const ITEMS = [
-  ['/community', 'Leaderboard', 'who earned the most, across every project'],
+  ['/community', 'Community home', 'the builders of the week, month and year'],
+  ['/community/leaderboard', 'Leaderboard', 'who earned the most, across every project'],
   ['/community/week', 'Builder of the week', 'the top earner of each week, and how it is chosen'],
   ['/community/find', 'Find a builder', 'anyone building here, by name or role'],
   ['/community/recruiters', 'Open to recruiters', 'who is open to recruiting, for project owners'],
@@ -557,9 +655,9 @@ test('every page that wears the hub’s bar carries the Community menu before Pr
     const at = html.indexOf(apex ? `<!--apex-only:start-->${trig}` : trig);
     assert.ok(at > 0, `${f}: the Community trigger`);
     assert.ok(html.indexOf('id="projTrig"') > at, `${f}: Community comes before Projects`);
-    assert.ok(html.includes(wrap(apex, band)), `${f}: the Community band, its four sub-pages`);
+    assert.ok(html.includes(wrap(apex, band)), `${f}: the Community band, its five sub-pages`);
     assert.ok(html.indexOf('id="menuCommunity"') < html.indexOf('id="menuProjects"'), `${f}: the bands in the bar’s order`);
-    assert.ok(html.includes(wrap(apex, fold)), `${f}: the four folded into the Projects band for phones`);
+    assert.ok(html.includes(wrap(apex, fold)), `${f}: the five folded into the Projects band for phones`);
     if (apex) assert.doesNotMatch(stripApexOnly(html, false).split('<body>')[1], /\/community|commTrig|menuCommunity|connSuggest/, `${f}: a child has no community pages, so no trace of the menu`);
   }
 });
@@ -617,7 +715,7 @@ function get(pathname, host) {
   });
 }
 
-test('GET /community, /community/week, /community/find and /community/recruiters: one stamped page on the hub’s apex; never on a child or another host', async () => {
+test('GET /community, /community/leaderboard, /community/week, /community/find and /community/recruiters: one stamped page on the hub’s apex; never on a child or another host', async () => {
   modules.setModuleOverrides({ 'platform-identity': false });
   for (const [p] of SUBPAGES) assert.equal((await get(p, 'game.test.local')).status, 404, `${p}: a child instance has none of the routes these pages read`);
   modules.setModuleOverrides({ 'platform-identity': true });
@@ -630,7 +728,7 @@ test('GET /community, /community/week, /community/find and /community/recruiters
     bodies.push(hub.body);
   }
   assert.ok(bodies.every((b) => b === bodies[0]), 'byte-identical for every sub-page: the script picks the view');
-  assert.doesNotMatch((await get('/community/everyone', 'game.test.local')).body, /— Community<\/title>/, 'only the four sub-pages');
+  assert.doesNotMatch((await get('/community/everyone', 'game.test.local')).body, /— Community<\/title>/, 'only the five sub-pages');
   for (const host of ['builders.test.local', 'status.test.local']) {
     assert.doesNotMatch((await get('/community', host)).body, /— Community<\/title>/, `${host} must not serve /community`);
   }
@@ -643,10 +741,17 @@ test('the kit renders each sub-page for everyone, the empty board, and a project
   const states = json('community.states.json');
   assert.equal(states.page, '/community');
   assert.deepEqual(states.modes, ['dark']);
-  for (const s of ['out', 'out-30d', 'out-artists', 'out-week', 'in-week', 'out-find', 'out-find-search', 'out-recruiters', 'in-recruiters', 'in']) assert.ok(states.states[s], `kit state ${s}`);
+  for (const s of ['out', 'in', 'out-board', 'out-30d', 'out-artists', 'out-week', 'in-week', 'out-find', 'out-find-search', 'out-recruiters', 'in-recruiters', 'in-board']) assert.ok(states.states[s], `kit state ${s}`);
+  assert.equal(states.states.out.url, undefined, 'the home is /community itself');
+  for (const s of ['out-board', 'out-30d', 'out-artists', 'in-board']) assert.equal(states.states[s].url, '/community/leaderboard', `${s}: the board’s own address`);
   assert.equal(states.states['out-find'].url, '/community/find');
   assert.equal(states.states['out-week'].url, '/community/week');
-  assert.ok(states.states.out.expect.visible.includes('#boardCrown'), 'the board carries the crown line');
+  assert.ok(states.states['out-board'].expect.visible.includes('#boardCrown'), 'the board carries the crown line');
+  // the home's other answers (task 1004902): before the first month, nobody, and a new year
+  for (const [file, fixture] of [['community-crowns-first.states.json', 'community-crowns-first'], ['community-crowns-none.states.json', 'community-crowns-none'], ['community-crowns-new-year.states.json', 'community-crowns-new-year']]) {
+    assert.equal(json(file).stub.fixtures['community-crowns'], fixture);
+    assert.ok(fs.existsSync(path.join(ROOT, 'modules', 'ui-design', 'kit', 'fixtures', fixture + '.json')), `fixture ${fixture}`);
+  }
   assert.equal(states.states['in-recruiters'].url, '/community/recruiters');
   assert.ok(states.states['in-recruiters'].expect.visible.includes('#recruitClosed'), 'signed in but not admitted: told, shown no one');
   for (const [file, name, fixture] of [['community-empty.states.json', 'community-leaderboard', 'community-leaderboard-empty'], ['community-recruiter.states.json', 'scouting', 'scouting-recruiter'], ['community-owner.states.json', 'my-projects', 'my-projects-owner'], ['community-owner-two.states.json', 'my-projects', 'my-projects-owner-two'], ['community-week-none.states.json', 'community-week', 'community-week-none']]) {
@@ -685,9 +790,14 @@ async function call(origin, p) {
   return { status: res.status, body: await res.json() };
 }
 
-test('the kit stub answers the board, the builder of the week, the search and the recruiting door the way the routes do', async () => {
+test('the kit stub answers the crowns, the board, the builder of the week, the search and the recruiting door the way the routes do', async () => {
   const s = await stub();
   try {
+    const crowns = await call(s.origin, '/community/crowns');
+    assert.deepEqual(Object.keys(crowns.body), ['week', 'month', 'year'], 'the route’s three periods');
+    const { week: w, month: m, year: y } = crowns.body;
+    assert.deepEqual([Object.keys(w).sort(), Object.keys(m).sort(), Object.keys(y).sort()], [['end', 'start', 'winner'], ['end', 'first_crown', 'start', 'winner'], ['last', 'since', 'start', 'winner']], 'community-crowns.js’s shape');
+    assert.ok([w.winner, m.winner, y.winner].every((r) => r && Object.keys(r).sort().join() === 'avatar_url,credits,display_name,github_login,handle,tasks_shipped'), 'the module’s projection, no github_id');
     const week = await call(s.origin, '/community/builder-of-the-week');
     assert.deepEqual(Object.keys(week.body).sort(), ['past', 'week', 'winner'], 'the route’s three keys');
     assert.ok(week.body.winner && week.body.past.length, 'a crown and the weeks before it');
@@ -717,6 +827,11 @@ test('the kit stub answers the board, the builder of the week, the search and th
     assert.equal(r.body.winner, null);
     assert.deepEqual(r.body.past, []);
   } finally { none.stop(); }
+  const nobody = await stub({ FIXTURE_ALIAS: JSON.stringify({ 'community-crowns': 'community-crowns-none' }) });
+  try {
+    const r = await call(nobody.origin, '/community/crowns');
+    assert.deepEqual([r.body.week.winner, r.body.month.winner, r.body.year.winner, r.body.year.last], [null, null, null, null]);
+  } finally { nobody.stop(); }
   const owner = await stub({ AUTH: '1', FIXTURE_ALIAS: JSON.stringify({ scouting: 'scouting-recruiter' }) });
   try {
     const r = await call(owner.origin, '/scouting');

package/tests/landing_legal_pages.mjs

@@ -193,8 +193,8 @@ for (const p of PAGES) {
     assert.deepEqual(bandLinks(bandOf(html, 'menuProjects')), [
       ['Sky', '/projects?view=map'], ['Table', '/projects?view=map&sub=table'],
       ['Your projects', '/projects?view=mine'], ['New project', '/projects?view=new'],
-      // the Community menu's four sub-pages, folded into the band under 480px (tasks 1003363, 1002981); apex-only
-      ['Leaderboard', '/community'], ['Builder of the week', '/community/week'], ['Find a builder', '/community/find'], ['Open to recruiters', '/community/recruiters'],
+      // the Community menu's five sub-pages, folded into the band under 480px (tasks 1003363, 1002981, 1004902); apex-only
+      ['Community home', '/community'], ['Leaderboard', '/community/leaderboard'], ['Builder of the week', '/community/week'], ['Find a builder', '/community/find'], ['Open to recruiters', '/community/recruiters'],
       ['Builders you may know', '/connections#connSuggest'],
     ], 'this page has no views of its own, so every item names /projects in full');
     assert.deepEqual(bandLinks(bandOf(stripApexOnly(html, false), 'menuProjects')).map((l) => l[0]), ['Sky', 'Table', 'Your projects', 'New project'], 'a child has no /community');