@bongos/core 1.25.2 → 1.25.4

package/modules/onboarding/genesis-home.js

@@ -156,6 +156,8 @@ function shapeGenesis({ mode, plan, tasks = {}, board = {}, stageAt = {} }) {
     const idx = fm.STAGES.indexOf(key);
     const list = (tasks[key] || []).map((t) => ({ ...t, finished: FINISHED.includes(t.status) }));
     const b = board[key] || null;
+    const allFinished = list.length > 0 && list.every((t) => t.finished);
+    const onBoard = !!(b && (b.state === 'sitting' || b.state === 'passed'));
     const days = plan && plan.days && plan.days[key] ? plan.days[key] : info.days;
     // A demo's stage is minutes long (task 1004506); its due time is counted in them.
     const minutes = plan && plan.minutes && plan.minutes[key] ? plan.minutes[key] : null;
@@ -177,6 +179,9 @@ function shapeGenesis({ mode, plan, tasks = {}, board = {}, stageAt = {} }) {
       tasks: list,
       finished: list.filter((t) => t.finished).length,
       total: list.length,
+      // task 1005199: this stage (the current one or any later one) can be put to
+      // the Board Room now — its tasks are all finished and it is not already there.
+      can_close: at >= 1 && idx >= at && allFinished && !onBoard,
       board: b ? {
         state: b.state, item_id: b.item_id || null, needs: b.needs || null,
         one_vote_decides: !!b.one_vote_decides, waiting_on: b.waiting_on || [],
@@ -349,7 +354,15 @@ async function closeStage(stageKey, builderId, deps = {}) {
   const s = seams(deps);
   const mode = await reconcile(s);
   if (!mode) return { ok: false, reason: 'not_founding' };
-  if (mode.stage !== stageKey) return { ok: false, reason: 'not_current_stage', stage: mode.stage };
+  // task 1005199: any stage at or AFTER the current one may be put up, so every
+  // finished stage can sit in the Board Room at once. Order is kept by reconcile, not
+  // here: the project only moves past a stage whose own sitting passed, so a later
+  // stage's pass waits for the earlier ones. A stage already behind, or the decide
+  // pre-stage, is still refused.
+  if (!PROPER.includes(stageKey)) return { ok: false, reason: 'unknown_stage' };
+  if (!PROPER.includes(mode.stage) || fm.STAGES.indexOf(stageKey) < fm.STAGES.indexOf(mode.stage)) {
+    return { ok: false, reason: 'not_current_stage', stage: mode.stage };
+  }
   const all = s.lifecycle && typeof s.lifecycle.genesisTasks === 'function' ? await s.lifecycle.genesisTasks() : {};
   const list = all[stageKey] || [];
   const taskIds = list.map((t) => t.id);
@@ -357,9 +370,13 @@ async function closeStage(stageKey, builderId, deps = {}) {
   const nextOf = (key) => (key === 'legislation' ? null : fm.STAGES[fm.STAGES.indexOf(key) + 1]);
   const closedAnswer = async (itemId, confirm) => {
     const after = await reconcile(s);
+    const at = after && after.stage;
     return {
       ok: true, closed: true, stage: stageKey,
-      next_stage: stageKey === 'legislation' ? null : (after && after.stage) || nextOf(stageKey),
+      next_stage: stageKey === 'legislation' && at === 'legislation' ? null : at || nextOf(stageKey),
+      // task 1005199: a later stage passed while an earlier one is still open, so
+      // the project stays at the earlier stage until that one passes too.
+      waits_for_earlier: !!(at && fm.STAGES.indexOf(at) < fm.STAGES.indexOf(stageKey)),
       item_id: itemId, confirm,
     };
   };
@@ -379,6 +396,9 @@ async function closeStage(stageKey, builderId, deps = {}) {
     return sittingOpen(stageKey, r.item ? String(r.item.id) : null, !r.opened, board[stageKey] || null, builderId);
   }
   if (!list.length || !list.every((t) => FINISHED.includes(t.status))) return { ok: false, reason: 'stage_tasks_unfinished' };
+  // With no Board Room there is no sitting to hold a later stage, so only the
+  // current one can be closed here; a later one waits its turn.
+  if (stageKey !== mode.stage) return { ok: false, reason: 'not_current_stage', stage: mode.stage };
   if (stageKey !== 'legislation') {
     await fm.setFoundingMode({ stage: nextOf(stageKey) }, builderId, modeDeps(s));
   }
@@ -452,9 +472,44 @@ async function onStagePassed(deps = {}) {
   try { await reconcile(seams(deps)); } catch (_) { /* recovered on the next read */ }
 }
 
+// putFinishedStages — shipping a stage puts it in the Board Room by itself (task
+// 1005199). Every stage at or after the current one whose tasks are all finished and
+// that has NEVER been put to the board is opened as a sitting, with nobody's vote cast:
+// the founder still says yes, but no longer has to press "close" first. A stage the
+// board sent back is left for the founder to put up again on purpose. Opening is the
+// government port's own gate (finished tasks, one sitting per stage), so a race with a
+// manual close opens one sitting, not two. Returns the stage keys it put up.
+async function putFinishedStages(deps = {}) {
+  const s = seams(deps);
+  const gov = s.government;
+  if (!gov || typeof gov.openGenesisStageClose !== 'function') return [];
+  const mode = await reconcile(s);
+  if (!mode || !PROPER.includes(mode.stage)) return [];
+  const all = s.lifecycle && typeof s.lifecycle.genesisTasks === 'function' ? await s.lifecycle.genesisTasks() : {};
+  const board = await boardByStage(gov);
+  const put = [];
+  for (const key of PROPER.slice(PROPER.indexOf(mode.stage))) {
+    const list = all[key] || [];
+    if (!list.length || !list.every((t) => FINISHED.includes(t.status))) continue;
+    const st = board[key] && board[key].state;
+    if (st && st !== 'not_put') continue;
+    const r = await gov.openGenesisStageClose({ stageKey: key, taskIds: list.map((t) => t.id), openedBy: null });
+    if (r && r.opened) put.push(key);
+  }
+  return put;
+}
+
+// onTaskShipped — the `task.shipped` listener. Any ship may be the last task of a
+// stage; on a project that is not founding this costs the one genesis.enabled read.
+// Best-effort: the founder's own close button is still there if this misses.
+async function onTaskShipped(deps = {}) {
+  try { return await putFinishedStages(deps); } catch (_) { return []; }
+}
+
 module.exports = {
   PLAN_KEY, STAGE_INFO, PROPER, DEMO_PEOPLE, DEMO_HOURS, intIn, parsePlan, shapeGenesis, demoMinutes, demoPlan,
   readGenesis, startFounding, savePlan, applyGovernmentChoice, closeStage, comeAlive, skipGenesis, onStagePassed,
+  putFinishedStages, onTaskShipped,
   // the founding-mode deps this file reads the mode with, for founding-birth.js (task 1004506)
   modeDepsFor: (deps) => modeDeps(seams(deps)),
 };

package/modules/onboarding/routes/onboarding.js

@@ -134,6 +134,8 @@ function mountGenesisRoutes(router) {
   if (!genesisListening && typeof api.on === 'function') {
     genesisListening = true;
     api.on('board.genesis_stage.passed', () => genesis.onStagePassed());
+    // task 1005199: a ship that finishes a stage puts that stage in the Board Room.
+    api.on('task.shipped', () => genesis.onTaskShipped());
   }
   const owns = api.requirePermission('project.settings.manage');
   const refuse = (res, r) => res.status(GENESIS_REFUSALS[r.reason] || 409).json({

package/modules/ui-design/kit/fixtures/founding-genesis-votes.json

@@ -0,0 +1,193 @@
+{
+  "_": "Genesis with several stages in the Board Room at once (task 1005199): scope, strategize and charter sitting on the founder, legalize finished and not yet put up, legislation in progress.",
+  "genesis": {
+    "stage": "scope",
+    "stage_number": 1,
+    "stage_count": 5,
+    "day": 2,
+    "deciding": false,
+    "plan": {
+      "days": {
+        "scope": 7,
+        "strategize": 7,
+        "charter": 4,
+        "legalize": 7,
+        "legislation": 3
+      },
+      "passes": 1,
+      "advisors": "none",
+      "government": "monarchy",
+      "expected_builders": 1,
+      "existing": false
+    },
+    "demo": null,
+    "stages": [
+      {
+        "key": "scope",
+        "number": 1,
+        "label": "Scope",
+        "life": "primordial sea",
+        "plate": "r5-life-1-primordial-sea",
+        "done_when": "The scope is written: what you are making, for whom, and what is left out.",
+        "wakes": [
+          "goals",
+          "goal-map"
+        ],
+        "days": 7,
+        "minutes": null,
+        "due": "2026-11-17T09:00:00.000Z",
+        "state": "now",
+        "tasks": [
+          {
+            "id": "2001",
+            "title": "Scope: write it down",
+            "status": "shipped",
+            "finished": true
+          }
+        ],
+        "finished": 1,
+        "total": 1,
+        "can_close": false,
+        "board": {
+          "state": "sitting",
+          "item_id": "41",
+          "needs": "One yes decides: the first member to say yes closes it.",
+          "one_vote_decides": true,
+          "waiting_on": [
+            {
+              "builder_id": "1",
+              "display_name": "Founder"
+            }
+          ]
+        }
+      },
+      {
+        "key": "strategize",
+        "number": 2,
+        "label": "Strategize",
+        "life": "first cells",
+        "plate": "r5-life-2-first-cells",
+        "done_when": "The strategy is written out, or the one you have is linked.",
+        "wakes": [
+          "work"
+        ],
+        "days": 7,
+        "minutes": null,
+        "due": null,
+        "state": "later",
+        "tasks": [
+          {
+            "id": "2002",
+            "title": "Strategize: write it down",
+            "status": "shipped",
+            "finished": true
+          }
+        ],
+        "finished": 1,
+        "total": 1,
+        "can_close": false,
+        "board": {
+          "state": "sitting",
+          "item_id": "42",
+          "needs": "One yes decides: the first member to say yes closes it.",
+          "one_vote_decides": true,
+          "waiting_on": [
+            {
+              "builder_id": "1",
+              "display_name": "Founder"
+            }
+          ]
+        }
+      },
+      {
+        "key": "charter",
+        "number": 3,
+        "label": "Charter",
+        "life": "the genome",
+        "plate": "r5-life-3-genome",
+        "done_when": "The starting government is chosen and the bylaws are written.",
+        "wakes": [],
+        "days": 4,
+        "minutes": null,
+        "due": null,
+        "state": "later",
+        "tasks": [
+          {
+            "id": "2003",
+            "title": "Charter: write it down",
+            "status": "shipped",
+            "finished": true
+          }
+        ],
+        "finished": 1,
+        "total": 1,
+        "can_close": false,
+        "board": {
+          "state": "sitting",
+          "item_id": "43",
+          "needs": "One yes decides: the first member to say yes closes it.",
+          "one_vote_decides": true,
+          "waiting_on": [
+            {
+              "builder_id": "1",
+              "display_name": "Founder"
+            }
+          ]
+        }
+      },
+      {
+        "key": "legalize",
+        "number": 4,
+        "label": "Legalize",
+        "life": "the membrane",
+        "plate": "r5-life-4-membrane",
+        "done_when": "Rewards are decided, and who can be paid.",
+        "wakes": [],
+        "days": 7,
+        "minutes": null,
+        "due": null,
+        "state": "later",
+        "tasks": [
+          {
+            "id": "2004",
+            "title": "Legalize: write it down",
+            "status": "shipped",
+            "finished": true
+          }
+        ],
+        "finished": 1,
+        "total": 1,
+        "can_close": true,
+        "board": null
+      },
+      {
+        "key": "legislation",
+        "number": 5,
+        "label": "Legislation",
+        "life": "the nervous system",
+        "plate": "r5-life-5-nervous-system",
+        "done_when": "The voting rules are set: who votes, and how many must agree.",
+        "wakes": [],
+        "days": 3,
+        "minutes": null,
+        "due": null,
+        "state": "later",
+        "tasks": [
+          {
+            "id": "2005",
+            "title": "Legislation: write it down",
+            "status": "active",
+            "finished": false
+          }
+        ],
+        "finished": 0,
+        "total": 1,
+        "can_close": false,
+        "board": null
+      }
+    ],
+    "can_close": false,
+    "can_come_alive": false
+  },
+  "viewer_id": "1"
+}

package/modules/ui-design/kit/fixtures/me-founding-demo.json

@@ -17,7 +17,6 @@
       "goals": "scope",
       "goal-map": "scope",
       "work": "strategize",
-      "board-room": "charter",
       "economy": "legalize",
       "ranks": "legislation",
       "collab": "alive",

package/modules/ui-design/kit/fixtures/me-founding.json

@@ -14,7 +14,6 @@
     "day": 9,
     "asleep": {
       "work": "strategize",
-      "board-room": "charter",
       "economy": "legalize",
       "ranks": "legislation",
       "collab": "alive",

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.25.2",
+  "version": "1.25.4",
   "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

@@ -11706,5 +11706,17 @@
       "id": "1005248",
       "text": "In game mode, no two buttons on the visor share a hotkey any more, and Options now sits only inside the Actions menu with its own key."
     }
+  ],
+  "1.25.3": [
+    {
+      "id": "1005199",
+      "text": "Founding a project is faster: each finished stage goes to the Board Room by itself, every stage can be voted on at once with one \"vote yes on all\" button, and the Board Room no longer looks locked during genesis."
+    }
+  ],
+  "1.25.4": [
+    {
+      "id": "1005249",
+      "text": "Your details now sit on your character at the bottom left of the game: hover to see them, click to open your full profile without leaving the scene. The old profile card at the top right is gone."
+    }
   ]
 }

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

@@ -38,22 +38,32 @@ test('an unknown stage fails CLOSED — OFF, never a hall stuck half-asleep', ()
   assert.equal(fm.shapeFoundingMode({ active: 'true', stage: 'launch' }), null);
 });
 
-test('active with no stage yet is the decide pre-stage, and every room sleeps', () => {
+test('active with no stage yet is the decide pre-stage, and every room but the Board Room sleeps', () => {
   const f = fm.shapeFoundingMode({ active: 'true' });
   assert.equal(f.stage, 'decide');
   assert.equal(f.stage_number, 0);
   assert.equal(f.stage_count, 5);
   // task 1005051: Roadmap folded into Goals; scope wakes Goals and its map.
-  for (const id of ['goals', 'goal-map', 'work', 'board-room', 'collab', 'roster']) {
+  for (const id of ['goals', 'goal-map', 'work', 'collab', 'roster']) {
     assert.ok(id in f.asleep, `${id} sleeps while deciding`);
   }
 });
 
+// task 1005199: every stage, from scope on, is closed by a vote in the Board Room, so
+// the room must never read as locked while genesis has a ballot in it.
+test('the Board Room is awake at every stage of genesis', () => {
+  for (const stage of fm.STAGES) {
+    const f = fm.shapeFoundingMode({ active: 'true', stage });
+    assert.ok(!('board-room' in f.asleep), `board-room is awake at ${stage}`);
+  }
+  assert.ok(!Object.values(fm.WAKES).some((ids) => ids.includes('board-room')), 'no stage wakes it, because it never sleeps');
+});
+
 test('a room wakes once the stage that wakes it is behind', () => {
   const f = fm.shapeFoundingMode({ active: 'true', stage: 'charter' });
   for (const id of ['goals', 'goal-map', 'work']) assert.ok(!(id in f.asleep), `${id} woke`);
   assert.ok(!('roadmap' in f.asleep), 'the folded Roadmap is no room to wake');
-  assert.equal(f.asleep['board-room'], 'charter');
+  assert.ok(!('board-room' in f.asleep), 'the Board Room never sleeps (task 1005199)');
   // task 1005046: Economy and Ranks were the rooms legalize and legislation woke;
   // they are Primer chapters now, and the Primer never sleeps.
   assert.ok(!('economy' in f.asleep) && !('ranks' in f.asleep), 'no retired Docs page is put to sleep');

package/tests/genesis_home.mjs

@@ -249,13 +249,65 @@ test('the owner can skip genesis from any stage: no sitting, hall opens, recorde
   assert.equal(await gh.readGenesis(mid.deps()), null);
 });
 
-test('only the stage in progress can be put to the board', async () => {
+test('a later stage can be put to the board once finished; a stage behind cannot (task 1005199)', async () => {
   const w = world();
   await gh.startFounding(1, w.deps());
   await gh.savePlan({}, 1, w.deps());
+  assert.equal((await gh.closeStage('charter', 1, w.deps())).reason, 'stage_tasks_unfinished', 'the finished-tasks gate still holds');
+  w.finish('charter');
   const r = await gh.closeStage('charter', 1, w.deps());
-  assert.equal(r.reason, 'not_current_stage');
-  assert.equal(w.opened.length, 0);
+  assert.equal(r.reason, 'sitting_open', 'charter sits while the project is still at scope');
+  assert.deepEqual(w.opened.at(-1).stageKey, 'charter');
+  assert.equal((await gh.readGenesis(w.deps())).stage, 'scope');
+  w.finish('scope'); w.pass('scope'); await gh.onStagePassed(w.deps());
+  assert.equal((await gh.closeStage('scope', 1, w.deps())).reason, 'not_current_stage', 'a stage behind is refused');
+  assert.equal((await gh.closeStage('decide', 1, w.deps())).reason, 'unknown_stage');
+});
+
+test('every finished stage sits at once, and they pass in order (task 1005199)', async () => {
+  const w = world();
+  await gh.startFounding(1, w.deps());
+  await gh.savePlan({}, 1, w.deps());
+  for (const s of STAGES5) w.finish(s);
+  let g = await gh.readGenesis(w.deps());
+  assert.deepEqual(g.stages.map((s) => s.can_close), [true, true, true, true, true], 'every finished stage can be put up');
+  for (const s of STAGES5) await gh.closeStage(s, 1, w.deps());
+  g = await gh.readGenesis(w.deps());
+  assert.deepEqual(g.stages.map((s) => s.board && s.board.state), Array(5).fill('sitting'));
+  assert.deepEqual(g.stages.map((s) => s.can_close), [false, false, false, false, false], 'a sitting stage is not put up twice');
+  // A later pass does not move the project past an earlier stage still sitting.
+  w.pass('charter'); w.pass('legalize');
+  await gh.onStagePassed(w.deps());
+  assert.equal((await gh.readGenesis(w.deps())).stage, 'scope', 'scope still sits: the project waits for it');
+  w.pass('scope'); await gh.onStagePassed(w.deps());
+  assert.equal((await gh.readGenesis(w.deps())).stage, 'strategize', 'scope passed; strategize still sits, so the project stops there');
+  w.pass('strategize'); await gh.onStagePassed(w.deps());
+  assert.equal((await gh.readGenesis(w.deps())).stage, 'legislation', 'strategize passed: charter and legalize had passed already');
+  w.pass('legislation'); await gh.onStagePassed(w.deps());
+  g = await gh.readGenesis(w.deps());
+  assert.equal(g.can_come_alive, true, 'one click left: bring it to life');
+  assert.equal((await gh.comeAlive(1, w.deps())).ok, true);
+});
+
+test('shipping the last task of a stage puts it in the Board Room by itself (task 1005199)', async () => {
+  const w = world();
+  assert.deepEqual(await gh.onTaskShipped(w.deps()), [], 'not founding: nothing is put up');
+  await gh.startFounding(1, w.deps());
+  await gh.savePlan({}, 1, w.deps());
+  assert.deepEqual(await gh.onTaskShipped(w.deps()), [], 'no stage is finished yet');
+  w.finish('scope'); w.finish('legalize');
+  assert.deepEqual(await gh.onTaskShipped(w.deps()), ['scope', 'legalize'], 'every finished stage, current and later');
+  assert.equal(w.opened.length, 2);
+  assert.deepEqual(await gh.onTaskShipped(w.deps()), [], 'a stage already sitting is not put up again');
+  w.board.strategize = { state: 'returned', waiting_on: [] };
+  w.finish('strategize');
+  assert.deepEqual(await gh.onTaskShipped(w.deps()), [], 'a stage the board sent back waits for the founder');
+  assert.deepEqual(await gh.onTaskShipped({ ...w.deps(), government: { genesisStageStatus: async () => { throw new Error('down'); }, openGenesisStageClose: async () => ({}) } }), [], 'a failure never throws into the ship');
+});
+
+test('the route factory listens for ships (task 1005199)', () => {
+  const src = fs.readFileSync(path.join(ROOT, 'modules', 'onboarding', 'routes', 'onboarding.js'), 'utf8');
+  assert.match(src, /api\.on\('task\.shipped', \(\) => genesis\.onTaskShipped\(\)\)/);
 });
 
 test('a returned stage stays put and can be put up again', async () => {
@@ -316,7 +368,7 @@ function bootCard({ founding, data = { genesis: null } }) {
   const attrs = founding ? { 'data-founding': 'on' } : {};
   const sandbox = {
     window: {
-      OTB: { escapeHtml: (s) => String(s), contributeHallWidget: (w) => { widget = w; } },
+      OTB: { escapeHtml: (s) => String(s), statusPill: (s) => `<span>${s}</span>`, contributeHallWidget: (w) => { widget = w; } },
       BongosClient: { createClient: () => ({ request: async (m, p) => { calls.push(`${m} ${p}`); return { ok: true, status: 200, data }; } }) },
     },
     document: { documentElement: { getAttribute: (k) => attrs[k] || null } },
@@ -371,6 +423,42 @@ test('a demo\'s genesis card: no decide form, the settled plan in one line, each
   assert.doesNotMatch(host.innerHTML, /data-genesis-plan/, 'a demo never shows the decide form');
 });
 
+test('the card lists every stage vote waiting on the viewer, and votes yes on all in order (task 1005199)', async () => {
+  const me = [{ builder_id: '1', display_name: 'Founder' }];
+  const genesis = gh.shapeGenesis({
+    mode: { stage: 'scope', stage_number: 1, stage_count: 5, day: 1 },
+    plan: gh.parsePlan({}).plan,
+    tasks: Object.fromEntries(STAGES5.map((s, i) => [s, [{ id: String(100 + i), title: s, status: i < 4 ? 'shipped' : 'ready' }]])),
+    board: {
+      scope: { state: 'sitting', item_id: '11', waiting_on: me, needs: 'One yes decides.' },
+      strategize: { state: 'sitting', item_id: '12', waiting_on: me },
+      charter: { state: 'passed', item_id: '13', waiting_on: [] },
+    },
+  });
+  assert.deepEqual(genesis.stages.map((s) => s.can_close), [false, false, false, true, false], 'only legalize is finished and not yet on the board');
+  const b = bootCard({ founding: true, data: { genesis, viewer_id: '1' } });
+  let onClick = null;
+  b.host.addEventListener = (type, fn) => { if (type === 'click') onClick = fn; };
+  b.host.contains = () => true;
+  b.widget.mount(b.host); // re-mount so the click handler is captured
+  await new Promise((r) => setImmediate(r));
+  await new Promise((r) => setImmediate(r));
+  const html = b.host.innerHTML;
+  assert.match(html, /Waiting for your vote · 2 stages/);
+  assert.match(html, /data-genesis-vote-all>Vote yes on all 2</);
+  assert.match(html, /passed, waits its turn/, 'a later stage that passed says it waits for the earlier ones');
+  assert.match(html, /data-genesis-close="legalize">Put to the board</, 'a finished later stage can be put up from its row');
+  assert.doesNotMatch(html, /data-genesis-close="legislation"/, 'an unfinished stage cannot');
+  b.calls.length = 0;
+  const btn = { hasAttribute: (k) => k === 'data-genesis-vote-all' };
+  onClick({ target: { closest: () => btn } });
+  for (let i = 0; i < 6; i++) await new Promise((r) => setImmediate(r));
+  assert.deepEqual(b.calls.slice(0, 2), [
+    'POST /api/bongos/government/board/items/11/votes',
+    'POST /api/bongos/government/board/items/12/votes',
+  ], 'one yes per stage, earliest first');
+});
+
 test('the hall carries the five life plates byte-identical to the world\'s', () => {
   const world = path.join(ROOT, 'modules', 'public-landing', 'public', 'assets', 'world');
   const hall = path.join(ROOT, 'modules', 'hall-ui', 'public', 'genesis');

package/tests/hall_board_world.mjs

@@ -270,23 +270,6 @@ test('the band ends level: no align-items on the grid, so the two cards stretch'
     'and the single-column fallback still exists below 768px (the task text said 860; the sheet says 768)');
 });
 
-test('the Standing card is the mock\'s: an identity line and a three-row fact ledger, no banner', () => {
-  const block = hallRenderJs.match(/const homeStanding = document\.getElementById\('home-standing-body'\);[\s\S]*?renderSystemNotices\(/);
-  assert.ok(block, 'the Home card render is where it was');
-  assert.match(block[0], /class="home-who"/, 'the identity line');
-  assert.match(block[0], /<dt>\$\{escapeHtml\(curLabel\(true\)\)\}<\/dt>/,
-    'the currency row takes its label from the branding contract at render time — a data-currency-label attribute is rebranded once at load, before this row exists');
-  for (const label of ['Leaderboard place', 'Preferred work']) {
-    assert.match(block[0], new RegExp(`<dt>${label}</dt>`), `the ledger row: ${label}`);
-  }
-  assert.match(block[0], /: PREFS_EMPTY\}/, 'the empty-preference copy is the one string both Standing surfaces share');
-  assert.doesNotMatch(block[0], /Banner\}/, 'no banner is stacked into the card any more');
-  for (const sel of ['.home-who', '.home-facts', '.home-facts dt', '.home-facts dd']) {
-    assert.ok(rule(styleCss, sel), `style.css styles ${sel}`);
-  }
-  assert.match(rule(styleCss, '.home-who__avatar') || '', /var\(--skeleton\)/, 'the avatar placeholder is the skeleton tone, not --bg-deep (pure black in dark)');
-});
-
 test('the system notices are inbox LINES, first in the card, and counted by its refresh()', () => {
   // Anchored on the statement AFTER the markup, so a ';' inside the markup or its comments cannot cut it short.
   const mount = goalInboxJs.match(/host\.innerHTML =([\s\S]*?);\n    host\.addEventListener/);
@@ -322,7 +305,7 @@ test('the greeting reads /me only; the version tab and its progress read left Ho
 
 // Boot hall-render.js against a stub DOM and a ctx of getters (the way
 // builders.js builds it) and read what the greeting and the card actually say.
-function bootHallRender({ me, progress = null, leaderboard = [], ctxExtra = {} }) {
+function bootHallRender({ me, progress = null, ctxExtra = {} }) {
   const els = new Map();
   const makeEl = () => ({
     dataset: {}, style: {}, textContent: '', hidden: false, _html: '', innerHTML: '',
@@ -364,7 +347,6 @@ function bootHallRender({ me, progress = null, leaderboard = [], ctxExtra = {} }
     ...ctxExtra,
   };
   const api = windowObj.OTBHallRender(ctx);
-  api.lbState.rows = leaderboard;
   return { api, el: (id) => documentObj.getElementById(id) };
 }
 
@@ -374,7 +356,6 @@ const ME = {
   cost: { level: 'warn', spend_mtd_usd: 80, budget_mtd_usd: 100, pct_used: 80 },
   needs_rebase_tasks: [{ id: 1003460 }],
 };
-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 writes nothing else', () => {
@@ -386,22 +367,13 @@ test('RUN: the greeting names the builder, and writes nothing else', () => {
   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', () => {
-  const { api, el } = bootHallRender({ me: ME, leaderboard: LEADERBOARD });
+test('RUN: Home draws no Standing chip, your details are on the visor now (task 1005249)', () => {
+  const { api, el } = bootHallRender({ me: ME });
+  assert.equal(api.lbState, undefined, 'no leaderboard rows are kept for a place nobody shows');
+  assert.equal(api.setRecentShips, undefined, 'no shipped count is kept for a chip that is gone');
   api.renderProfile(ME.builder);
-  const html = el('home-standing-body').innerHTML;
-  assert.match(html, /<p class="home-who__name">Percy Jackson<\/p>/);
-  assert.match(html, /<p class="home-who__handle">@percy<\/p>/);
-  // written from curLabel(true), not a data-currency-label attribute: brand-apply
-  // rebrands those once at load, and this row is stamped after /me answers
-  assert.match(html, /<dt>Credits<\/dt><dd>14,441<\/dd>/);
-  assert.match(html, /<dt>Leaderboard place<\/dt><dd>2nd of 4<\/dd>/);
-  assert.match(html, /<dt>Preferred work<\/dt><dd>Not set yet<\/dd>/, 'the mock\'s copy for an empty preference');
-  assert.doesNotMatch(html, /profile__(needs|budget|rebase)/, 'the banners are not in the card');
-  const withPrefs = bootHallRender({ me: ME, leaderboard: [] });
-  withPrefs.api.renderProfile({ ...ME.builder, preferred_disciplines: ['artisan', 'ui'] });
-  assert.match(withPrefs.el('home-standing-body').innerHTML, /<dd>artisan, ui<\/dd>/);
-  assert.match(withPrefs.el('home-standing-body').innerHTML, /<dt>Leaderboard place<\/dt><dd>—<\/dd>/, 'no roll yet: a dash, not a wrong place');
+  // the stub document hands back a blank element for any id, so "drew nothing" is an empty one
+  assert.equal(el('home-standing-body').innerHTML || '', '', 'no Standing card is written');
 });
 
 // task 1005046: "Where you stand" left the retired Ranks page for Accomplishments,