@bongos/core 1.24.29 → 1.24.30

package/modules/lifecycle/home-city.js

@@ -0,0 +1,340 @@
+'use strict';
+
+// modules/lifecycle/home-city.js — the weekly summary behind Home's project city
+// (task 1005054, the owner's Home redesign).
+//
+// WHY. Home became one scene (modules/hall-ui/public/home-city.js): a tower per
+// working area as tall as what has shipped there, a ladder of the week's builders,
+// and a slider that replays the last few weeks. Drawing that from the browser would
+// mean downloading every shipped task, idea and vote and slicing it — the read the
+// hall's bounded-reads rule forbids (modules/hall-ui/CLAUDE.md: a Home card asks
+// the server for what it draws). So it is counted here, in SQL, grouped by week:
+// the response grows with the number of areas, builders and weeks, never with the
+// corpus.
+//
+// WHAT IT ANSWERS, for the last N weeks (Monday-start, UTC; the last is this week):
+//   areas  — each open, non-maintenance goal of the version being built (the focus
+//            version, else the newest one building): what it had shipped before the
+//            window, then per week, split into art (artist and ui work — economy's
+//            credits-by-craft rule) and build, and the builder who shipped most there.
+//   people — per builder per week: tasks shipped (build / art), ideas filed, and
+//            govern acts (board votes cast, blockers resolved).
+//   ideas  — the window's ideas for the sky, newest first, bounded, each with the
+//            goal of the task it became.
+//   now    — who holds an open claim in each area (an Autobongos runner working it
+//            marks the site as an agent's), and how many matters in each area
+//            wait on THIS viewer.
+//
+// "WAITS ON YOU" IS THE DOCKET'S OWN ANSWER (task 1005056). The government port's
+// yoursByGoal(viewer) routes the docket's goal-shaped matters (blockers, criteria
+// awaiting sign-off, goal join requests) with modules/government/routing.js and
+// counts, per goal, those whose route is the viewer's — so a seated Lead, a board
+// member or an access holder sees their own dots, and the city never disagrees
+// with the docket. The port is resolved optionally (not declared in `consumes`):
+// with government switched off, an older government without the method, or seats
+// it could not read, the city falls back to the old approximation — open blockers
+// whose stored ask waits on `owner` (or that carry none), shown only to an Archon.
+//
+// MODULE BOUNDARY: reaches core only through the published doorway. The ideas,
+// blockers, government and autonomy tables are READ in SQL (a cross-table read
+// crosses the wall, a cross-module require does not — modules/ideas/CLAUDE.md);
+// the two module tables are probed with to_regclass first, so a project with
+// government or autonomy switched off answers without them rather than failing.
+
+const api = require('../../src/module-api');
+
+const log = api.logger('lifecycle');
+
+const MIN_WEEKS = 4;
+const MAX_WEEKS = 26;
+const DEFAULT_WEEKS = 10;
+const MAX_AREAS = 30;
+const MAX_IDEAS = 120;
+const ART_DISCIPLINES = Object.freeze(['artist', 'ui']);
+// modules/ideas/skill-friction.js holds the original; a module may not require a
+// sibling, so the two markers are mirrored here (an Xenos viewer never sees them).
+const SKILL_FRICTION_KIND = 'skill-friction';
+const SKILL_FRICTION_TAG = '[skill-friction]';
+const SMOKE_TITLE = '\\_\\_smoke\\_\\_%';
+
+function clampWeeks(v) {
+  const n = Number.parseInt(v, 10);
+  if (!Number.isFinite(n)) return DEFAULT_WEEKS;
+  return Math.max(MIN_WEEKS, Math.min(MAX_WEEKS, n));
+}
+
+// week index of a timestamp column against the window start ($ref), as SQL
+const wk = (col, ref) => `floor(extract(epoch FROM (${col} - ${ref}::timestamptz)) / 604800)::int`;
+
+async function tableExists(pool, name) {
+  const { rows } = await pool.query('SELECT to_regclass($1) IS NOT NULL AS ok', [`public.${name}`]);
+  return !!(rows[0] && rows[0].ok);
+}
+
+// The project's focus version when one is set, else db-versions.js
+// currentBuildingVersionId's rule (building only, newest started first, id breaks a
+// tie) — the version the roadmap and Goals already lead with.
+async function versionBeingBuilt(pool, deps) {
+  const focus = await (deps.getFocusVersionId || api.projectSettings.getFocusVersionId)().catch(() => null);
+  const { rows } = await pool.query(
+    `SELECT id, name FROM versions
+      WHERE ($1::text IS NOT NULL AND id = $1) OR ($1::text IS NULL AND status = 'building')
+      ORDER BY started_at DESC NULLS LAST, id
+      LIMIT 1`,
+    [focus],
+  );
+  return rows[0] || null;
+}
+
+// The docket's answer, held per viewer for WAITING_TTL_MS. Home is the most-loaded
+// page and the docket's routing is several reads deep, so a reload inside the
+// window costs no reads. The dots are a display count that gates nothing, so the
+// uncached-authority rule (ADR 0016) is untouched; the docket itself stays live.
+// Keyed by port so a swapped port (a test, a reload) never sees another's answers.
+const WAITING_TTL_MS = 30 * 1000;
+const WAITING_MAX = 500;
+const waitingMemo = new WeakMap();
+async function yoursByGoalHeld(gov, viewer, now) {
+  const memo = waitingMemo.get(gov) || new Map();
+  waitingMemo.set(gov, memo);
+  const key = `${viewer.id}:${String(viewer.rank || '').toLowerCase()}`;
+  const hit = memo.get(key);
+  if (hit && now - hit.at < WAITING_TTL_MS) return hit.r;
+  const r = await Promise.resolve().then(() => gov.yoursByGoal(viewer)).catch((err) => {
+    log.warn({ err: err && err.message }, 'home city: the docket could not say what waits on the viewer');
+    return null;
+  });
+  if (r && r.available === true) {
+    if (memo.size >= WAITING_MAX) memo.delete(memo.keys().next().value);
+    memo.set(key, { at: now, r });
+  }
+  return r;
+}
+
+// Per area, how many matters wait on the viewer → [{ goal_id, n }]. The docket's
+// routing through the government port when it answers; else the approximation
+// (Archon only), so Home never loses its dots to a missing or failing port.
+async function waitingOnViewer(pool, goalIds, viewer, deps) {
+  if (!viewer || viewer.id == null) return [];
+  const gov = deps.government !== undefined ? deps.government : api.resolveOptional('government');
+  if (gov && typeof gov.yoursByGoal === 'function') {
+    const r = await yoursByGoalHeld(gov, viewer, deps.now ? deps.now() : Date.now());
+    if (r && r.available === true) {
+      const areas = new Set(goalIds);
+      return Object.entries(r.goals || {})
+        .filter(([goalId, n]) => areas.has(String(goalId)) && Number(n) > 0)
+        .map(([goalId, n]) => ({ goal_id: String(goalId), n: Number(n) }));
+    }
+  }
+  if (String(viewer.rank || '').toLowerCase() !== 'archon') return [];
+  const hasAsks = await tableExists(pool, 'government_asks');
+  return (await pool.query(
+    `SELECT t.goal_id::text AS goal_id, count(DISTINCT b.id)::int AS n
+       FROM blockers b
+       JOIN task_blockers tb ON tb.blocker_id = b.id
+       JOIN tasks t ON t.id = tb.task_id
+       ${hasAsks ? `LEFT JOIN government_asks a ON a.matter_id = 'blockers:' || b.id` : ''}
+      WHERE b.status = 'open' AND t.goal_id = ANY($1::bigint[])
+        ${hasAsks ? `AND (a.matter_id IS NULL OR a.waits_on = 'owner')` : ''}
+      GROUP BY 1`,
+    [goalIds],
+  )).rows;
+}
+
+// → the raw rows, every query bounded by the window, the areas or a LIMIT.
+// The reads that do not depend on each other run together (Promise.all): the
+// window and the version first, then the areas, then everything else at once.
+async function readCity({ weeks, viewer }, deps = {}) {
+  const pool = (deps.pool && process.env.NODE_ENV === 'test') ? deps.pool : api.pool;
+  const N = clampWeeks(weeks);
+  const rank = viewer ? String(viewer.rank || '').toLowerCase() : '';
+  const isArchon = rank === 'archon';
+  const viewerId = viewer && viewer.id != null ? String(viewer.id) : null;
+  const [{ rows: [win] }, version, hasVotes, hasRunners] = await Promise.all([
+    pool.query(
+      `SELECT ((date_trunc('week', now() AT TIME ZONE 'UTC') AT TIME ZONE 'UTC') - make_interval(weeks => $1 - 1)) AS start`,
+      [N],
+    ),
+    versionBeingBuilt(pool, deps),
+    tableExists(pool, 'government_board_votes'),
+    tableExists(pool, 'autonomy_runner_heartbeat'),
+  ]);
+  const start = win.start;
+  const out = { N, start, version, areas: [], areaWeeks: [], leads: [], peopleWeeks: [], ideaCounts: [], ideas: [], gov: [], builders: [], sites: [], waiting: [] };
+
+  // VISIBILITY (ADR 0112's leak rule, as goal-graph.js applies it): a private
+  // goal the viewer is neither a member of nor an Archon over stays a tower (its
+  // counts are structure) but its title, and the titles of ideas tied to it, are
+  // dropped in shapeCity. Visibility comes from the signed-in viewer, never the query.
+  if (version) {
+    out.areas = (await pool.query(
+      `SELECT g.id::text AS goal_id, g.title,
+              (g.visibility IS DISTINCT FROM 'private'
+                 OR $2::boolean
+                 OR EXISTS (SELECT 1 FROM goal_members gm WHERE gm.goal_id = g.id AND gm.builder_id = $3::bigint)) AS visible
+         FROM goals g
+        WHERE g.version_id = $1 AND g.status = 'open' AND NOT g.is_maintenance
+        ORDER BY g.sort_order, g.id
+        LIMIT ${MAX_AREAS}`,
+      [version.id, isArchon, viewerId],
+    )).rows;
+  }
+  const goalIds = out.areas.map((a) => a.goal_id);
+  const none = Promise.resolve({ rows: [] });
+  const friction = rank === 'xenos' ? `AND i.kind <> '${SKILL_FRICTION_KIND}' AND i.title NOT LIKE '${SKILL_FRICTION_TAG}%'` : '';
+
+  const [areaWeeks, leads, peopleWeeks, ideaCounts, ideas, gov, sites, waiting] = await Promise.all([
+    goalIds.length ? pool.query(
+      `SELECT t.goal_id::text AS goal_id,
+              CASE WHEN t.shipped_at < $2 THEN -1 ELSE ${wk('t.shipped_at', '$2')} END AS wk,
+              (t.discipline = ANY($3::text[])) AS art,
+              count(*)::int AS n
+         FROM tasks t
+        WHERE t.status = 'shipped' AND t.shipped_at IS NOT NULL
+          AND t.goal_id = ANY($1::bigint[])
+          AND t.title NOT LIKE '${SMOKE_TITLE}' ESCAPE '\\'
+        GROUP BY 1, 2, 3`,
+      [goalIds, start, ART_DISCIPLINES],
+    ) : none,
+    goalIds.length ? pool.query(
+      `SELECT DISTINCT ON (goal_id, wk) goal_id, wk, shipped_by
+         FROM (SELECT t.goal_id::text AS goal_id, ${wk('t.shipped_at', '$2')} AS wk, t.shipped_by::text AS shipped_by, count(*) AS n
+                 FROM tasks t
+                WHERE t.status = 'shipped' AND t.shipped_at >= $2 AND t.shipped_by IS NOT NULL
+                  AND t.goal_id = ANY($1::bigint[])
+                GROUP BY 1, 2, 3) x
+        ORDER BY goal_id, wk, n DESC, shipped_by`,
+      [goalIds, start],
+    ) : none,
+    pool.query(
+      `SELECT t.shipped_by::text AS id, ${wk('t.shipped_at', '$1')} AS wk, (t.discipline = ANY($2::text[])) AS art, count(*)::int AS n
+         FROM tasks t
+        WHERE t.status = 'shipped' AND t.shipped_at >= $1 AND t.shipped_by IS NOT NULL
+          AND t.title NOT LIKE '${SMOKE_TITLE}' ESCAPE '\\'
+        GROUP BY 1, 2, 3`,
+      [start, ART_DISCIPLINES],
+    ),
+    pool.query(
+      `SELECT i.captured_by::text AS id, ${wk('i.captured_at', '$1')} AS wk, count(*)::int AS n
+         FROM idea_inbox i
+        WHERE i.captured_at >= $1 AND i.captured_by IS NOT NULL ${friction}
+        GROUP BY 1, 2`,
+      [start],
+    ),
+    pool.query(
+      `SELECT i.id::text AS id, i.title, i.captured_by::text AS by, ${wk('i.captured_at', '$1')} AS wk, pt.goal_id::text AS goal_id
+         FROM idea_inbox i
+         LEFT JOIN tasks pt ON pt.id = i.promoted_to_task_id
+        WHERE i.captured_at >= $1 ${friction}
+        ORDER BY i.captured_at DESC
+        LIMIT ${MAX_IDEAS}`,
+      [start],
+    ),
+    pool.query(
+      `SELECT id, wk, sum(n)::int AS n FROM (
+         ${hasVotes ? `SELECT v.voter_id::text AS id, ${wk('v.cast_at', '$1')} AS wk, count(*) AS n
+           FROM government_board_votes v WHERE v.cast_at >= $1 GROUP BY 1, 2
+         UNION ALL` : ''}
+         SELECT b.resolved_by::text AS id, ${wk('b.resolved_at', '$1')} AS wk, count(*) AS n
+           FROM blockers b WHERE b.status = 'resolved' AND b.resolved_at >= $1 AND b.resolved_by IS NOT NULL GROUP BY 1, 2
+       ) x GROUP BY 1, 2`,
+      [start],
+    ),
+    goalIds.length ? pool.query(
+      `SELECT DISTINCT ON (t.goal_id) t.goal_id::text AS goal_id, c.builder_id::text AS builder_id,
+              ${hasRunners ? `EXISTS (SELECT 1 FROM autonomy_runner_heartbeat h
+                                       WHERE h.working_task_id = t.id AND h.last_seen_at > now() - interval '15 minutes')` : 'false'} AS agent
+         FROM claims c
+         JOIN tasks t ON t.id = c.task_id
+        WHERE c.released_at IS NULL AND t.goal_id = ANY($1::bigint[])
+        ORDER BY t.goal_id, c.claimed_at DESC`,
+      [goalIds],
+    ) : none,
+    goalIds.length ? waitingOnViewer(pool, goalIds, viewer, deps) : Promise.resolve([]),
+  ]);
+  Object.assign(out, {
+    areaWeeks: areaWeeks.rows, leads: leads.rows, peopleWeeks: peopleWeeks.rows, ideaCounts: ideaCounts.rows,
+    ideas: ideas.rows, gov: gov.rows, sites: sites.rows, waiting,
+  });
+
+  const ids = new Set();
+  [out.leads.map((r) => r.shipped_by), out.peopleWeeks.map((r) => r.id), out.ideaCounts.map((r) => r.id), out.ideas.map((r) => r.by), out.gov.map((r) => r.id), out.sites.map((r) => r.builder_id)]
+    .forEach((list) => list.forEach((id) => { if (id != null) ids.add(String(id)); }));
+  if (viewerId) ids.add(viewerId);
+  if (ids.size) {
+    out.builders = (await pool.query(
+      `SELECT b.id::text AS id, b.github_login, b.display_name, b.avatar_url
+         FROM builders b
+        WHERE b.id = ANY($1::bigint[]) AND b.system_role IS NULL`,
+      [[...ids]],
+    )).rows;
+  }
+  return out;
+}
+
+// The raw rows → the response Home draws. Pure: a test feeds it rows with no
+// database. Rows outside the window (a clock skew, a bad week index) are dropped,
+// never counted at the edge.
+function shapeCity(raw, viewer) {
+  const N = raw.N;
+  const inWeek = (w) => Number.isInteger(w) && w >= 0 && w < N;
+  const zeros = () => Array(N).fill(0);
+  const start = raw.start instanceof Date ? raw.start : new Date(raw.start);
+  const weeks = Array.from({ length: N }, (_, i) => ({ start: new Date(start.getTime() + i * 7 * 864e5).toISOString().slice(0, 10) }));
+
+  const areas = raw.areas.map((a) => ({ goal_id: a.goal_id, title: a.visible === false ? null : a.title, base_build: 0, base_art: 0, build: zeros(), art: zeros(), lead: Array(N).fill(null) }));
+  const byGoal = new Map(areas.map((a) => [a.goal_id, a]));
+  const hiddenGoals = new Set(raw.areas.filter((a) => a.visible === false).map((a) => String(a.goal_id)));
+  raw.areaWeeks.forEach((r) => {
+    const a = byGoal.get(String(r.goal_id)); if (!a) return;
+    const n = Number(r.n) || 0;
+    if (r.wk === -1) { if (r.art) a.base_art += n; else a.base_build += n; return; }
+    if (inWeek(r.wk)) (r.art ? a.art : a.build)[r.wk] += n;
+  });
+  raw.leads.forEach((r) => { const a = byGoal.get(String(r.goal_id)); if (a && inWeek(r.wk)) a.lead[r.wk] = String(r.shipped_by); });
+
+  const known = new Map(raw.builders.map((b) => [String(b.id), b]));
+  const people = new Map();
+  const person = (id) => {
+    const key = String(id);
+    if (!known.has(key)) return null; // a machine principal or a deleted builder is never drawn
+    if (!people.has(key)) {
+      const b = known.get(key);
+      people.set(key, { id: key, login: b.github_login || '', name: b.display_name || b.github_login || 'Builder', avatar_url: b.avatar_url || null, agent: false, build: zeros(), art: zeros(), idea: zeros(), gov: zeros() });
+    }
+    return people.get(key);
+  };
+  raw.peopleWeeks.forEach((r) => { const p = person(r.id); if (p && inWeek(r.wk)) (r.art ? p.art : p.build)[r.wk] += Number(r.n) || 0; });
+  raw.ideaCounts.forEach((r) => { const p = person(r.id); if (p && inWeek(r.wk)) p.idea[r.wk] += Number(r.n) || 0; });
+  raw.gov.forEach((r) => { const p = person(r.id); if (p && inWeek(r.wk)) p.gov[r.wk] += Number(r.n) || 0; });
+  if (viewer && viewer.id != null) person(viewer.id);
+  areas.forEach((a) => { a.lead = a.lead.map((id) => (id && known.has(id) ? id : null)); });
+
+  const ideas = raw.ideas.filter((r) => inWeek(r.wk)).map((r) => ({ id: String(r.id), week: r.wk, by: r.by && known.has(String(r.by)) ? String(r.by) : null, title: hiddenGoals.has(String(r.goal_id)) ? null : (r.title || ''), goal_id: r.goal_id && byGoal.has(String(r.goal_id)) ? String(r.goal_id) : null }));
+  const sites = raw.sites.filter((s) => byGoal.has(String(s.goal_id)) && known.has(String(s.builder_id)))
+    .map((s) => { person(s.builder_id); return { goal_id: String(s.goal_id), builder_id: String(s.builder_id), agent: !!s.agent }; });
+  const waiting = raw.waiting.filter((w) => byGoal.has(String(w.goal_id)) && Number(w.n) > 0).map((w) => ({ goal_id: String(w.goal_id), count: Number(w.n) }));
+
+  return {
+    viewer: viewer && viewer.id != null ? { id: String(viewer.id) } : null,
+    version: raw.version ? { id: raw.version.id, name: raw.version.name || raw.version.id } : null,
+    weeks, areas, people: [...people.values()], ideas, now: { sites, waiting },
+  };
+}
+
+// The GET /home/city handler, injectable so a test drives it with no express.
+function homeCityHandler({ log, read = readCity } = {}) {
+  return async function homeCityRoute(req, res) {
+    try {
+      const viewer = req.builder ? { id: req.builder.id, rank: req.builder.rank } : null;
+      const raw = await read({ weeks: req.query && req.query.weeks, viewer });
+      res.set('Cache-Control', 'private, max-age=60');
+      res.json(shapeCity(raw, viewer));
+    } catch (err) {
+      if (log) log.error('GET /home/city', err);
+      res.fail('home_city_failed', { status: 500, message: 'internal error' });
+    }
+  };
+}
+
+module.exports = { WAITING_TTL_MS, DEFAULT_WEEKS, MAX_AREAS, MAX_IDEAS, clampWeeks, readCity, shapeCity, homeCityHandler };

package/modules/lifecycle/module.json

@@ -35,6 +35,7 @@
       "sky",
       "goal-task-relevance",
       "moving",
+      "home-city",
       "task-votes",
       "notes"
     ],

package/modules/lifecycle/routes/home-city.js

@@ -0,0 +1,29 @@
+'use strict';
+
+// modules/lifecycle/routes/home-city.js — GET /home/city, the weekly summary behind
+// Home's project city (task 1005054).
+//
+// WHY ITS OWN ROUTE FILE. routes/tasks.js and routes/goals.js sit at the 1,500-line
+// ratchet, and the path is top-level `/home/city`, never under `/tasks` or `/goals`,
+// whose `/:id` routes would swallow a literal segment (the `/inbox/awaiting-nod`
+// trap; route-shadow-guard). The reads and the handler live in ../home-city.js so a
+// test drives them with no express and no database (routes/moving.js precedent).
+//
+// MODULE BOUNDARY: reaches core only through the published doorway
+// `../../../src/module-api`; `../home-city` is this module's own read.
+
+const express = require('express');
+const api = require('../../../src/module-api');
+const homeCity = require('../home-city');
+
+const log = api.logger('lifecycle');
+
+module.exports = function buildHomeCityRouter() {
+  const router = express.Router();
+  // rank: any-builder — GET /home/city, the counts Home's city draws. Every number in
+  // it is a count of rows a signed-in builder can already list (shipped tasks, ideas,
+  // votes, open claims); the per-area "waits on you" half is the docket's routing for
+  // this viewer (task 1005056), computed inside the read. Nothing here is writable.
+  router.get('/home/city', api.requireBuilder, homeCity.homeCityHandler({ log }));
+  return router;
+};

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@bongos/core",
-  "version": "1.24.29",
+  "version": "1.24.30",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.24.29",
+      "version": "1.24.30",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "express": "^4.21.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.24.29",
+  "version": "1.24.30",
   "description": "Cloud Bongos — the AI-first build platform core (GDS + platform surfaces + module system), installed as a versioned dependency (ADR 0108).",
   "license": "AGPL-3.0-or-later",
   "main": "src/platform-server.js",

package/release-notes.json

@@ -11107,5 +11107,15 @@
       "id": "1005044",
       "text": "Your agent settings now live in one place, My agents: Settings shows a short link there instead of repeating them, and every old Settings link to them opens My agents."
     }
+  ],
+  "1.24.30": [
+    {
+      "id": "1005056",
+      "text": "The \"waiting on you\" dots on Home's project city now show every person the matters actually wait on, not just the owner."
+    },
+    {
+      "id": "1005054",
+      "text": "Home now shows the whole project as a living city: towers that grow as work ships, the people building them, and a slider to replay the last ten weeks."
+    }
   ]
 }

package/src/module-api.js

@@ -81,7 +81,7 @@ const { sleep } = require('./sleep');
 // MAJOR (see allowBoxScope below): passes the request through untouched.
 function deprecatedNoopMiddleware(_req, _res, next) { next(); }
 
-const CORE_VERSION = '1.24.29'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.24.30'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('discord'); log.info('mounted');

package/tests/claim_from_task_and_home.mjs

@@ -86,16 +86,10 @@ await test('task.html\'s cache-bust moved for task.js', () => {
   assert.match(taskHtml, /task\.js\?v=2026-09-28-taskclaim/);
 });
 
-// == Home's "Next up" rows ====================================================
-
-await test('hall-render.js constructs the shared claim action for Home\'s Next-up row', () => {
-  // Lives in hall-render.js, not builders.js: builders.js sits at the
-  // 1,500-line fitness ratchet (hall-ui/CLAUDE.md — growth goes in the
-  // lib/renderer, not the page).
-  assert.match(hallRenderJs, /function wireNextUpClaim\(\)/);
-  assert.match(hallRenderJs, /makeClaimAction\(\{/);
-  assert.match(hallRenderJs, /window\.OTBClaimAction/);
-});
+// == Home ====================================================================
+// task 1005054: Home's "Next up" rows left with the "Your work" card (the project
+// city took its place), so Home carries no claim button and no claim action.
+// Claiming lives on the task page above and on the Work board.
 
 await test('the shared postJSON carries { status, data } — the contract claim-action.js reads', () => {
   const m = buildersJs.match(/async function postJSON\(path, body\) \{[\s\S]*?\n {2}\}/);
@@ -103,46 +97,17 @@ await test('the shared postJSON carries { status, data } — the contract claim-
   assert.match(m[0], /err\.data\s*=/, 'postJSON must set err.data or every refusal here falls through to the generic line');
 });
 
-await test('each Next-up row renders a Claim button carrying its task id', () => {
-  const m = buildersJs.match(/list\.innerHTML = rows\.map\(\(t\) => \{[\s\S]*?\n {6}\}\)\.join\(''\);/);
-  assert.ok(m, 'loadNextUp row template not found');
-  assert.match(m[0], /class="[^"]*next-up__claim[^"]*"/);
-  assert.match(m[0], /data-task-id="\$\{escapeHtml\(String\(t\.id\)\)\}"/);
-});
-
-await test('the Next-up Claim button routes through claimAction.claim, not a raw POST', () => {
-  const m = hallRenderJs.match(/function wireNextUpClaim\(\) \{[\s\S]*?\n {2}\}/);
-  assert.ok(m, 'wireNextUpClaim not found');
-  assert.match(m[0], /\$\('#home-next-list'\)\?\.addEventListener\('click'/);
-  assert.match(m[0], /claimAction\.claim\(taskId\)/);
-});
-
-await test('builders.js wires the Next-up claim action rather than hand-rolling it', () => {
+await test('Home hand-rolls no claim: no POST /claims, no leftover Next-up wiring', () => {
   assert.doesNotMatch(buildersJs, /postJSON\(\s*`\$\{API\}\/claims/);
-  assert.match(buildersJs, /wireNextUpClaim\(\)/, 'builders.js must call the renderer\'s wiring');
+  assert.doesNotMatch(buildersJs + hallRenderJs, /wireNextUpClaim|home-next-list|next-up__claim/);
+  assert.doesNotMatch(indexHtml, /claim-action\.js/, 'Home has no claim button, so it loads no claim action');
 });
 
-await test('the claim wiring landed in the renderer, not back over the 1,500-line ratchet', () => {
-  // Not a second copy of fitness.js's own gate (scripts/bongos/fitness-ratchets.js)
-  // — this is the reason wireNextUpClaim moved to hall-render.js in the first
-  // place (see its own comment): a regression here explains WHY that file grew,
-  // not just THAT some file grew.
+await test('the page halves stay under the 1,500-line ratchet', () => {
   for (const [name, src] of [['builders.js', buildersJs], ['hall-render.js', hallRenderJs]]) {
     const lines = src.split('\n').length;
     assert.ok(lines <= 1500, `${name} is ${lines} lines — over the fitness ratchet`);
   }
 });
 
-await test('index.html loads claim-action.js before builders.js', () => {
-  const shared = indexHtml.indexOf('claim-action.js');
-  const after = indexHtml.indexOf('builders.js?v=');
-  assert.ok(shared > -1, 'index.html must load claim-action.js');
-  assert.ok(after > shared, 'builders.js must load AFTER claim-action.js');
-});
-
-await test('index.html\'s cache-bust moved for builders.js', () => {
-  assert.doesNotMatch(indexHtml, /builders\.js\?v=2026-06-27-r75/, 'the old bust is still there');
-  assert.match(indexHtml, /builders\.js\?v=2026-09-28-nextupclaim/);
-});
-
 summary();

package/tests/hall_board_world.mjs

@@ -303,13 +303,14 @@ test('the system notices are inbox LINES, first in the card, and counted by its
   }
 });
 
-test('the greeting reads /me and the public progress (for the version tab), and builders.js feeds both', () => {
-  assert.match(buildersJs, /getJSON\(`\$\{API\}\/public\/progress`\)/, 'Home fetches the public progress once');
+test('the greeting reads /me only; the version tab and its progress read left Home', () => {
+  // task 1005054: the version tab left with the stats strip, so Home no longer
+  // fetches /public/progress; the project city (home-city.js) draws how far it is.
+  assert.doesNotMatch(buildersJs, /\/public\/progress/, 'Home no longer fetches the public progress');
   assert.doesNotMatch(buildersJs, /getJSON\(`\$\{API\}\/tasks\/claimable`/,
     'no unbounded claimable fetch on Home');
-  assert.match(buildersJs, /get lastProgressState\(\)/, 'the renderer reads progress through a getter, so it cannot freeze at boot');
-  assert.doesNotMatch(buildersJs, /lastClaimableCount/, 'the greeting no longer needs the claimable count (task 1004780)');
-  assert.equal((buildersJs.match(/renderGreeting\(\)/g) || []).length, 2, 'rendered after /me and after progress — each as it lands');
+  assert.doesNotMatch(buildersJs, /lastProgressState|lastClaimableCount/, 'the greeting needs neither the progress nor the claimable count');
+  assert.equal((buildersJs.match(/renderGreeting\(\)/g) || []).length, 1, 'rendered once, as soon as /me answers');
 });
 
 // Boot hall-render.js against a stub DOM and a ctx of getters (the way
@@ -368,16 +369,13 @@ const ME = {
 const LEADERBOARD = [{ github_login: 'a', total_credits: 20000 }, { github_login: 'percy', total_credits: 14441 }, { github_login: 'b', total_credits: 3 }, { github_login: 'c', total_credits: 1 }];
 const PROGRESS = { progress: [{ version_id: 'BONGOS-V1', status: 'building', total_count: 605, percent_complete: 75 }, { version_id: 'V2', status: 'planning', total_count: 9000, percent_complete: 0 }] };
 
-test('RUN: the greeting names the builder, and the version tab carries how far the version is', () => {
+test('RUN: the greeting names the builder, and writes nothing else', () => {
+  // task 1005054: the version tab left Home with the stats strip; how far the
+  // project has come is the city under the greeting (home-city.js).
   const { api, el } = bootHallRender({ me: ME, progress: PROGRESS });
   api.renderGreeting();
   assert.match(el('hall-h1').textContent, /^Good (morning|afternoon|evening), Percy Jackson$/);
-  assert.equal(el('home-version-name').textContent, 'BONGOS-V1', 'the building version, not the bigger planning one');
-  assert.equal(el('home-version-pct').textContent, '75% complete');
-  assert.equal(el('home-version').hidden, false);
-  const none = bootHallRender({ me: ME });
-  none.api.renderGreeting();
-  assert.equal(none.el('home-version').hidden, true, 'no progress yet: no tab');
+  assert.equal(el('home-version').textContent || '', '', 'no version tab is drawn');
 });
 
 test('RUN: the Standing card carries the three facts, the place as "2nd of 4", and no banner', () => {

package/tests/hall_home_ships_bounded.mjs

@@ -122,14 +122,15 @@ function loadRender({ view = 'home' } = {}) {
 
 const homePage = (total, firstId = 3000) => ({ ships: [ship(firstId), ship(firstId - 1)], total });
 
-test('Home: the count and the five-row table come from the small page, with no ledger fetch', async () => {
+test('Home: the Standing chip\'s count comes from the small page, with no ledger fetch', async () => {
+  // task 1005054: the Shipped tile and the five-row table left Home with the stats
+  // strip and "Your work"; the small page still feeds the Standing chip's count.
   const { r, el, fetched } = loadRender();
   assert.equal(r.HOME_SHIPS_LIMIT, 5);
   r.setRecentShips(homePage(3000));
   await new Promise((done) => setTimeout(done, 0));
   assert.deepEqual(fetched, [], 'Home never asks for the full history');
-  assert.equal(el('stat-shipped').textContent, '3000', 'the Shipped tile shows the server total, not rows held');
-  assert.match(el('home-recent-table tbody').innerHTML, /#3000[\s\S]*#2999/);
+  assert.equal(el('standing-shipped').textContent, '3000', 'the chip shows the server total, not rows held');
   assert.equal(el('recent-ships tbody').innerHTML, '', 'the ledger is untouched until its view opens');
 });
 

package/tests/home_bounded_reads.mjs

@@ -28,7 +28,6 @@ const require = createRequire(import.meta.url);
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const read = (rel) => fs.readFileSync(path.join(ROOT, rel), 'utf8');
 const BUILDERS_JS = read('modules/hall-ui/public/builders.js');
-const WIDGETS_JS = read('modules/hall-ui/public/hall-widgets.js');
 const ROUTE = read('modules/lifecycle/routes/tasks.js');
 const DB_TASKS = read('modules/lifecycle/db-tasks.js');
 
@@ -48,26 +47,24 @@ await test('no Home read downloads a feed and slices it in the browser', () => {
   // DISPLAYED is fine; narrowing what was FETCHED is the bug, and the two look
   // identical at the call site — which is why this is a test and not a code review.
   const src = noComments(BUILDERS_JS);
-  for (const fn of ['loadNextUp', 'loadTriageInbox']) {
-    const from = src.indexOf(`function ${fn}(`);
-    assert.ok(from > 0, `${fn} must exist`);
-    const body = src.slice(from, src.indexOf('\n  }\n', from));
-    const name = fn;
-    const url = body.match(/\$\{API\}\/[^`'"]+/);
-    assert.ok(url, `${name} must issue a request`);
-    assert.match(url[0], /[?&]limit=\d+/, `${name} must ask the server for its page size`);
-  }
+  const from = src.indexOf('function loadTriageInbox(');
+  assert.ok(from > 0, 'loadTriageInbox must exist');
+  const body = src.slice(from, src.indexOf('\n  }\n', from));
+  const url = body.match(/\$\{API\}\/[^`'"]+/);
+  assert.ok(url, 'loadTriageInbox must issue a request');
+  assert.match(url[0], /[?&]limit=\d+/, 'loadTriageInbox must ask the server for its page size');
 });
 
-await test('the two cards ask for exactly the rows they draw', () => {
-  assert.match(BUILDERS_JS, /\$\{API\}\/tasks\/claimable\?limit=5/, 'Next up draws five rows, level with Recently shipped');
-  assert.match(BUILDERS_JS, /\$\{API\}\/inbox\?limit=5/, 'the triage card draws five');
-  // …and no longer re-slices what came back.
-  const src = noComments(BUILDERS_JS);
-  const from = src.indexOf('function loadNextUp(');
-  const body = src.slice(from, src.indexOf('\n  }\n', from));
-  assert.ok(body.length > 0, 'loadNextUp body found');
-  assert.doesNotMatch(body, /\.slice\(0,\s*2\)/, 'the client-side slice is gone');
+await test('the project city asks for ONE weekly summary, and the Next-up read left with its card', () => {
+  // task 1005054: Home's body is the project city. It draws from one bounded read
+  // the server counts per week (modules/lifecycle/home-city.js), never a task feed;
+  // the Next-up card and its GET /tasks/claimable read left Home with "Your work".
+  const CITY_JS = noComments(read('modules/hall-ui/public/home-city.js'));
+  const reads = [...CITY_JS.matchAll(/api\.request\('GET',\s*`([^`]+)`/g)].map((m) => m[1]);
+  assert.deepEqual(reads, ['${API}/home/city?weeks=${WEEKS}'], 'one read, asked for its window');
+  assert.doesNotMatch(CITY_JS, /\/tasks|claimable|recent-ships/, 'the city never downloads a feed');
+  assert.doesNotMatch(noComments(BUILDERS_JS), /function loadNextUp\(|tasks\/claimable/, 'Home no longer reads the claimable feed');
+  assert.match(BUILDERS_JS, /\$\{API\}\/inbox\?limit=5/, 'the triage card still draws five');
 });
 
 // ---------------------------------------------------------------------------
@@ -153,16 +150,4 @@ await test('the limit is applied AFTER the JS post-filters, not as a SQL LIMIT',
   assert.match(routeBody, /feed\.slice\(0, claimLimit\)/, 'the slice happens on the finished feed');
 });
 
-// ---------------------------------------------------------------------------
-// 4. what the reader sees
-// ---------------------------------------------------------------------------
-
-await test('the foot names the queue the two rows came off', () => {
-  assert.match(WIDGETS_JS, /id="home-next-foot"/, 'the link has an id to write into');
-  assert.match(BUILDERS_JS, /See all \$\{fmtNum\(total\)\} ready work/);
-  // Silent rather than wrong when the count is missing or not larger than what is
-  // shown: "See all 2" under two rows is noise, and a guessed number is worse.
-  assert.match(BUILDERS_JS, /Number\.isFinite\(total\) && total > rows\.length/);
-});
-
 summary();