@bongos/core 1.23.14 → 1.23.16

package/tests/builder_of_the_week_db.mjs

@@ -0,0 +1,166 @@
+// tests/builder_of_the_week_db.mjs — task 1002981 (community spec D5; real DB).
+//
+// Proves Builder of the Week against real SQL: which snapshots open and close the
+// week, the shipped-work floor, the tie order, the leaderboard's eligibility, that
+// the first decision is pinned (a later change, a hide, a race) and that a week
+// nobody won is recorded empty. A fake pool can only prove the statements' shape
+// (tests/builder_of_the_week.mjs).
+//
+// The crown is global (every eligible builder on the hub), so every fixture week is
+// in 2099: a shared database's real builders have no snapshot there, their week's
+// 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/builder_of_the_week_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 { readBuilderOfTheWeek, crownedWeek, clearCrownMemo } = require('../modules/platform-identity/builder-of-the-week.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(`builder_of_the_week_db.mjs SKIPPED — no reachable Postgres (${e.code || e.message}).`);
+  await pool.end().catch(() => {});
+  process.exit(0);
+}
+
+const A = 90298101, B = 90298102, C = 90298103, D = 90298104;
+const HIDDEN = 90298105, PRIVATE = 90298106, E = 90298107;
+const IDS = [A, B, C, D, E, HIDDEN, PRIVATE];
+const P1 = 't1002981-p1', P2 = 't1002981-p2';
+const DAY = 24 * 60 * 60 * 1000;
+const NOW = new Date('2099-03-12T10:00:00.000Z');
+const { start, end } = crownedWeek(NOW);
+const at = (base, ms) => new Date(base.getTime() + ms);
+const q = (sql, params) => pool.query(sql, params);
+
+async function cleanup() {
+  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, { visibility = 'public', 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', $3, $4, now())`,
+    [id, handle, visibility, hide],
+  );
+}
+// The live row (its numbers do not matter to a past week; first seen long before the
+// week unless said) and a history of snapshots.
+async function builder(id, client, history, firstSeen = at(start, -365 * DAY)) {
+  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)`, [client, id, firstSeen]);
+  for (const [when, credits, ships, karma] 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, $5, $6)`,
+      [client, id, credits, ships, karma, when],
+    );
+  }
+}
+const recorded = async (week) => (await q(
+  `SELECT github_id::text AS github_id, credits_delta::int AS credits, ships_delta::int AS ships FROM platform_identity_weekly_features WHERE week_start = $1::date`,
+  [week],
+)).rows;
+const read = (now = NOW) => { clearCrownMemo(); return readBuilderOfTheWeek({ now, pool }); };
+
+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',
+  ]) await q(migrationSql(f));
+  await cleanup();
+
+  await account(A, 't1002981-a');
+  await account(B, 't1002981-b');
+  await account(C, 't1002981-c');
+  await account(D, 't1002981-d');
+  await account(E, 't1002981-e');
+  await account(HIDDEN, 't1002981-hidden', { hide: true });
+  await account(PRIVATE, 't1002981-private', { visibility: 'private' });
+
+  // A: 350 credits, 3 works, no karma — across two projects. P1 has a snapshot before
+  // the week (the baseline); P2 has none but was first seen in the week (counts from
+  // zero). A snapshot a second AFTER the week closes is not the week's.
+  await builder(A, P1, [[at(start, -3 * DAY), 100, 5, 4], [at(start, 2 * DAY), 400, 7, 4], [at(end, 1000), 99999, 99, 4]]);
+  await builder(A, P2, [[at(start, 3 * DAY), 50, 1, 0]], at(start, 3 * DAY));
+  // E: a lifetime brought into the week — no history before it, and seen before it (or
+  // before first_seen_at existed, NULL). Counting from zero would crown E; neither counts.
+  await builder(E, P1, [[at(start, DAY), 90000, 40, 0]], null);
+  await builder(E, P2, [[at(start, DAY), 90000, 40, 0]]);
+  // C: the same credits and works as A, two more karma — C beats A on karma.
+  await builder(C, P1, [[at(start, -DAY), 0, 0, 0], [at(start, DAY), 360, 3, 2]]);
+  // D: the same credits, the most karma, but one work fewer — works come before karma.
+  await builder(D, P1, [[at(start, -DAY), 0, 0, 0], [at(start, DAY), 350, 2, 9]]);
+  // B: the most credits, but no work shipped in the week (the floor).
+  await builder(B, P1, [[at(start, -DAY), 0, 4, 0], [at(start, DAY), 900, 4, 0]]);
+  // HIDDEN and PRIVATE out-earn everyone, and the leaderboard may not show them.
+  await builder(HIDDEN, P1, [[at(start, -DAY), 0, 0, 0], [at(start, DAY), 5000, 5, 0]]);
+  await builder(PRIVATE, P1, [[at(start, -DAY), 0, 0, 0], [at(start, DAY), 5000, 5, 0]]);
+  // A snapshot exactly at the start belongs to the baseline: C's week is 360 - 10, not 360.
+  await q(`INSERT INTO platform_identity_activity_snapshots (client_id, github_id, credits, tasks_shipped, karma, reported_at) VALUES ($1, $2, 10, 0, 0, $3)`, [P1, C, start]);
+
+  // 1 — the crown, and the row that records it
+  const first = await read();
+  same(first.week, { start: start.toISOString().slice(0, 10), end: end.toISOString().slice(0, 10) }, 'the week is the last full Monday-to-Monday week');
+  same(first.winner && [first.winner.handle, first.winner.credits, first.winner.tasks_shipped], ['t1002981-c', 350, 3], 'ties go to works shipped, then karma; no work, hidden, private and a lifetime brought into the week never win');
+  ok(!('github_id' in first.winner), 'github_id never crosses');
+  same(await recorded(first.week.start), [{ github_id: String(C), credits: 350, ships: 3 }], 'the week is recorded on the first read');
+
+  // 2 — pinned: a later report into the past week, 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, A, at(start, 4 * DAY)]);
+  await q(`UPDATE platform_identity_accounts SET hide_stats = false WHERE github_id = $1`, [HIDDEN]);
+  same((await read()).winner.handle, 't1002981-c', 'the first decision stands');
+  await q(`UPDATE platform_identity_accounts SET hide_stats = true WHERE github_id = $1`, [HIDDEN]);
+
+  // 3 — a winner who hides is not shown, and their week goes to nobody else
+  await q(`UPDATE platform_identity_accounts SET hide_stats = true WHERE github_id = $1`, [C]);
+  same((await read()).winner, null, 'a hidden winner is not drawn');
+  same(await recorded(first.week.start), [{ github_id: String(C), credits: 350, ships: 3 }], 'and the row is never re-crowned');
+
+  // 4 — a later week nobody shipped in (two on, past A's late snapshot) is recorded empty;
+  // the crowned week is in its past list once its winner is shown again
+  const next = at(NOW, 14 * DAY);
+  const empty = await read(next);
+  same(empty.winner, null, 'a week nobody won has no crown');
+  same(await recorded(empty.week.start), [{ github_id: null, credits: 0, ships: 0 }], 'and is recorded empty, so it stays empty');
+  same(empty.past, [], 'the week before is left out while its winner hides');
+  await q(`UPDATE platform_identity_accounts SET hide_stats = false WHERE github_id = $1`, [C]);
+  same((await read(next)).past.map((p) => [p.week_start, p.handle]), [[first.week.start, 't1002981-c']], 'shown again, it is back in the past weeks');
+
+  // 5 — two hub processes crowning the same week at once: one row, no error
+  const third = at(NOW, 21 * DAY);
+  const other = new Pool({ connectionString: process.env.DATABASE_URL || undefined });
+  try {
+    clearCrownMemo();
+    const both = await Promise.all([readBuilderOfTheWeek({ now: third, pool }), readBuilderOfTheWeek({ now: third, pool: other })]);
+    same(both.map((b) => b.winner), [null, null], 'both answer');
+    same((await recorded(both[0].week.start)).length, 1, 'one row: ON CONFLICT DO NOTHING');
+  } finally { await other.end().catch(() => {}); }
+
+  console.log(`\nbuilder_of_the_week_db.mjs: ${pass} passed`);
+} finally {
+  clearCrownMemo();
+  await cleanup();
+  await pool.end().catch(() => {});
+}

package/tests/copy_desk_page_approve.mjs

@@ -288,6 +288,59 @@ try {
     assert.equal(pages.parseSentBackBlocks(task(5002).description).length, 2, 'send-backs append');
   });
 
+  // task 1004900: the WORDS of a submitted batch are reviewed before anything is
+  // applied. Approve puts the round in the /tweak queue; send-back withdraws the
+  // batch so the round is a draft its artist can change.
+  await test('words first: a submitted batch is in the queue as words, not applied, and only an approval sends it to /tweak', async () => {
+    const STUDIO = '/copy-desk/pages/builders:studio';
+    const line = { key: 'L0001', section: 'top', before: 'Welcome home', after: 'Welcome back', placement: 'placed', file: 'x.html', line: 1, string_id: 'abc' };
+    const desc = () => [
+      'Page tweak round 1 for builders:studio.',
+      pages.composeDraftBlock({ page_id: 'builders:studio', reading_hash: 'h', saved_at: '2026-09-23T00:00:00Z', lines: [line] }),
+      pages.composeBatchBlock({ page_id: 'builders:studio', reading_hash: 'h', submitted_at: '2026-09-23T00:00:00Z', lines: [line] }),
+    ].join('\n\n');
+    db.tasks.push({ id: '7001', status: 'ready', title: 'Tweak: Studio', description: desc(), source: 'page-tweak', source_ref: pages.roundSourceRef('builders:studio', 1), touches: [], version_id: 'V9', goal_id: '77' });
+    db.claims.push({ id: String(++db.seq.claim), task_id: '7001', builder_id: ALICE, worktree_name: null, creator_session_id: null, claimed_at: stamp(), released_at: stamp(), outcome: 'partial' });
+
+    assert.equal((await call('GET', STUDIO, ALICE)).body.open_round.state, 'words_review');
+    const q = (await call('GET', '/copy-desk/approvals', BOB)).body;
+    const item = q.queue.find((x) => x.task_id === '7001');
+    assert.ok(item, 'the submitted words are in the queue');
+    assert.equal(item.kind, 'words');
+    assert.equal(item.applied_at, null);
+    assert.deepEqual(item.lines.map((l) => [l.before, l.after]), [['Welcome home', 'Welcome back']]);
+    assert.equal(q.not_applied.some((r) => r.task_id === '7001'), false, 'not listed as approved-and-waiting');
+
+    const dan = await call('POST', `${STUDIO}/approve`, DAN, { task_id: '7001' });
+    assert.equal(errCode(dan.body), 'not_an_artist');
+    const short = await call('POST', `${STUDIO}/send-back`, BOB, { note: 'nope' });
+    assert.equal(errCode(short.body), 'note_too_short');
+
+    const ok = await call('POST', `${STUDIO}/approve`, BOB, { task_id: '7001' });
+    assert.equal(ok.status, 200, JSON.stringify(ok.body));
+    assert.equal(ok.body.outcome, 'words_approved');
+    assert.deepEqual(ok.body.round, { task_id: '7001', state: 'submitted', status: 'ready' });
+    assert.equal(task(7001).status, 'ready', 'nothing applied or landed: the task only gained the approval');
+    assert.deepEqual(pages.parseWordsApprovedBlocks(task(7001).description).map((a) => a.by), [BOB]);
+    assert.equal((await call('GET', STUDIO, ALICE)).body.open_round.state, 'submitted', 'now in the /tweak queue');
+    const after = (await call('GET', '/copy-desk/approvals', BOB)).body;
+    assert.equal(after.queue.some((x) => x.task_id === '7001'), false);
+    assert.equal(after.not_applied.some((r) => r.task_id === '7001'), true, 'listed as approved, waiting to be applied');
+    const twice = await call('POST', `${STUDIO}/approve`, BOB);
+    assert.equal(errCode(twice.body), 'not_waiting', 'an approved batch is not decided again');
+
+    // A second round of words, sent back: the batch goes, the draft stays, the note rests on the task.
+    task(7001).description = desc();
+    const back = await call('POST', `${STUDIO}/send-back`, ALICE, { note: 'I want to say this differently.', task_id: '7001' });
+    assert.equal(back.status, 200, JSON.stringify(back.body));
+    assert.equal(back.body.outcome, 'words_sent_back');
+    assert.equal(pages.parseBatchBlock(task(7001).description).ok, false, 'the batch is withdrawn');
+    assert.equal(pages.parseDraftBlock(task(7001).description).ok, true, 'the draft stays for its writer');
+    assert.deepEqual(pages.parseSentBackBlocks(task(7001).description).map((s) => s.note), ['I want to say this differently.']);
+    assert.equal((await call('GET', STUDIO, ALICE)).body.open_round.state, 'draft', 'a draft again, open for writing');
+    assert.equal(pages.roundOpenForWriting(task(7001)), true);
+  });
+
   await test('an ordinary task and a failed grade are never moved through the port', async () => {
     db.tasks.push({ id: '6001', status: 'completed', title: 'x', description: '', source: 'planning-session', source_ref: 'x', touches: [] });
     db.grades.set('6001', true);

package/tests/copy_desk_page_editor.mjs

@@ -144,10 +144,10 @@ try {
     writeReadings(readingsWith('studio-h1'));
   });
 
-  await test('after submit the round reads submitted and nobody holds it', async () => {
+  await test('after submit the round waits for its words to be reviewed and nobody holds it', async () => {
     assert.equal((await call('POST', `${STUDIO}/submit`, ALICE)).body.outcome, 'submitted');
     const r = await call('GET', `${STUDIO}/draft`, ALICE);
-    assert.equal(r.body.round.state, 'submitted');
+    assert.equal(r.body.round.state, 'words_review', 'task 1004900: reviewed before it is applied');
     assert.equal(r.body.round.held_by_you, false);
     assert.equal(r.body.round.holder, null);
   });

package/tests/copy_desk_page_next.mjs

@@ -154,7 +154,7 @@ try {
     round.status = 'ready';
     round.description += '\n\n' + pages.composeBatchBlock({ page_id: 'status:explore', reading_hash: 'h', submitted_at: 'x', lines: [{ key: 'L0001', section: 'hero', before: 'Explore', after: 'Look around', placement: 'placed', file: 'x', line: 1, string_id: 'a' }] });
     const next = (await getNext(ALICE)).body;
-    assert.deepEqual(next.skipped, [{ page_id: 'status:explore', reason: 'page_in_flight', state: 'submitted' }]);
+    assert.deepEqual(next.skipped, [{ page_id: 'status:explore', reason: 'page_in_flight', state: 'words_review' }]);
     const refused = await call('POST', '/copy-desk/pages/status:explore/claim', ALICE, {});
     assert.equal(errCode(refused.body), 'page_in_flight');
   });

package/tests/copy_desk_page_release.mjs

@@ -104,7 +104,7 @@ try {
     const flight = Object.fromEntries(r.body.in_flight.map((f) => [f.page_id, f]));
     assert.deepEqual([flight['landing:index'].state, flight['landing:index'].stuck, flight['landing:index'].task_id], ['unknown', true, '7001']);
     assert.deepEqual([flight['landing:projects'].state, flight['landing:projects'].stuck], ['unknown', true]);
-    assert.equal(flight['status:explore'].state, 'submitted');
+    assert.equal(flight['status:explore'].state, 'words_review');
     assert.equal(flight['status:explore'].stuck, false);
   });
 

package/tests/copy_desk_page_submit.mjs

@@ -188,7 +188,7 @@ try {
     const r = await call('POST', `${STUDIO}/submit`, ALICE);
     assert.equal(r.status, 200, JSON.stringify(r.body));
     assert.equal(r.body.outcome, 'submitted');
-    assert.deepEqual(r.body.round, { task_id: studioTask().id, state: 'submitted', status: 'ready' });
+    assert.deepEqual(r.body.round, { task_id: studioTask().id, state: 'words_review', status: 'ready' });
     assert.equal(r.body.batch.line_count, 2);
     assert.deepEqual(r.body.next, { path: '/copy-desk/next' });
 
@@ -229,7 +229,7 @@ try {
   await test('the page reads submitted, and nobody can claim it back into writing', async () => {
     const page = await call('GET', STUDIO, BOB);
     assert.equal(page.status, 200);
-    assert.equal(page.body.open_round.state, 'submitted');
+    assert.equal(page.body.open_round.state, 'words_review');
     const claim = await call('POST', `${STUDIO}/claim`, BOB);
     assert.equal(errCode(claim.body), 'page_in_flight');
   });

package/tests/copy_stuck_page_tweaks.mjs

@@ -23,7 +23,8 @@ const ago = (d) => new Date(NOW.getTime() - d * 86400000).toISOString();
 const pg = (id, title = id) => ({ id, surface: id.split(':')[0], title, path: '/', files: [] });
 const PAGES = [pg('landing:index', '{{productName}}: {{tagline}}'), pg('landing:account', 'Account'), pg('builders:studio', 'Studio'), pg('landing:projects', 'Projects')];
 const INVENTORY = { surfaces: [{ id: 'landing' }, { id: 'builders' }], pages: PAGES };
-const batch = (id) => pages.composeBatchBlock({ page_id: id, reading_hash: 'h', submitted_at: ago(9), lines: [] });
+// Approved words (task 1004900): the round waits to be applied.
+const batch = (id) => `${pages.composeBatchBlock({ page_id: id, reading_hash: 'h', submitted_at: ago(9), lines: [] })}\n\n${pages.composeWordsApprovedBlock({ at: ago(9), by: '7' })}`;
 const round = (n, id, extra) => ({ id: String(n), source: 'page-tweak', source_ref: pages.roundSourceRef(id, 1), description: pages.roundTaskBody(pg(id), 1), artist_id: '7', ...extra });
 const ARTIST = '7';
 const TASKS = [
@@ -45,6 +46,14 @@ await test('the composer: only stuck pages, each with where it sits, how long, a
   ]);
 });
 
+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 });
+  assert.deepEqual(got.map((s) => [s.page_id, s.state, s.waits_on]), [['landing:projects', 'words_review', 'artist']]);
+  assert.deepEqual(status.stuckPageTweaksFor({ builderId: ARTIST, rank: 'xenos', stuck: got }).map((s) => s.page_id), ['landing:projects']);
+  assert.deepEqual(status.stuckPageTweaksFor({ builderId: '99', rank: 'metic', stuck: got }), [], 'an applier is not asked to review words');
+});
+
 await test('Home: the artist sees their own review; a Metic+ builder sees what waits to be applied', () => {
   const forArtist = status.stuckPageTweaksFor({ builderId: ARTIST, rank: 'thetes', stuck: stuck() });
   assert.deepEqual(forArtist.map((s) => s.page_id), ['landing:account']);
@@ -57,7 +66,7 @@ await test('the real needs roster: one Needs-attention line per page, where and
   const r = needs.computeNeeds({ rank: 'archon', ownKeySet: true, stuckPageTweaks: status.stuckPageTweaksFor({ builderId: ARTIST, rank: 'archon', stuck: stuck() }) });
   const lines = r.items.filter((n) => n.id.startsWith('page_tweak_stuck:'));
   assert.deepEqual(lines.map((n) => [n.id, n.title, n.message, n.state, n.action.href]), [
-    ['page_tweak_stuck:landing:index', 'Page tweak stuck: landing:index', 'Submitted, waiting to be applied for 26 days.', 'action_needed', '/studio'],
+    ['page_tweak_stuck:landing:index', 'Page tweak stuck: landing:index', 'Approved, waiting to be applied for 26 days.', 'action_needed', '/studio'],
     ['page_tweak_stuck:landing:account', 'Page tweak stuck: Account', 'Waiting for your review for 5 days.', 'action_needed', '/studio'],
   ]);
 });
@@ -82,7 +91,7 @@ await test('the real digest: page names only, never copy, to the ship channel, a
   assert.equal(posts[0].channel, 'ship_feed');
   assert.equal(posts[0].text, [
     'Page tweaks stuck (2). Open the Studio to move them:',
-    '- landing:index: submitted, waiting to be applied, 26 days',
+    '- landing:index: approved, waiting to be applied, 26 days',
     '- Account: waiting for your review, 5 days',
   ].join('\n'));
   const again = await stuckTweaks.runDigest({ nowMs: NOW.getTime() + 3600_000, state, post, readStuckImpl });

package/tests/hall_approval_queue.mjs

@@ -141,8 +141,8 @@ await test('lib: the artboard\'s words, from the route\'s own shape', () => {
   assert.equal(lib.displayTitle(home), 'Home', 'an apex template title is Home, the artboard\'s own word');
   assert.equal(lib.subLine(home), '· landing · 1 line rewritten, applied · 1 not applied');
   assert.equal(lib.subLine(projects), '· landing · 1 line rewritten, applied');
-  assert.equal(lib.doorDetail(2), '2 pages applied, waiting for you');
-  assert.equal(lib.doorDetail(1), '1 page applied, waiting for you');
+  assert.equal(lib.doorDetail(2), '2 pages waiting for you');
+  assert.equal(lib.doorDetail(1), '1 page waiting for you');
   assert.equal(lib.doorDetail(0), 'nothing waiting for you');
   assert.equal(lib.approvedLine(home, { status_after: 'Text tweaked 3x', next: { page: { title: 'Contact' } } }),
     'Approved. It ships now, and Home reads text tweaked 3x. Next in the queue: Contact.', 'the artboard line, word for word');
@@ -346,22 +346,22 @@ await test('submitted but not applied: listed apart, marked, how long, no verbs,
   const submitted = {
     id: 60, status: 'ready', holder_id: null, artist_id: ME, artist_login: 'me', updated_at: '2026-09-29T08:00:00Z',
     source_ref: pages.roundSourceRef('landing:projects', 2),
-    description: ['Page tweak round 2.', pages.composeBatchBlock({ page_id: 'landing:projects', reading_hash: 'h', submitted_at: '2026-09-29T08:00:00Z', lines: [{ key: 'L0002', section: 'list', before: 'Every project', after: 'All of them', placement: 'placed', file: 'x.html', line: 1, string_id: 'a' }] })].join('\n\n'),
+    description: ['Page tweak round 2.', pages.composeBatchBlock({ page_id: 'landing:projects', reading_hash: 'h', submitted_at: '2026-09-29T08:00:00Z', lines: [{ key: 'L0002', section: 'list', before: 'Every project', after: 'All of them', placement: 'placed', file: 'x.html', line: 1, string_id: 'a' }] }), pages.composeWordsApprovedBlock({ at: '2026-09-29T09:00:00Z', by: ME })].join('\n\n'),
   };
   const tasks = [...TASKS.filter((t) => t.id !== 42), submitted];
   const data = pageStatus.composeApprovals({ inventory: INVENTORY, tasks, builderId: ME, crafts: ['artist'], now: NOW });
   assert.equal(data.count, 1, 'the door counts reviewable rounds only');
   assert.deepEqual(data.queue.map((q) => q.task_id), ['41']);
   assert.deepEqual(data.not_applied.map((r) => [r.page_id, r.task_id, r.state_word, r.waited_days, r.line_count]),
-    [['landing:projects', '60', 'Submitted, waiting to be applied', 21, 1]]);
+    [['landing:projects', '60', 'Approved, waiting to be applied', 21, 1]]);
 
   const b = bootPanel({ answers: { [APPROVALS]: { ok: true, ...data }, [vis(41)]: slotsFor(41) } });
   await b.panel.open(); await settle(); await settle();
-  assert.equal(text(b.q('.aq-pending__h')), 'Submitted, not applied yet (1)');
+  assert.equal(text(b.q('.aq-pending__h')), 'Approved, not applied yet (1)');
   const row = b.q('.aq-pending__row');
   assert.match(text(row), /Projects/);
   assert.match(text(row), /not applied yet/);
-  assert.match(text(row), /Submitted, waiting to be applied · waiting 21 days\. The words are waiting to be applied/);
+  assert.match(text(row), /Approved, waiting to be applied · waiting 21 days\. The words are approved and waiting to be put on the page/);
   assert.equal(row.querySelectorAll('button').length, 0, 'no approve or send-back on a page nobody applied');
   assert.deepEqual(b.counts, [1]);
 

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 three sub-pages, folded into the band under 480px (task 1003363)
-    ['Leaderboard', '/community'], ['Find a builder', '/community/find'], ['Open to recruiters', '/community/recruiters'],
+    // 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'],
     ['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')), [