@bongos/core 1.21.35 → 1.21.36

package/tests/hall_street_desk.mjs

@@ -163,7 +163,7 @@ test('a floor holds its own source; the ideas floor holds the open ideas; the re
   const at = (k, f) => D.floorMatters(k, f, dk).map((m) => m.id);
   assert.deepEqual(at('people', 4), ['access_requests:1'], 'Waiting to join: the open request only');
   assert.deepEqual(at('people', 0), ['board:5'], 'a sitting sits at the front desk');
-  assert.deepEqual(at('planning', 2), ['board:6'], 'Ideas to ratify');
+  assert.deepEqual(at('planning', 1), ['board:6'], 'Ideas to ratify');
   assert.deepEqual(at('planning', 0), [], 'an idea is not also at the front desk');
   assert.equal(D.firstNeeds('people', dk), 0);
   assert.equal(D.firstNeeds('rules', dk), null);
@@ -234,12 +234,12 @@ function fakeDom() {
   }
   return { document: { documentElement: mk('html'), getElementById: (id) => byId.get(id) || null, createElement: (t) => mk(t), createElementNS: (_n, t) => mk(t) }, byId, focused };
 }
-async function bootPage(hash, ms, { refuse = false } = {}) {
+async function bootPage(hash, ms, { refuse = false, over = {} } = {}) {
   const { document, byId, focused } = fakeDom();
   const sent = [];
   const store = new Map();
   let matters = ms.slice();
-  const feeds = () => ({ '/api/bongos/government/docket': docket(matters), '/api/bongos/goals': { goals: [] }, '/api/bongos/goals/rollups': { rollups: [] } });
+  const feeds = () => ({ '/api/bongos/government/docket': docket(matters, over), '/api/bongos/goals': { goals: [] }, '/api/bongos/goals/rollups': { rollups: [] } });
   const location = { hash, href: '' };
   const window = {
     innerWidth: 1440, innerHeight: 900, location,
@@ -268,7 +268,7 @@ async function bootPage(hash, ms, { refuse = false } = {}) {
 }
 
 test('the page: the desk acts in place — the row clears, the floor lights with a tick, the meter takes a pip, the toast speaks', async () => {
-  const ms = [matter({ id: 'access_requests:11', source: 'access_requests', building: 'people', state: 'needs', proposer: { name: 'Ana Ruiz' }, ref: { id: 11 }, opened_at: '2026-10-01T12:00:00.000Z' })];
+  const ms = [matter({ id: 'access_requests:11', source: 'access_requests', building: 'people', state: 'needs', proposer: { name: 'Ana Ruiz' }, ref: { id: 11 }, opened_at: new Date(Date.now() - 2 * 86400000 - 3600000).toISOString() })]; // two days before the real clock: the page reads real time
   const p = await bootPage('#building=people', ms);
   const html = read('street.html');
   assert.ok(html.indexOf('/builders/street-desk.js?') > html.indexOf('/builders/street-inside.js?') && html.indexOf('/builders/street-desk.js?') < html.indexOf('/builders/street.js?'), 'the desk loads after the interior and before the page');
@@ -490,10 +490,78 @@ function moreDesks({ preflight = null, longWords = false } = {}) {
     desk('rules.modules', 'rules', modulesRoute.moduleDeskRows([{ key: 'discord', title: t('Discord'), enabled: true }, { key: 'economy', title: 'Economy', enabled: false }])),
     desk('treasury.backup', 'treasury', backupRoute.backupDeskRows({ age_hours: 30, stale: false }, false)),
     desk('people.invite', 'people', [accessRoute.INVITE_DESK_ROW]),
+    // task 1004561: a builder's monthly limit, and a sign-off undone
+    desk('treasury.budgets', 'treasury', buildersRoute.budgetDeskRows(
+      [{ id: 7, display_name: t('Ana Ruiz'), github_login: 'ana', monthly_budget_usd: '50' }, { id: 8, github_login: 'kai', monthly_budget_usd: null }],
+    )),
+    desk('review.signed', 'review', lifeDocket.signedDeskRows([
+      { id: 11, criterion_md: t('Refunds land'), satisfied: true, checked_at: '2026-10-02T10:00:00.000Z' },
+      { id: 12, criterion_md: 'Not yet', satisfied: false, checked_at: null },
+    ])),
   );
   return dk;
 }
 
+// A docket whose decision table puts a building to a sitting (task 1004561).
+function heldBy(dk, key, rule = 'majority') {
+  dk.buildings = dk.buildings.map((b) => (b.key === key ? { ...b, decision: { rule, sitting: true, who: 'the council' }, holder_count: 5 } : b));
+  return dk;
+}
+
+test('Treasury: each builder\'s monthly limit in one tap, the limit they have left off; no limit clears it', () => {
+  const rows = actedRows(moreDesks(), 'treasury', 3);
+  const ana = rows.find((r) => r.name === 'Ana Ruiz');
+  assert.equal(ana.fact, '$50 a month');
+  assert.deepEqual(ana.actions.map((a) => a.label), ['set limit']);
+  assert.deepEqual(ana.choices.budget.options.map((o) => o.key), ['25', '100', '250', 'none'], 'the current limit is not offered');
+  assert.deepEqual(j(C.request(ana.card, 'budget', ana.choices.budget.options[1].input)), { method: 'PATCH', url: '/api/bongos/builders/7/budget', body: { monthly_budget_usd: 100 } });
+  assert.deepEqual(j(C.request(ana.card, 'budget', ana.choices.budget.options[3].input)).body, { monthly_budget_usd: null });
+  const kai = rows.find((r) => r.name === 'kai');
+  assert.equal(kai.fact, 'no limit');
+  assert.ok(!kai.choices.budget.options.some((o) => o.key === 'none'), 'no limit is not offered to someone without one');
+  assert.equal(C.answer(ana.card, 'budget', {}).toast, 'Ana Ruiz has a new monthly limit.');
+});
+
+test('Review: a signed-off promise is undone in place, the reason one tap', () => {
+  const rows = actedRows(moreDesks(), 'review', 2);
+  assert.deepEqual(rows.map((r) => r.name), ['Refunds land'], 'only what is signed off');
+  const r = rows[0];
+  assert.equal(r.fact, 'signed off oct 2');
+  assert.deepEqual(r.actions.map((a) => a.label), ['undo']);
+  assert.ok(r.choices.unsign.options.every((o) => o.label.length <= D.LIMITS.chip));
+  assert.deepEqual(j(C.request(r.card, 'unsign', r.choices.unsign.options[0].input)), { method: 'POST', url: '/api/bongos/done-when/11/unsatisfy', body: { reason: 'it broke again' } });
+  assert.equal(C.answer(r.card, 'unsign', {}).kind, 'settle');
+});
+
+test('a building held by a sitting: its desk acts are filed as that building\'s matter, which acts once passed', () => {
+  const filed = (dk, key, floor, name, act, pick) => {
+    const r = actedRows(dk, key, floor).find((x) => x.name === name);
+    assert.ok(r, `${name} on ${key}`);
+    const input = pick == null ? {} : r.choices[act].options[pick].input;
+    return { req: j(C.request(r.card, act, input)), card: r.card };
+  };
+  const t = filed(heldBy(moreDesks(), 'treasury'), 'treasury', 3, 'Ana Ruiz', 'budget', 1);
+  assert.equal(t.req.url, '/api/bongos/government/board/matters');
+  assert.deepEqual(t.req.body.action, { type: 'set_budget', builder_id: 7, monthly_usd: 100 });
+  assert.equal(t.req.body.area, 'treasury');
+  assert.equal(C.answer(t.card, 'budget', {}).toast, 'Sent to the council. It is carried out when they pass it.');
+  const rv = filed(heldBy(moreDesks(), 'review'), 'review', 1, 'Refunds work', 'force', 0);
+  assert.deepEqual(rv.req.body, { area: 'review', title: 'Sign off: Refunds work', action: { type: 'satisfy_criterion', criterion_id: 8 } });
+  const au = heldBy(moreDesks(), 'automation');
+  const sw = actedRows(au, 'automation', 0).find((x) => x.actions.some((a) => a.key === 'switch_on'));
+  assert.deepEqual(j(C.request(sw.card, 'switch_on', {})).body.action, { type: 'switch_on' });
+  // where the building decides alone, the same tap is the direct route
+  const alone = filed(heldBy(moreDesks(), 'treasury', 'decide'), 'treasury', 3, 'Ana Ruiz', 'budget', 1);
+  assert.equal(alone.req.url, '/api/bongos/builders/7/budget');
+  const plain = filed(moreDesks(), 'treasury', 3, 'Ana Ruiz', 'budget', 1);
+  assert.equal(plain.req.url, '/api/bongos/builders/7/budget');
+  // the new desks keep the line rule while a sitting holds them
+  for (const key of ['treasury', 'review', 'automation']) {
+    const dk = heldBy(moreDesks({ longWords: true }), key);
+    I.PLAN[key].floors.forEach((_f, floor) => assert.deepEqual(D.breaks(D.deskModel({ key, floor, docket: dk, goals: GOALS, now: NOW, viewerId: '95' })), []));
+  }
+});
+
 test('the second-pass desks keep the line rule on every floor', () => {
   for (const longWords of [false, true]) {
     for (const preflight of [null, { target: '1.21.20', ok: true }, { target: '1.21.20', ok: false, error: LONG }]) {
@@ -555,3 +623,175 @@ test('the Treasury desk reads the newest backup without blocking (no sync disk r
   const body = src.split('async function newestDumpAge')[1].split('\nfunction latestDump')[0];
   assert.doesNotMatch(body, /Sync\(/);
 });
+
+// ── the Planning desks (task 1004560) ─────────────────────────────────────────
+// Priorities, Ideas to ratify and Waiting on you, as on the Desks board, built
+// from the REAL server mappers through the docket's own normalisers.
+const ideasDocket = SRV('modules/ideas/governor-docket.js');
+const ORDER_GOALS = [
+  { id: 31, title: 'Governor city', status: 'open', version_id: 'V2' }, { id: 32, title: 'Payments', status: 'open', version_id: 'V2' },
+  { id: 33, title: 'Onboarding', status: 'open', version_id: 'V2' }, { id: 34, title: 'Elsewhere', status: 'open', version_id: 'V9' },
+];
+const ORDER_CRITERIA = [{ goal_id: 31, satisfied: true }, { goal_id: 31, satisfied: true }, { goal_id: 32, satisfied: true }, { goal_id: 32, satisfied: false }, { goal_id: 32, satisfied: false }];
+function planningDocket({ longWords = false, sitting = null } = {}) {
+  const t = (s) => (longWords ? LONG + ' ' + s : s);
+  const goals = ORDER_GOALS.map((g) => ({ ...g, title: t(g.title) }));
+  const desk = (key, rows) => ({ key, building: 'planning', status: 'live', rows: rows.map((r) => DK.normalizeDeskRow(r, { desk: key, building: 'planning' })).filter(Boolean) });
+  const ideas = [
+    { id: 5, status: 'open', kind: 'criterion-proposal', title: t('Calm mode promise'), body_md: JSON.stringify({ target_version: 'V2', criterion_md: t('A quiet floor shows one line') }), created_at: '2026-09-28T09:00:00.000Z' },
+    { id: 6, status: 'open', kind: 'idea', grade: 'full', title: t('Objection goes back'), template_key: 'base-v2', field_values: { success: 'It comes back with its reason', scope: 'the return path' }, created_at: '2026-09-25T09:00:00.000Z' },
+    { id: 7, status: 'open', kind: 'idea', grade: 'full', title: 'Still sitting', template_key: 'base-v2', field_values: { success: 'x' } },
+    { id: 8, status: 'open', kind: 'idea', grade: 'full', title: t('No shape'), template_key: 'base-v0', field_values: {} },
+  ];
+  const blockers = [
+    { id: 12, title: t('Payment provider'), body_md: 'Which one?\n- Option A: Stripe — cheaper\n- **Option B:** Paddle (merchant of record)\n- Option C: Wait a month', created_at: '2026-09-30T10:00:00.000Z', blocking_task_ids: [1, 2, 3, 4] },
+    { id: 13, title: t('Hosting'), body_md: 'No options listed.', created_at: '2026-10-01T10:00:00.000Z', blocking_task_ids: [] },
+  ];
+  const matters = blockers.map((b) => DK.normalizeMatter(ideasDocket.blockerDocketMatter(b, true), { source: 'blockers', building: 'planning' })).filter(Boolean);
+  const over = {
+    desks: [
+      desk('planning.order', lifeDocket.orderDeskRows(goals, ORDER_CRITERIA, 'V2', true)),
+      desk('planning.ratify', ideasDocket.ratifyDeskRows(ideas, [{ id: 'V2', name: 'Version two' }, { id: 'V3' }], new Set(['6', '8']))),
+    ],
+  };
+  const dk = docket(matters, over);
+  if (sitting) dk.buildings.find((b) => b.key === 'planning').decision = sitting.decision, dk.buildings.find((b) => b.key === 'planning').holder_count = sitting.holders;
+  return dk;
+}
+const planDesk = (dk, floor, extra = {}) => D.deskModel({ key: 'planning', floor, docket: dk, goals: GOALS, now: NOW, viewerId: '95', ...extra });
+
+test('Planning: the three desks are the first three floors, as on the Desks board', () => {
+  assert.deepEqual(I.PLAN.planning.floors.slice(0, 3).map((f) => f[0]), ['Priorities', 'Ideas to ratify', 'Waiting on you']);
+  assert.deepEqual(I.PLAN.planning.floors.slice(0, 3).map((f) => f[2].desk || f[2].source), ['planning.order', 'planning.ratify', 'blockers']);
+});
+
+test('Priorities: the version\'s open goals in order with promise pips; arrows move them; a save bar with undo sets the order', () => {
+  assert.deepEqual(lifeDocket.orderDeskRows(ORDER_GOALS, ORDER_CRITERIA, 'V2', false), [], 'no rows for a viewer who may not set the order');
+  assert.deepEqual(lifeDocket.orderDeskRows(ORDER_GOALS.slice(0, 1), [], 'V2', true), [], 'one goal has no order to set');
+  const dk = planningDocket();
+  const desk = planDesk(dk, 0);
+  assert.deepEqual(desk.rows.map((r) => [r.pos, r.name, r.fact]), [[1, 'Governor city', '2 of 2 promises kept'], [2, 'Payments', '1 of 3 promises kept'], [3, 'Onboarding', 'no promises yet']], 'only the building version\'s open goals, in their order');
+  assert.deepEqual(desk.rows[1].pips.map((p) => p.on), [true, false, false], 'one pip per promise, filled when kept');
+  assert.deepEqual(desk.rows[0].actions.map((a) => a.label), ['move up', 'move down']);
+  assert.equal(desk.status, '3 goals in order');
+  assert.equal(desk.hot, false);
+  assert.deepEqual(desk.tiles.map((t) => [t.v, t.l]), [['60%', 'promises kept'], ['5', 'on record']]);
+  assert.equal(desk.save, null, 'nothing to save until the order changes');
+  const keys = desk.rows.map((r) => r.key);
+  assert.deepEqual(D.moved(keys, keys[0], -1), keys, 'the top cannot move up');
+  const order = D.moved(keys, keys[2], -1);
+  const moved = planDesk(dk, 0, { order });
+  assert.deepEqual(moved.rows.map((r) => r.name), ['Governor city', 'Onboarding', 'Payments']);
+  assert.deepEqual(j(moved.save), { line: 'new order · saved for everyone', label: 'save order', council: false, said: 'Saved. Goals are worked in this order now.', set: 'V2', ids: ['31', '33', '32'], names: ['Governor city', 'Onboarding', 'Payments'] });
+  assert.deepEqual(j(C.orderRequest(moved.save)), { method: 'POST', url: '/api/bongos/goals/reorder', body: { version_id: 'V2', ordered_ids: [31, 33, 32] } });
+  assert.deepEqual(D.breaks(moved), []);
+});
+
+test('Priorities: where the decision table puts Planning to a sitting, the save files a Planning matter and says so', () => {
+  const majority = planningDocket({ sitting: { decision: { rule: 'majority', sitting: true, who: 'the council' }, holders: 5 } });
+  const keys = planDesk(majority, 0).rows.map((r) => r.key);
+  const save = planDesk(majority, 0, { order: D.moved(keys, keys[1], -1) }).save;
+  assert.equal(save.line, 'new order · goes to the council · 3 yes needed');
+  assert.equal(save.label, 'send to council');
+  const req = j(C.orderRequest(save));
+  assert.equal(req.url, '/api/bongos/government/board/matters');
+  assert.equal(req.body.area, 'planning');
+  assert.match(req.body.detail_md, /1\. Payments\n2\. Governor city\n3\. Onboarding$/);
+  const alone = planningDocket({ sitting: { decision: { rule: 'decide', sitting: true }, holders: 1 } });
+  assert.equal(planDesk(alone, 0, { order: D.moved(keys, keys[1], -1) }).save.council, false, 'a sitting that decides alone sets the order itself');
+  const consent = planningDocket({ sitting: { decision: { rule: 'consent', sitting: true }, holders: 4 } });
+  const cs = planDesk(consent, 0, { order: D.moved(keys, keys[1], -1) }).save;
+  assert.match(cs.line, /unless one objects/);
+  assert.equal(cs.said, 'The new order is with the council. It passes unless someone objects.', 'the toast is whole sentences');
+  assert.equal(save.said, 'The new order is with the council. It needs 3 yes.');
+});
+
+test('Ideas to ratify: a promise ratifies in one tap; a carried Full Idea becomes a goal by a version chip, or opens its page; a sitting idea stays the board\'s vote', () => {
+  const dk = planningDocket();
+  const rows = D.rowsFor('planning', 1, dk, { now: NOW, goals: GOALS });
+  const promise = rows.find((r) => r.name === 'Calm mode promise');
+  assert.deepEqual(promise.actions.map((a) => a.label), ['ratify', 'open']);
+  assert.deepEqual(j(C.request(promise.card, 'ratify')), { method: 'POST', url: '/api/bongos/inbox/5/ratify', body: { notes_md: 'Ratified on the floor desk.' } });
+  const full = rows.find((r) => r.name === 'Objection goes back');
+  assert.deepEqual(full.actions.map((a) => a.label), ['make goal', 'open']);
+  assert.deepEqual(full.choices.ratify_goal.options.map((o) => o.label), ['V2', 'V3'], 'the target version is a chip');
+  assert.deepEqual(j(C.request(full.card, 'ratify_goal', full.choices.ratify_goal.options[1].input)), { method: 'POST', url: '/api/bongos/inbox/6/ratify-goal', body: { target_version: 'V3', notes_md: 'Ratified on the floor desk.' } });
+  assert.ok(!rows.some((r) => r.name === 'Still sitting'), 'a Full Idea the board has not carried is not ratified from here');
+  const shapeless = rows.find((r) => r.name === 'No shape');
+  assert.deepEqual(shapeless.actions.map((a) => [a.key, a.go]), [['open', '/idea/8']], 'inputs that do not fit chips: a link');
+  assert.match(planDesk(dk, 1).status, /^3 to ratify · oldest/, 'counted in the noun of its desk');
+  // the board's vote row keeps its place and shows its seats as pips
+  const room = { open: [{ id: '900', subject_type: 'full_idea', subject: { title: 'Watch a goal' }, constitution: { pass_rule: 'majority' }, votes: [{ voter_id: '3', direction: 'yes' }, { voter_id: '4', direction: 'yes' }], tally: { open: 3 } }], closed: [] };
+  const withVote = docket(dk.matters.concat([matter({ id: 'board:900', source: 'board', short: 'idea to ratify', title: 'Watch a goal', state: 'needs' })]), { desks: dk.desks });
+  const vote = D.rowsFor('planning', 1, withVote, { now: NOW, room, viewerId: '95' }).find((r) => r.source === 'board');
+  assert.ok(vote.pips && vote.pips.filter((p) => p.on).length === 2, 'a filled pip per yes');
+});
+
+test('Waiting on you: a blocker is decided by one of its own options, or go ahead / not now / need more, written as the resolution note', () => {
+  assert.equal(ideasDocket.blockerDocketMatter({ id: 1, title: 'x', created_at: null }, false).acts, undefined, 'no act for a viewer who may not resolve');
+  const dk = planningDocket();
+  const rows = D.rowsFor('planning', 2, dk, { now: NOW });
+  const pay = rows.find((r) => r.name === 'Payment provider');
+  assert.deepEqual(pay.actions.map((a) => a.label), ['decide']);
+  assert.equal(pay.show, 'decide', 'its chips stand open: deciding is picking one');
+  assert.deepEqual(pay.choices.decide.options.map((o) => o.label), ['Stripe', 'Paddle', 'Wait a month']);
+  assert.deepEqual(j(C.request(pay.card, 'decide', pay.choices.decide.options[1].input)), { method: 'POST', url: '/api/bongos/blockers/12/resolve', body: { resolution_note: 'Decided on the floor desk: Paddle.' } });
+  const host = rows.find((r) => r.name === 'Hosting');
+  assert.deepEqual(host.choices.decide.options.map((o) => o.label), ['go ahead', 'not now', 'need more']);
+  const desk = planDesk(dk, 2);
+  assert.equal(desk.hot, true);
+  assert.match(desk.status, /^2 waiting · oldest/);
+});
+
+test('the Planning desks keep the line rule, long words or short, with a moved order and a sitting', () => {
+  for (const longWords of [false, true]) {
+    const dk = planningDocket({ longWords, sitting: { decision: { rule: 'unanimous', sitting: true }, holders: 12 } });
+    const keys = planDesk(dk, 0).rows.map((r) => r.key);
+    const desks = [0, 1, 2, 3, 4, 5].map((f) => planDesk(dk, f, f === 0 ? { order: keys.slice().reverse() } : {}));
+    assert.ok(desks[0].save, 'the moved order has its save bar');
+    assert.deepEqual(desks.flatMap((d) => D.breaks(d)), []);
+  }
+});
+
+test('the page: the arrows move a goal in place, undo puts it back, save sends the order', async () => {
+  const dk = planningDocket();
+  const p = await bootPage('#building=planning', dk.matters, { over: { desks: dk.desks } });
+  p.byId.get('insideFloors').children[0].fire('click');
+  const rowsEl = () => p.part('desk-rows').children;
+  const arrows = (i) => rowsEl()[i].children[0].children.find((c) => c.className === 'desk-acts').children;
+  assert.deepEqual(rowsEl().map((r) => r.children[0].children[0].textContent), ['1', '2', '3'], 'each goal shows its place');
+  assert.equal(p.part('desk-save'), undefined);
+  assert.equal(arrows(0)[0].attrs.disabled, '', 'the top goal cannot go up');
+  assert.equal(arrows(2)[1].attrs.disabled, '', 'the last goal cannot go down');
+  assert.equal(arrows(1)[0].attrs.disabled, undefined);
+  rowsEl()[0].children[0].children[2].fire('click');
+  assert.deepEqual(rowsEl()[0].children[1].children.map((f) => f.textContent), ['version V2'], 'a goal\'s facts open in place like any row');
+  rowsEl()[0].children[0].children[2].fire('click');
+  arrows(0)[1].fire('click');
+  assert.deepEqual(rowsEl().map((r) => r.children[0].children[2].children[0].textContent), ['Payments', 'Governor city', 'Onboarding']);
+  const bar = p.part('desk-save');
+  assert.deepEqual(bar.children.map((c) => c.textContent), ['new order · saved for everyone', 'undo', 'save order']);
+  bar.children[1].fire('click');
+  assert.equal(p.part('desk-save'), undefined, 'undo puts the order back');
+  arrows(2)[0].fire('click');
+  p.part('desk-save').children[2].fire('click');
+  for (let i = 0; i < 5; i++) await new Promise((r) => setTimeout(r, 0));
+  assert.deepEqual(p.sent, [{ method: 'POST', url: '/api/bongos/goals/reorder', body: { version_id: 'V2', ordered_ids: [31, 33, 32] } }]);
+  assert.match(p.byId.get('streetToast').textContent, /worked in this order/);
+  assert.equal(p.byId.get('streetTodayN').textContent, '1 decided');
+});
+
+test('the page: one tap on its option decides a blocker, its options standing open with no extra button', async () => {
+  const dk = planningDocket();
+  const p = await bootPage('#building=planning', dk.matters, { over: { desks: dk.desks } });
+  p.byId.get('insideFloors').children[2].fire('click');
+  const pay = p.part('desk-rows').children.find((r) => r.children[0].children[1].children[0].textContent === 'Payment provider');
+  assert.equal(pay.children[0].children.find((c) => c.className === 'desk-acts').children.length, 0, 'no decide button: the chip is the act');
+  const chips = pay.children[1];
+  assert.equal(chips.className, 'desk-choices');
+  assert.deepEqual(chips.children.map((c) => c.textContent), ['pick one', 'Stripe', 'Paddle', 'Wait a month']);
+  chips.children[2].fire('click');
+  for (let i = 0; i < 5; i++) await new Promise((r) => setTimeout(r, 0));
+  assert.deepEqual(p.sent, [{ method: 'POST', url: '/api/bongos/blockers/12/resolve', body: { resolution_note: 'Decided on the floor desk: Paddle.' } }]);
+  assert.match(p.byId.get('streetToast').textContent, /Decided/);
+});

package/tests/hall_street_inside.mjs

@@ -231,7 +231,7 @@ test('a floor bound to a reading shows its figure and line when live; Planning c
   assert.equal(I.civicInfo('treasury', { docket: d, now: NOW }).floors.find((f) => f.name === 'Reserve').count, '$1,100');
   const goals = [goal(1), goal(2), goal(3), goal(4), goal(5), goal(6, 'achieved')];
   const m = I.buildingModel({ key: 'planning', docket: d, goals, mode: 'dark', now: NOW });
-  const g = I.civicInfo('planning', { docket: d, goals: goals.filter((x) => x.status === 'open'), now: NOW }).floors[0];
+  const g = I.civicInfo('planning', { docket: d, goals: goals.filter((x) => x.status === 'open'), now: NOW }).floors.find((f) => f.name === 'Goals');
   assert.deepEqual([g.name, g.count, g.line], ['Goals', '5', '5 goals open']);
   assert.equal(g.lines.length, 5, 'four goals and a line for the rest');
   assert.ok(m.texts.some((t) => t.v === '5' && t.s === 20), 'only open goals are counted on the wall');
@@ -311,9 +311,9 @@ test('a floor the docket cannot answer never shows a number; Goals falls back to
   for (const [n, st] of [['Ranks', 'not_yours'], ['The council', 'off'], ['Newcomers', 'unavailable'], ['Testers', 'unavailable']]) {
     assert.deepEqual([by[n].status, by[n].count], [st, ''], `${n} says ${st} and no number`);
   }
-  const g = I.civicInfo('planning', { docket: docket(), goals: [goal(1), goal(2)], now: NOW }).floors[0];
+  const g = I.civicInfo('planning', { docket: docket(), goals: [goal(1), goal(2)], now: NOW }).floors.find((f) => f.name === 'Goals');
   assert.deepEqual([g.count, g.line], ['2', '2 goals open'], 'an older docket without floors still counts the open goals');
-  const live = I.civicInfo('planning', { docket: docket([], { floors: [floorRow('planning.goals', { count: '1', line: '1 goal open', lines: [['Hall', '5 of 5 kept']] })] }), goals: [goal(1), goal(2)], now: NOW }).floors[0];
+  const live = I.civicInfo('planning', { docket: docket([], { floors: [floorRow('planning.goals', { count: '1', line: '1 goal open', lines: [['Hall', '5 of 5 kept']] })] }), goals: [goal(1), goal(2)], now: NOW }).floors.find((f) => f.name === 'Goals');
   assert.deepEqual([live.count, live.lines], ['1', [['Hall', '5 of 5 kept']]], 'with the floor, its promises kept of total');
 });