@bongos/core 1.24.29 → 1.24.30

package/tests/home_city.mjs

@@ -0,0 +1,385 @@
+// tests/home_city.mjs — Home's project city (task 1005054): the weekly summary the
+// server counts, and the drawing that turns it into towers and a ladder.
+//
+// The server half (modules/lifecycle/home-city.js) is driven three ways with no
+// database: the pure shaping over hand-written rows, the reads against a recording
+// fake pool (to prove every query is bounded by the window, the areas or a LIMIT,
+// and that the viewer-only and module-optional parts behave), and the handler. The
+// drawing half (modules/hall-ui/public/home-city-draw.js) is pure and runs in node.
+//
+// Run:  node tests/home_city.mjs
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+import { makeRunner } from './helpers.mjs';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+process.env.NODE_ENV = 'test';
+const city = require(path.join(ROOT, 'modules/lifecycle/home-city.js'));
+const Draw = require(path.join(ROOT, 'modules/hall-ui/public/home-city-draw.js'));
+const FIXTURE = JSON.parse(fs.readFileSync(path.join(ROOT, 'scripts/hall-preview/fixtures/home__city.json'), 'utf8'));
+
+const { test, summary } = makeRunner();
+
+const START = new Date('2026-08-31T00:00:00Z');
+function raw(over = {}) {
+  return Object.assign({
+    N: 4, start: START, version: { id: 'V2', name: 'The ten working areas' },
+    areas: [{ goal_id: '10', title: 'Area ten' }, { goal_id: '20', title: 'Area twenty' }],
+    areaWeeks: [], leads: [], peopleWeeks: [], ideaCounts: [], ideas: [], gov: [], sites: [], waiting: [],
+    builders: [{ id: '1', github_login: 'ana', display_name: 'Ana', avatar_url: null }, { id: '2', github_login: 'bo', display_name: null, avatar_url: 'https://x/2.png' }],
+  }, over);
+}
+
+// ---------------------------------------------------------------------------
+// 1. the shaping (pure)
+// ---------------------------------------------------------------------------
+
+await test('an area splits what came before the window from each week, and art from build', () => {
+  const out = city.shapeCity(raw({
+    areaWeeks: [
+      { goal_id: '10', wk: -1, art: false, n: 40 }, { goal_id: '10', wk: -1, art: true, n: 3 },
+      { goal_id: '10', wk: 0, art: false, n: 5 }, { goal_id: '10', wk: 3, art: true, n: 2 },
+      { goal_id: '10', wk: 7, art: false, n: 99 }, // outside a four-week window: dropped, never piled on the edge
+      { goal_id: '99', wk: 1, art: false, n: 9 },  // not an area of the version: ignored
+    ],
+  }), null);
+  const a = out.areas.find((x) => x.goal_id === '10');
+  assert.equal(a.base_build, 40); assert.equal(a.base_art, 3);
+  assert.deepEqual(a.build, [5, 0, 0, 0]); assert.deepEqual(a.art, [0, 0, 0, 2]);
+  assert.deepEqual(out.weeks.map((w) => w.start), ['2026-08-31', '2026-09-07', '2026-09-14', '2026-09-21']);
+});
+
+await test('people are only known builders; the viewer is always there, even with a quiet week', () => {
+  const out = city.shapeCity(raw({
+    peopleWeeks: [{ id: '1', wk: 2, art: false, n: 4 }, { id: '1', wk: 2, art: true, n: 1 }, { id: '77', wk: 2, art: false, n: 8 }],
+    ideaCounts: [{ id: '2', wk: 1, n: 3 }], gov: [{ id: '1', wk: 3, n: 2 }],
+  }), { id: '2', rank: 'metic' });
+  const ana = out.people.find((p) => p.id === '1'), bo = out.people.find((p) => p.id === '2');
+  assert.deepEqual(ana.build, [0, 0, 4, 0]); assert.deepEqual(ana.art, [0, 0, 1, 0]); assert.deepEqual(ana.gov, [0, 0, 0, 2]);
+  assert.deepEqual(bo.idea, [0, 3, 0, 0]);
+  assert.equal(bo.name, 'bo', 'no display name falls back to the login');
+  assert.ok(!out.people.some((p) => p.id === '77'), 'a machine principal or deleted builder (not in builders) is never drawn');
+  assert.equal(out.viewer.id, '2');
+  assert.ok(out.people.every((p) => p.agent === false), 'a person is never an agent: agents are a site fact');
+});
+
+await test('leads, ideas and sites keep only what the city can place', () => {
+  const out = city.shapeCity(raw({
+    leads: [{ goal_id: '10', wk: 1, shipped_by: '1' }, { goal_id: '20', wk: 1, shipped_by: '77' }],
+    ideas: [{ id: 5, title: 'Sky', by: '1', wk: 3, goal_id: '20' }, { id: 6, title: 'Old', by: '1', wk: 9, goal_id: null }, { id: 7, title: 'Stray', by: '77', wk: 0, goal_id: '99' }],
+    sites: [{ goal_id: '10', builder_id: '1', agent: true }, { goal_id: '99', builder_id: '1', agent: false }, { goal_id: '20', builder_id: '77', agent: false }],
+    waiting: [{ goal_id: '20', n: 4 }, { goal_id: '10', n: 0 }, { goal_id: '99', n: 2 }],
+  }), null);
+  assert.equal(out.areas[0].lead[1], '1'); assert.equal(out.areas[1].lead[1], null);
+  assert.deepEqual(out.ideas.map((i) => [i.id, i.goal_id, i.by]), [['5', '20', '1'], ['7', null, null]]);
+  assert.deepEqual(out.now.sites, [{ goal_id: '10', builder_id: '1', agent: true }]);
+  assert.deepEqual(out.now.waiting, [{ goal_id: '20', count: 4 }]);
+});
+
+await test('a private area the viewer may not read keeps its tower but loses its name, and so do its ideas (ADR 0112)', () => {
+  const r = raw({
+    areas: [{ goal_id: '10', title: 'Area ten', visible: true }, { goal_id: '20', title: 'Secret plan', visible: false }],
+    areaWeeks: [{ goal_id: '20', wk: 1, art: false, n: 3 }],
+    ideas: [{ id: '7', title: 'Secret idea', by: '1', wk: 1, goal_id: '20' }, { id: '8', title: 'Open idea', by: '1', wk: 1, goal_id: '10' }],
+  });
+  const d = city.shapeCity(r, { id: '1' });
+  const hidden = d.areas.find((a) => a.goal_id === '20');
+  assert.equal(hidden.title, null, 'the private name never leaves the server');
+  assert.deepEqual(hidden.build, [0, 3, 0, 0], 'its counts are structure and stay');
+  assert.equal(d.areas.find((a) => a.goal_id === '10').title, 'Area ten');
+  assert.equal(d.ideas.find((x) => x.id === '7').title, null, 'an idea tied to it loses its title too');
+  assert.equal(d.ideas.find((x) => x.id === '8').title, 'Open idea');
+  assert.ok(!JSON.stringify(d).includes('Secret'), 'no private prose anywhere in the payload');
+  const m = Draw.cityModel(d);
+  assert.equal(m.areas.find((a) => a.id === '20').title, 'A private area');
+  assert.equal(m.ideas.find((x) => x.id === '7').title, 'A private idea');
+});
+
+await test('weeks are clamped: never fewer than four, never more than twenty-six', () => {
+  assert.equal(city.clampWeeks(undefined), city.DEFAULT_WEEKS);
+  assert.equal(city.clampWeeks('2'), 4);
+  assert.equal(city.clampWeeks('500'), 26);
+  assert.equal(city.clampWeeks('abc'), city.DEFAULT_WEEKS);
+});
+
+// ---------------------------------------------------------------------------
+// 2. the reads: bounded, viewer-scoped, module-optional
+// ---------------------------------------------------------------------------
+
+function fakePool({ tables = {} } = {}) {
+  const seen = [];
+  return {
+    seen,
+    async query(sql, params) {
+      seen.push({ sql, params });
+      if (/to_regclass/.test(sql)) return { rows: [{ ok: !!tables[String(params[0]).replace('public.', '')] }] };
+      if (/date_trunc\('week'/.test(sql)) return { rows: [{ start: START }] };
+      if (/FROM versions/.test(sql)) return { rows: [{ id: 'V2', name: 'V2' }] };
+      if (/FROM goals g/.test(sql)) return { rows: [{ goal_id: '10', title: 'Area ten' }] };
+      if (/FROM builders b/.test(sql)) return { rows: [] };
+      return { rows: [] };
+    },
+  };
+}
+
+await test('every read is bounded by the window, the areas or a LIMIT, and never selects a task body', async () => {
+  const pool = fakePool({ tables: { government_board_votes: true, autonomy_runner_heartbeat: true, government_asks: true } });
+  await city.readCity({ weeks: 10, viewer: { id: '1', rank: 'archon' } }, { pool, getFocusVersionId: async () => null });
+  const data = pool.seen.filter((q) => !/to_regclass|date_trunc\('week'|FROM versions/.test(q.sql));
+  assert.ok(data.length >= 8, 'the summary reads areas, weeks, leads, people, ideas, govern, sites and waiting');
+  for (const q of data) {
+    const bounded = /LIMIT \d+/.test(q.sql) || /goal_id = ANY\(\$1::bigint\[\]\)/.test(q.sql) || /(shipped_at|captured_at|cast_at|resolved_at) >= \$1/.test(q.sql) || /b\.id = ANY/.test(q.sql);
+    assert.ok(bounded, `unbounded read:\n${q.sql}`);
+    assert.doesNotMatch(q.sql, /description|body_md|value_summary/, 'the city never downloads prose it does not draw');
+  }
+  assert.ok(data.filter((q) => /FROM tasks t/.test(q.sql) && !/claims c/.test(q.sql)).every((q) => /GROUP BY/.test(q.sql)), 'task reads come back as counts, not rows');
+});
+
+await test('visibility comes from the signed-in viewer: membership or Archon, never the query', async () => {
+  const metic = fakePool();
+  await city.readCity({ weeks: 10, viewer: { id: '42', rank: 'metic' } }, { pool: metic, getFocusVersionId: async () => null });
+  const q = metic.seen.find((x) => /FROM goals g/.test(x.sql));
+  assert.match(q.sql, /visibility IS DISTINCT FROM 'private'/);
+  assert.match(q.sql, /goal_members gm WHERE gm\.goal_id = g\.id AND gm\.builder_id = \$3/);
+  assert.deepEqual(q.params.slice(1), [false, '42']);
+  const archon = fakePool();
+  await city.readCity({ weeks: 10, viewer: { id: '1', rank: 'archon' } }, { pool: archon, getFocusVersionId: async () => null });
+  assert.equal(archon.seen.find((x) => /FROM goals g/.test(x.sql)).params[1], true);
+});
+
+await test('the independent reads run together, not one after another', async () => {
+  let inFlight = 0; let peak = 0;
+  const pool = fakePool({ tables: { government_board_votes: true, autonomy_runner_heartbeat: true, government_asks: true } });
+  const orig = pool.query.bind(pool);
+  pool.query = async (sql, params) => { inFlight += 1; peak = Math.max(peak, inFlight); await new Promise((r) => setTimeout(r, 5)); inFlight -= 1; return orig(sql, params); };
+  await city.readCity({ weeks: 10, viewer: { id: '1', rank: 'archon' } }, { pool, getFocusVersionId: async () => null });
+  assert.ok(peak >= 8, `the per-area and per-person reads overlap (peak ${peak})`);
+});
+
+await test('"waits on you" is the docket\'s routing when the government port answers, for any viewer it routes to', async () => {
+  const asked = [];
+  const government = { yoursByGoal: async (v) => { asked.push(v); return { available: true, goals: { 10: 2, 99: 5, 20: 0 } }; } };
+  const pool = fakePool({ tables: { government_asks: true } });
+  const r = await city.readCity({ weeks: 10, viewer: { id: '8', rank: 'metic' } }, { pool, government, getFocusVersionId: async () => null });
+  assert.deepEqual(asked, [{ id: '8', rank: 'metic' }], 'the port is asked once, for this viewer');
+  assert.deepEqual(r.waiting, [{ goal_id: '10', n: 2 }], 'a seated Metic gets their dots; a goal that is not an area is dropped');
+  assert.ok(!pool.seen.some((q) => /JOIN task_blockers/.test(q.sql)), 'the approximation is not read when the docket answered');
+  const none = await city.readCity({ weeks: 10, viewer: null }, { pool: fakePool(), government, getFocusVersionId: async () => null });
+  assert.deepEqual([none.waiting, asked.length], [[], 1], 'a signed-out viewer is never asked about');
+});
+
+await test('"waits on you" is held per viewer for a short window, so a reload of Home costs no docket reads', async () => {
+  let calls = 0; let t = 1000;
+  const government = { yoursByGoal: async () => { calls += 1; return { available: true, goals: { 10: 1 } }; } };
+  const run = (viewer) => city.readCity({ weeks: 10, viewer }, { pool: fakePool(), government, now: () => t, getFocusVersionId: async () => null });
+  const a = await run({ id: '8', rank: 'metic' });
+  t += city.WAITING_TTL_MS - 1;
+  const b = await run({ id: '8', rank: 'metic' });
+  assert.deepEqual([calls, a.waiting, b.waiting], [1, [{ goal_id: '10', n: 1 }], [{ goal_id: '10', n: 1 }]], 'inside the window: one docket read, the same dots');
+  await run({ id: '9', rank: 'metic' });
+  assert.equal(calls, 2, 'another viewer is asked for their own answer');
+  t += 2;
+  await run({ id: '8', rank: 'metic' });
+  assert.equal(calls, 3, 'after the window the docket is asked again');
+  const failing = { yoursByGoal: async () => ({ available: false, reason: 'unavailable' }) };
+  let fcalls = 0; const counted = { yoursByGoal: async (v) => { fcalls += 1; return failing.yoursByGoal(v); } };
+  for (let i = 0; i < 2; i += 1) await city.readCity({ weeks: 10, viewer: { id: '8', rank: 'metic' } }, { pool: fakePool(), government: counted, now: () => t, getFocusVersionId: async () => null });
+  assert.equal(fcalls, 2, 'an unavailable answer is never held');
+});
+
+await test('"waits on you" falls back to the approximation (Archon only) when the port is absent, older, unavailable or throws', async () => {
+  const ports = [null, {}, { yoursByGoal: async () => ({ available: false, reason: 'unavailable' }) }, { yoursByGoal: async () => { throw new Error('db down'); } }];
+  for (const government of ports) {
+    const metic = fakePool({ tables: { government_asks: true } });
+    const m = await city.readCity({ weeks: 10, viewer: { id: '1', rank: 'metic' } }, { pool: metic, government, getFocusVersionId: async () => null });
+    assert.ok(!metic.seen.some((q) => /JOIN task_blockers/.test(q.sql)), 'a Metic is not the owner seat: no approximation read');
+    assert.deepEqual(m.waiting, []);
+    const archon = fakePool({ tables: { government_asks: true } });
+    await city.readCity({ weeks: 10, viewer: { id: '1', rank: 'archon' } }, { pool: archon, government, getFocusVersionId: async () => null });
+    const w = archon.seen.find((q) => /JOIN task_blockers/.test(q.sql));
+    assert.ok(w, 'an Archon gets the per-area approximation');
+    assert.match(w.sql, /a\.waits_on = 'owner'/, 'only blockers whose ask waits on the owner seat (or carry none)');
+  }
+});
+
+await test('the government port\'s yoursByGoal counts, per goal, the goal-shaped matters the docket routes to the viewer', async () => {
+  const docket = require(path.join(ROOT, 'modules/government/docket.js'));
+  const port = require(path.join(ROOT, 'modules/government/routes/government.js')).governmentPort;
+  assert.equal(typeof port.yoursByGoal, 'function', 'the port carries it');
+  assert.deepEqual([...docket.GOAL_SOURCES], ['blockers', 'criteria_uat', 'goal_join_requests']);
+  const src = (source, building, rows, gate = { anyBuilder: true }) => [source, { source, building, gate, read: async () => rows }];
+  const contributions = { sources: new Map([
+    src('blockers', 'planning', [{ id: 7, title: 'Pick a host', state: 'needs' }, { id: 8, title: 'Token scope', state: 'needs' }, { id: 9, title: 'Moving one', state: 'moving' }]),
+    src('criteria_uat', 'review', [{ id: 31, title: 'Sign off C3', state: 'needs' }], { permission: 'criterion.review' }),
+    src('goal_join_requests', 'people', [{ id: 55, title: 'Bo asks to join', state: 'needs' }]),
+    src('core_update', 'release', [{ id: 1, title: 'Update', state: 'needs' }]), // not goal-shaped: never read
+  ]) };
+  const seats = { leads: [{ building: 'review', builder_id: 8 }], owner: { builders: [{ id: 7 }] }, holders: {}, access: {} };
+  const asks = new Map([['blockers:8', { waits_on: 'lead:review' }]]);
+  let mapped = null;
+  const goalsOf = async (q) => {
+    mapped = q;
+    const rows = { 'blockers:7': ['10', '20'], 'blockers:8': ['10'], 'criteria_uat:31': ['20'], 'goal_join_requests:55': ['30'] };
+    return [...q.blockers.map((id) => `blockers:${id}`), ...q.criteria.map((id) => `criteria_uat:${id}`), ...q.joinRequests.map((id) => `goal_join_requests:${id}`)]
+      .flatMap((m) => (rows[m] || []).map((g) => ({ matter_id: m, goal_id: g })));
+  };
+  const opts = (permissions) => ({ contributions, permissions, readAsks: async () => asks, readSeats: async () => seats, goalsOf });
+
+  // The owner (no Lead in Planning or People): the ask-less blocker and the join request fall to them.
+  const owner = await docket.yoursByGoal({ id: 7, rank: 'archon' }, opts(['board.vote.cast', 'criterion.review']));
+  assert.deepEqual(owner, { available: true, goals: { 10: 1, 20: 1, 30: 1 } });
+  assert.deepEqual(mapped, { blockers: ['7'], criteria: [], joinRequests: ['55'] }, 'only matters routed to the viewer are mapped');
+
+  // The seated Review Lead: the blocker whose ask names their seat, and the criterion at their building.
+  const lead = await docket.yoursByGoal({ id: 8, rank: 'metic' }, opts(['board.vote.cast', 'criterion.review']));
+  assert.deepEqual(lead, { available: true, goals: { 10: 1, 20: 1 } });
+
+  // Without the criterion atom the source is gated out, exactly as on the docket.
+  const gated = await docket.yoursByGoal({ id: 8, rank: 'metic' }, opts(['board.vote.cast']));
+  assert.deepEqual(gated.goals, { 10: 1 });
+
+  // Without the docket's own atom nothing is routed (docketFor's rule).
+  assert.deepEqual(await docket.yoursByGoal({ id: 7 }, opts([])), { available: true, goals: {} });
+  // Unreadable seats are said, never a guessed zero.
+  assert.deepEqual(await docket.yoursByGoal({ id: 7 }, { ...opts(['board.vote.cast']), readSeats: async () => null }), { available: false, reason: 'unavailable' });
+});
+
+await test('government and autonomy tables are probed first: switched off, they are never named', async () => {
+  const pool = fakePool({ tables: {} });
+  await city.readCity({ weeks: 10, viewer: { id: '1', rank: 'archon' } }, { pool, getFocusVersionId: async () => null });
+  const all = pool.seen.filter((q) => !/to_regclass/.test(q.sql)).map((q) => q.sql).join('\n');
+  assert.doesNotMatch(all, /government_board_votes|autonomy_runner_heartbeat|government_asks/);
+});
+
+await test('an Xenos viewer never sees skill-friction ideas', async () => {
+  const pool = fakePool();
+  await city.readCity({ weeks: 10, viewer: { id: '1', rank: 'xenos' } }, { pool, getFocusVersionId: async () => null });
+  const ideaReads = pool.seen.filter((q) => /FROM idea_inbox/.test(q.sql));
+  assert.equal(ideaReads.length, 2);
+  for (const q of ideaReads) assert.match(q.sql, /i\.kind <> 'skill-friction' AND i\.title NOT LIKE '\[skill-friction\]%'/);
+  const metic = fakePool();
+  await city.readCity({ weeks: 10, viewer: { id: '1', rank: 'metic' } }, { pool: metic, getFocusVersionId: async () => null });
+  for (const q of metic.seen.filter((x) => /FROM idea_inbox/.test(x.sql))) assert.doesNotMatch(q.sql, /skill-friction/);
+});
+
+await test('no version being built: no areas are read and the city has nothing to draw', async () => {
+  const pool = fakePool();
+  pool.query = ((orig) => async (sql, params) => (/FROM versions/.test(sql) ? { rows: [] } : orig.call(pool, sql, params)))(pool.query);
+  const r = await city.readCity({ weeks: 10, viewer: null }, { pool, getFocusVersionId: async () => null });
+  assert.equal(r.version, null);
+  assert.deepEqual(r.areas, []);
+  assert.ok(!pool.seen.some((q) => /FROM goals g/.test(q.sql)));
+});
+
+// ---------------------------------------------------------------------------
+// 3. the handler
+// ---------------------------------------------------------------------------
+
+function fakeRes() {
+  const res = { headers: {}, body: null, failed: null };
+  res.set = (k, v) => { res.headers[k] = v; return res; };
+  res.json = (b) => { res.body = b; return res; };
+  res.fail = (code, o) => { res.failed = { code, status: o.status }; return res; };
+  return res;
+}
+
+await test('the handler shapes the read for the caller, privately cached', async () => {
+  let asked = null;
+  const h = city.homeCityHandler({ read: async (q) => { asked = q; return raw(); } });
+  const res = fakeRes();
+  await h({ builder: { id: '1', rank: 'thetes' }, query: { weeks: '8' } }, res);
+  assert.deepEqual(asked, { weeks: '8', viewer: { id: '1', rank: 'thetes' } });
+  assert.equal(res.headers['Cache-Control'], 'private, max-age=60');
+  assert.equal(res.body.viewer.id, '1');
+  assert.equal(res.body.areas.length, 2);
+});
+
+await test('a failed read is a 500, never a half-drawn city', async () => {
+  const h = city.homeCityHandler({ read: async () => { throw new Error('db down'); }, log: { error() {} } });
+  const res = fakeRes();
+  await h({ builder: { id: '1' }, query: {} }, res);
+  assert.deepEqual(res.failed, { code: 'home_city_failed', status: 500 });
+  assert.equal(res.body, null);
+});
+
+await test('the route is registered by the lifecycle module', () => {
+  const manifest = JSON.parse(fs.readFileSync(path.join(ROOT, 'modules/lifecycle/module.json'), 'utf8'));
+  assert.ok(manifest.contributes.routes.includes('home-city'));
+});
+
+// ---------------------------------------------------------------------------
+// 4. the drawing (pure)
+// ---------------------------------------------------------------------------
+
+await test('the fixture is a shape the drawing accepts, and the tallest areas stand at the back', () => {
+  const m = Draw.cityModel(FIXTURE);
+  assert.equal(m.W, 10);
+  assert.ok(m.areas.length > 5);
+  assert.ok(m.areas[0].total >= m.areas[m.areas.length - 1].total);
+  assert.equal(m.areas[0].y, 0.8, 'the tallest tower is in the back row');
+  assert.ok(m.areas.slice(5).every((a) => a.y > 0.8), 'the shorter half stands in front');
+});
+
+await test('more areas than the ground holds are reported, not drawn', () => {
+  const many = { weeks: [{ start: '2026-08-31' }], areas: Array.from({ length: 20 }, (_, i) => ({ goal_id: String(i), title: `A${i}`, base_build: 20 - i, build: [0], art: [0] })) };
+  const m = Draw.cityModel(many);
+  assert.equal(m.areas.length, Draw.MAX_AREAS);
+  assert.equal(m.unplaced, 20 - Draw.MAX_AREAS);
+});
+
+await test('the ladder ranks the week by total, and the viewer is appended when below the top seven', () => {
+  const people = Array.from({ length: 9 }, (_, i) => ({ id: String(i), name: `P${i}`, build: [9 - i], art: [0], idea: [0], gov: [0] }));
+  const m = Draw.cityModel({ weeks: [{ start: '2026-08-31' }], areas: [], people });
+  const top = Draw.ladderFor(m, 0, '8');
+  assert.deepEqual(top.map((r) => r.id), ['0', '1', '2', '3', '4', '5', '6', '8']);
+  assert.equal(top[7].me, true);
+  assert.deepEqual(Draw.ladderFor(m, 0, '3').map((r) => r.id).length, 7, 'a viewer in the top seven is not repeated');
+});
+
+await test('the latest week shows who is on site now; an earlier week shows its four busiest areas', () => {
+  const m = Draw.cityModel(FIXTURE);
+  const now = Draw.sitesFor(m, m.W - 1);
+  assert.deepEqual(Object.keys(now).sort(), FIXTURE.now.sites.map((s) => s.goal_id).sort());
+  assert.equal(now['1000095'].agent, true, 'a runner working the site marks it an agent\'s');
+  const earlier = Draw.sitesFor(m, 3);
+  assert.ok(Object.keys(earlier).length <= 4 && Object.keys(earlier).length > 0);
+  assert.ok(Object.values(earlier).every((s) => s.agent === false));
+});
+
+// the scene comes back as shapes; walk them the way home-city.js builds them
+function walk(nodes, fn) { for (const n of nodes) { fn(n); walk(n.kids, fn); } }
+function all(nodes) { const out = []; walk(nodes, (n) => out.push(n)); return out; }
+
+await test('towers grow week by week, and salmon only appears on the latest week', () => {
+  const m = Draw.cityModel(FIXTURE);
+  const first = all(Draw.citySvg(m, 0, { mode: 'dark' }).nodes);
+  const last = all(Draw.citySvg(m, m.W - 1, { mode: 'dark' }).nodes);
+  const shipped = (ns) => ns.map((n) => /^(\d+) shipped/.exec(n.attrs['data-tip-body'] || '')).filter(Boolean).reduce((s, x) => s + Number(x[1]), 0);
+  assert.ok(shipped(last) > shipped(first), 'more has shipped by now than by the first week');
+  assert.ok(!first.some((n) => n.attrs.fill === 'var(--accent)'), 'what waits on you is now, not then');
+  assert.ok(last.some((n) => n.attrs.class === 'hc-wait'));
+  assert.ok(last.some((n) => /'s agent$/.test(n.attrs['data-tip'] || '')), 'an agent\'s site is named as one');
+});
+
+await test('ledger text is never markup: titles and names travel as attribute values and text only', () => {
+  const hostile = { weeks: [{ start: '2026-08-31' }], areas: [{ goal_id: '1', title: '<img src=x onerror=alert(1)>', base_build: 5, build: [1], art: [0], lead: ['9'] }],
+    people: [{ id: '9', name: '"><script>x</script>', build: [1], art: [0], idea: [0], gov: [0] }],
+    ideas: [{ id: '3', week: 0, by: '9', title: '<b>idea</b>' }], now: { sites: [{ goal_id: '1', builder_id: '9' }] } };
+  const ns = all(Draw.citySvg(Draw.cityModel(hostile), 0, { mode: 'light' }).nodes);
+  const SHAPES = new Set(['defs', 'radialGradient', 'stop', 'path', 'line', 'circle', 'g', 'rect', 'text', 'clipPath', 'image']);
+  assert.deepEqual([...new Set(ns.map((n) => n.tag))].filter((t) => !SHAPES.has(t)), [], 'only SVG shapes, whatever a title says');
+  assert.ok(ns.some((n) => n.attrs['data-tip'] === '<img src=x onerror=alert(1)>'), 'the title rides as an attribute value, set with setAttribute');
+  assert.ok(ns.some((n) => n.tag === 'text' && n.text === '"'), 'a name\'s initial is a text node');
+});
+
+await test('both modes draw with their own faces', () => {
+  const m = Draw.cityModel(FIXTURE);
+  assert.ok(all(Draw.citySvg(m, m.W - 1, { mode: 'dark' }).nodes).some((n) => n.attrs.fill === '#34343a'));
+  assert.ok(all(Draw.citySvg(m, m.W - 1, { mode: 'light' }).nodes).some((n) => n.attrs.fill === '#f6f5f8'));
+});
+
+summary();

package/tests/home_city_widget.mjs

@@ -0,0 +1,120 @@
+// tests/home_city_widget.mjs — Home's project city, the real widget in a browser
+// (task 1005054).
+//
+// Runs modules/hall-ui/public/home-city-draw.js + home-city.js in a real page with
+// the read stubbed by the hall-preview fixture: one bounded read per load, the
+// slider redraws towers and ladder for the week it is on, play steps a week at a
+// time from the first to now and stops, and a refused read leaves Home without an
+// empty plate. Skips where no system Edge or Chrome is installed.
+//
+// Run:  node --test tests/home_city_widget.mjs
+import assert from 'node:assert/strict';
+import { test, after } from 'node:test';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const lib = require(path.join(ROOT, 'modules', 'ui-design', 'kit', 'lib.js'));
+const pub = (f) => fs.readFileSync(path.join(ROOT, 'modules', 'hall-ui', 'public', f), 'utf8');
+const DRAW = pub('home-city-draw.js');
+const WIDGET = pub('home-city.js');
+const CSS = pub('home-city.css');
+const FIXTURE = fs.readFileSync(path.join(ROOT, 'scripts', 'hall-preview', 'fixtures', 'home__city.json'), 'utf8');
+
+let browser = null;
+try { browser = await lib.launchBrowser(); } catch (e) { if (!(e instanceof lib.NoBrowserError)) throw e; }
+after(() => browser && browser.close());
+const skip = !browser && 'no system Edge or Chrome';
+
+const stubs = (status) => `
+  window.__asked = [];
+  window.__CITY = ${FIXTURE};
+  window.BongosClient = { createClient: () => ({ request: async (m, p) => {
+    window.__asked.push(m + ' ' + p);
+    if (${status} !== 200) return { ok: false, status: ${status}, data: null };
+    return p.startsWith('/api/bongos/home/city') ? { ok: true, status: 200, data: window.__CITY } : { ok: false, status: 404, data: null };
+  } }) };
+  window.OTBCraftMode = { iconHtml: (k, cls) => '<svg class="' + cls + '" data-icon="' + k + '"></svg>' };
+  window.OTB = { contributeHallWidget(w) { window.__widget = w; } };`;
+
+async function boot({ status = 200, width = 1280 } = {}) {
+  const ctx = await browser.newContext({ viewport: { width, height: 900 } });
+  const page = await ctx.newPage();
+  await page.clock.install();
+  await page.setContent(`<!doctype html><html><head><style>${CSS}</style></head><body><section id="home-city" class="scroll home-city" hidden></section></body></html>`);
+  await page.addScriptTag({ content: stubs(status) });
+  await page.addScriptTag({ content: DRAW });
+  await page.addScriptTag({ content: WIDGET });
+  await page.evaluate(() => window.__widget.mount(document.getElementById('home-city')));
+  return { ctx, page };
+}
+
+const state = (page) => page.evaluate(() => ({
+  hidden: document.getElementById('home-city').hidden,
+  asked: window.__asked,
+  week: document.querySelector('.hc-slider').getAttribute('aria-valuetext'),
+  svgLen: document.querySelector('.hc-svg').innerHTML.length,
+  rungs: [...document.querySelectorAll('.hc-rung:not([hidden])')].sort((a, b) => parseFloat(a.style.top) - parseFloat(b.style.top)).map((r) => ({ me: r.classList.contains('hc-rung--me'), line: r.querySelector('.hc-line').textContent })),
+}));
+
+test('one bounded read; the city, its ladder and the slider appear on now', { skip }, async () => {
+  const { ctx, page } = await boot();
+  await page.waitForFunction(() => document.querySelectorAll('.hc-rung').length > 0);
+  const s = await state(page);
+  await ctx.close();
+  assert.deepEqual(s.asked, ['GET /api/bongos/home/city?weeks=10'], 'Home asks for the summary once and nothing else');
+  assert.equal(s.hidden, false);
+  assert.equal(s.week, 'this week');
+  assert.ok(s.rungs.length >= 5);
+  assert.ok(s.rungs.some((r) => r.me), 'the viewer\'s row is marked');
+});
+
+test('the slider redraws the towers and re-ranks the ladder for the week it is on', { skip }, async () => {
+  const { ctx, page } = await boot();
+  await page.waitForFunction(() => document.querySelectorAll('.hc-rung').length > 0);
+  const now = await state(page);
+  await page.evaluate(() => { const s = document.querySelector('.hc-slider'); s.value = '0'; s.dispatchEvent(new Event('input', { bubbles: true })); });
+  const first = await state(page);
+  await ctx.close();
+  assert.equal(first.week, 'week of 31 Aug');
+  assert.notEqual(first.svgLen, now.svgLen, 'the scene was redrawn');
+  assert.notDeepEqual(first.rungs, now.rungs, 'the ladder is the first week\'s, not this week\'s');
+});
+
+test('play steps a week at a time from the first week to now, then stops', { skip }, async () => {
+  const { ctx, page } = await boot();
+  await page.waitForFunction(() => document.querySelectorAll('.hc-rung').length > 0);
+  await page.click('.hc-play');
+  const atStart = await state(page);
+  assert.equal(atStart.week, 'week of 31 Aug');
+  assert.equal(await page.evaluate(() => document.querySelector('.hc-play').classList.contains('is-playing')), true);
+  await page.clock.runFor(800);
+  assert.equal((await state(page)).week, 'week of 7 Sept', 'one step is one week');
+  await page.clock.runFor(800 * 12);
+  const end = await state(page);
+  const playing = await page.evaluate(() => document.querySelector('.hc-play').classList.contains('is-playing'));
+  await ctx.close();
+  assert.equal(end.week, 'this week');
+  assert.equal(playing, false, 'play stops on now');
+});
+
+test('a refused read leaves the section hidden: never an empty plate', { skip }, async () => {
+  const { ctx, page } = await boot({ status: 401 });
+  await page.evaluate(() => new Promise((r) => setTimeout(r, 0)));
+  await page.clock.runFor(50);
+  const s = await state(page);
+  await ctx.close();
+  assert.equal(s.hidden, true);
+  assert.equal(s.rungs.length, 0);
+});
+
+test('a phone width scrolls nothing sideways', { skip }, async () => {
+  const { ctx, page } = await boot({ width: 390 });
+  await page.waitForFunction(() => document.querySelectorAll('.hc-rung').length > 0);
+  const over = await page.evaluate(() => document.documentElement.scrollWidth - document.documentElement.clientWidth);
+  await ctx.close();
+  assert.equal(over, 0);
+});

package/tests/leaderboard_roles.mjs

@@ -236,7 +236,7 @@ function extract(src, start, end) {
 
 await test('the standing card adds the place inside the builder\'s main role, only when it says something new', () => {
   const src = read('modules/hall-ui/public/hall-render.js');
-  const code = extract(src, 'const lbState = { rows: [] };', '// task 1003459');
+  const code = extract(src, 'const lbState = { rows: [] };', '    return { acclaimEvidenceHtml');
   const sandbox = { rows: FIX.leaderboard };
   vm.createContext(sandbox);
   vm.runInContext(`${code}; lbState.rows = rows; this.place = leaderboardPlace; this.text = rolePlaceText;`, sandbox);
@@ -245,7 +245,8 @@ await test('the standing card adds the place inside the builder\'s main role, on
   assert.equal(sandbox.text(art), `#1 as an artist`);
   const top = sandbox.place(FIX.leaderboard[0].github_login);
   assert.equal(sandbox.text(top), '', 'the top engineer is #1 either way, so nothing is added');
-  assert.match(src, /setText\('stat-rank-sub', rollPlace \? \[`#\$\{rollPlace\.place\} on the leaderboard`, rolePlaceText\(rollPlace\)\]/);
+  // task 1005054: the stats strip (and its rank tile) left Home; the Standing chip's card carries the role place
+  assert.match(src, /\$\{rolePlaceText\(rollPlace\) \? `<span title="Your place among the/);
   assert.match(read('modules/hall-ui/public/builders.js'), /getJSON\(`\$\{API\}\/public\/leaderboard`\)/, 'the hall reads the list with the roles');
 });