@bongos/core 1.21.54 → 1.21.55

package/tests/hall_street_desk.mjs

@@ -525,6 +525,14 @@ const settingsRoute = SRV('modules/lifecycle/routes/project-settings.js');
 const modulesRoute = SRV('src/bongos/routes/modules.js');
 const backupRoute = SRV('src/bongos/routes/backup.js');
 const accessRoute = SRV('modules/onboarding/routes/access-requests.js');
+// the work categories (task 1004580): three offered, in their order, and one retired
+const CATS = [
+  { id: 1, slug: 'money', label: 'Money', sort_order: 10, active: true },
+  { id: 2, slug: 'walls', label: 'The walls', sort_order: 20, active: true },
+  { id: 3, slug: 'hall', label: 'The hall', sort_order: 21, active: true },
+  { id: 4, slug: 'legal', label: 'Legal', sort_order: 15, active: false },
+];
+const CAT_GOALS = new Map([['1', 4], ['2', 1]]);
 const PREVIEW = { instance_id: 41, served_version: '1.21.19', recommended_version: '1.21.20', behind: true, observed_at: '2026-10-03T10:00:00.000Z' };
 
 function moreDesks({ preflight = null, longWords = false } = {}) {
@@ -534,7 +542,7 @@ function moreDesks({ preflight = null, longWords = false } = {}) {
   dk.matters.push(DK.normalizeMatter({ id: '1.21.20', rule: 'decide', state: 'needs', title: 'Take core 1.21.20 (running 1.21.19)', short: 'core 1.21.20', href: '/settings#software-update', ref: { type: 'core_version', id: '1.21.20' } }, { source: 'core_update', building: 'release' }));
   dk.desks.push(
     desk('release.core', 'release', coreRoute.coreDeskRows({ ...PREVIEW, preflight })),
-    desk('rules.settings', 'rules', settingsRoute.settingsDeskRows({ days: 14, categories: [{ active: true }, { active: false }] })),
+    desk('rules.settings', 'rules', settingsRoute.settingsDeskRows({ days: 14, categories: CATS.map((c) => ({ ...c, label: t(c.label) })), goals: CAT_GOALS, mayAdd: true })),
     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]),
@@ -643,13 +651,13 @@ test('Release: the core update is checked first; take is offered only after a pa
   assert.deepEqual(D.breaks(desk), []);
 });
 
-test('Rules: the rot timer as day chips, work categories as a link, modules on in one tap and off with a yes', () => {
+test('Rules: the rot timer as day chips, work categories in place (never a link), modules on in one tap and off with a yes', () => {
   const rows = actedRows(moreDesks(), 'rules', 0);
   const rot = rows.find((r) => r.name === 'Rot timer');
   assert.deepEqual(rot.choices.rot.options.map((o) => o.key), ['7', '30', '60', '90'], 'the current value is not offered');
   assert.deepEqual(j(C.request(rot.card, 'rot', rot.choices.rot.options[1].input)), { method: 'PATCH', url: '/api/bongos/project-settings/rot-days', body: { days: 30 } });
-  const cats = rows.find((r) => r.name === 'Work categories');
-  assert.equal(cats.actions[0].go, '/project-settings');
+  assert.equal(rows.find((r) => r.name === 'Work categories'), undefined, 'no link-out row (task 1004580)');
+  assert.ok(rows.every((r) => r.actions.every((a) => !a.go)), 'nothing on the Rules floor leaves the building');
   const on = rows.find((r) => r.name === 'Economy');
   assert.deepEqual(j(C.request(on.card, 'module_on')), { method: 'POST', url: '/api/bongos/modules/economy/enable', body: { enabled: true } });
   const off = rows.find((r) => r.name === 'Discord');
@@ -1300,3 +1308,162 @@ test('1004579 the card: a failed upload says why on the card\'s line and keeps t
   assert.equal(p.byId.get('streetTodayN').textContent, '0 decided');
   assert.equal(walk(body, (n) => n.className === 'mcard-error').length, 0, 'said once, on its own line');
 });
+
+// ── task 1004580: the work categories, edited in place on the Rules desk ─────
+// The Project settings page's category list (project-settings.js catsBodyHtml)
+// renames, retires and brings back, reorders and adds. Each of those is now an
+// act on the floor desk, sent to the SAME two routes the page uses, under the
+// same atoms; the desk's old link-out row is gone.
+const catDesk = (rows) => ({ key: 'rules.settings', building: 'rules', status: 'live', rows: rows.map((r) => DK.normalizeDeskRow(r, { desk: 'rules.settings', building: 'rules' })).filter(Boolean) });
+const catRows = (opts = {}) => settingsRoute.settingsDeskRows({ days: 14, categories: CATS, goals: CAT_GOALS, mayAdd: true, ...opts });
+const catDocket = (opts) => docket([], { desks: [catDesk(catRows(opts))] });
+const rulesRows = (opts) => actedRows(catDocket(opts), 'rules', 0);
+const byName = (rows, n) => rows.find((r) => r.name === n);
+
+test('1004580 the server: one row per category, offered ones in order then retired, its goals as the fact; add only with goal.create', () => {
+  const rows = catRows();
+  assert.deepEqual(rows.map((r) => r.id), ['rot', 'cat-1', 'cat-2', 'cat-3', 'cat-4', 'cat-new']);
+  assert.deepEqual(rows.slice(1, 5).map((r) => r.fact), ['4 goals', '1 goal', '0 goals', 'retired · 0 goals']);
+  assert.deepEqual(rows[1].acts, [{ key: 'rename', field: 'name' }, { key: 'retire' }]);
+  assert.deepEqual(rows[4].acts, [{ key: 'restore' }, { key: 'rename', field: 'name' }], 'a retired one is brought back, never retired twice');
+  assert.deepEqual(rows.slice(1, 5).map((r) => r.seq), [10, 20, 21, undefined], 'only an offered one has a place to move');
+  assert.ok(rows.slice(1).every((r) => r.stay && r.tool && !r.href), 'every category row stays, counts as a tool and links nowhere');
+  assert.deepEqual(rows[5].acts, [{ key: 'add', field: 'name' }]);
+  assert.equal(rows[5].fact, '3 in use');
+  assert.equal(catRows({ mayAdd: false }).find((r) => r.id === 'cat-new'), undefined, 'no add row for a viewer POST /work-categories refuses');
+  // the docket keeps the typed name, the place and stay; a place that is no whole number is dropped
+  const n = DK.normalizeDeskRow(rows[1], { desk: 'rules.settings', building: 'rules' });
+  assert.deepEqual([n.acts[0].field, n.seq, n.stay], ['name', 10, true]);
+  assert.equal(DK.normalizeDeskRow({ ...rows[1], seq: 1.5 }, { desk: 'rules.settings', building: 'rules' }).seq, undefined);
+  assert.equal(DK.normalizeDeskRow({ ...rows[1], acts: [{ key: 'rename', field: 'password' }] }, { desk: 'rules.settings', building: 'rules' }).acts[0].field, undefined, 'only a name may be typed');
+});
+
+test('1004580 the server: the desk is read under the settings page’s own atom, and the add row under POST’s', () => {
+  const src = fs.readFileSync(path.join(ROOT, 'modules/lifecycle/routes/project-settings.js'), 'utf8');
+  const decl = src.split('function contributeSettingsDesk')[1].split('\n}')[0];
+  assert.match(decl, /desk: 'rules\.settings',\s*gate: \{ permission: 'project\.settings\.manage' \}/, 'the same atom as GET /project-settings and PATCH /work-categories/:id');
+  assert.match(decl, /mayAdd: [^\n]*ctx\.has\('goal\.create'\)/, 'the same atom as POST /work-categories');
+  const goals = fs.readFileSync(path.join(ROOT, 'modules/lifecycle/routes/goals.js'), 'utf8');
+  assert.match(goals, /router\.patch\('\/work-categories\/:id', auth\.requireBuilder,\s*auth\.requirePermission\('project\.settings\.manage'\)/);
+  assert.match(goals, /router\.post\('\/work-categories', auth\.requireBuilder, auth\.requirePermission\('goal\.create'\)/);
+});
+
+test('1004580 the desk: each act is sent to the settings page’s own route, and nothing typed sends nothing', () => {
+  const rows = rulesRows();
+  const money = byName(rows, 'Money');
+  assert.deepEqual(money.actions.map((a) => [a.key, a.label, a.tone]), [['rename', 'rename', 'primary'], ['retire', 'retire', 'quiet']]);
+  assert.deepEqual([money.choices.rename.ask, money.choices.rename.field, money.choices.rename.value], ['new name', 'name', 'Money'], 'a rename starts from the name it has');
+  assert.deepEqual(j(C.request(money.card, 'rename', { option: '  Revenue ' })), { method: 'PATCH', url: '/api/bongos/work-categories/1', body: { label: 'Revenue' } });
+  assert.equal(C.request(money.card, 'rename', { option: ' ' }), null);
+  assert.deepEqual(j(C.request(money.card, 'retire')), { method: 'PATCH', url: '/api/bongos/work-categories/1', body: { active: false } });
+  const legal = byName(rows, 'Legal');
+  assert.deepEqual(legal.actions.map((a) => a.label), ['bring back', 'rename']);
+  assert.deepEqual(j(C.request(legal.card, 'restore')), { method: 'PATCH', url: '/api/bongos/work-categories/4', body: { active: true } });
+  assert.deepEqual(j(C.request(money.card, 'move', { sort_order: 25 })), { method: 'PATCH', url: '/api/bongos/work-categories/1', body: { sort_order: 25 } });
+  assert.equal(C.request(money.card, 'move', { sort_order: 2.5 }), null);
+  const add = byName(rows, 'New category');
+  assert.deepEqual([add.actions[0].label, add.choices.add.ask, add.choices.add.field], ['add', 'its name', 'name']);
+  assert.deepEqual(j(C.request(add.card, 'add', { option: 'Developer Relations' })), { method: 'POST', url: '/api/bongos/work-categories', body: { label: 'Developer Relations' } });
+  assert.equal(C.request(add.card, 'add', { option: '' }), null);
+  assert.deepEqual(j([byName(rows, 'Money').moves, byName(rows, 'The hall').moves, byName(rows, 'Legal').moves || null]), [{ up: false, down: true }, { up: true, down: false }, null]);
+  assert.deepEqual(D.breaks(D.deskModel({ key: 'rules', floor: 0, docket: catDocket(), goals: GOALS, now: NOW })), [], 'the line rule holds');
+});
+
+test('1004580 a move: one write when a whole number sits between its new neighbours, else the order numbered again', () => {
+  const rows = rulesRows();
+  // Money (10) down, between The walls (20) and The hall (21): no whole number fits, so all three again in tens
+  assert.deepEqual(D.placeMoves(rows, byName(rows, 'Money').key, 1), [{ id: '2', sort_order: 10 }, { id: '1', sort_order: 20 }, { id: '3', sort_order: 30 }]);
+  // The hall (21) up, to after Money (10) and before The walls (20): one write, 15
+  assert.deepEqual(D.placeMoves(rows, byName(rows, 'The hall').key, -1), [{ id: '3', sort_order: 15 }]);
+  // The walls (20) up to the top: ten before Money
+  assert.deepEqual(D.placeMoves(rows, byName(rows, 'The walls').key, -1), [{ id: '2', sort_order: 0 }]);
+  assert.deepEqual(D.placeMoves(rows, byName(rows, 'Money').key, -1), [], 'the top does not go up');
+  assert.deepEqual(D.placeMoves(rows, byName(rows, 'Legal').key, -1), [], 'a retired one has no place');
+});
+
+// the page, on the Rules desk
+async function rulesPage(opts = {}) {
+  const p = await bootPage('#building=rules', [], { over: { desks: [catDesk(catRows())] }, ...opts });
+  const rowOf = (n) => p.part('desk-rows').children.find((r) => r.children[0].children[1].children[0].textContent === n);
+  const button = (row, label) => row.children[0].children.find((c) => /desk-acts/.test(c.className)).children.find((b) => b.textContent === label);
+  return { ...p, rowOf, button };
+}
+
+test('1004580 the page: rename in place; the field starts from the name, the write is the page’s PATCH, the row stays, pip, toast, record', async () => {
+  const p = await rulesPage({ answer: (url, body) => (body.label ? { status: 200, body: { ok: true, category: { id: 1, label: body.label } } } : null) });
+  assert.ok(walk(p.deskEl(), (n) => n.tagName === 'a').length === 0, 'no link on the desk');
+  assert.equal(walk(p.deskEl(), (n) => n.textContent === 'Work categories').length, 0, 'the link-out row is gone');
+  p.button(p.rowOf('Money'), 'rename').fire('click');
+  const ask = p.rowOf('Money').children[1];
+  assert.equal(ask.className, 'desk-choices');
+  assert.equal(ask.children[0].textContent, 'new name');
+  const input = ask.children[1];
+  assert.equal(input.value, 'Money');
+  input.value = 'Revenue';
+  ask.children[2].fire('click');
+  await settle();
+  assert.deepEqual(p.sent, [{ method: 'PATCH', url: '/api/bongos/work-categories/1', body: { label: 'Revenue' } }]);
+  assert.ok(p.rowOf('Money'), 'the row stays on the desk');
+  assert.equal(p.byId.get('streetToast').textContent, 'Renamed. Goals read Revenue now.');
+  assert.match(p.byId.get('streetToast').className, /street-toast--desk/);
+  assert.equal(p.byId.get('streetTodayN').textContent, '1 decided');
+  assert.equal(p.part('desk-record').children[1].textContent, 'renamed Money · now');
+});
+
+test('1004580 the page: retire and bring back in one tap each', async () => {
+  const p = await rulesPage();
+  p.button(p.rowOf('The walls'), 'retire').fire('click');
+  await settle();
+  p.button(p.rowOf('Legal'), 'bring back').fire('click');
+  await settle();
+  assert.deepEqual(p.sent, [{ method: 'PATCH', url: '/api/bongos/work-categories/2', body: { active: false } }, { method: 'PATCH', url: '/api/bongos/work-categories/4', body: { active: true } }]);
+  assert.equal(p.byId.get('streetToast').textContent, 'Brought back. New goals can pick it again.');
+  assert.equal(p.byId.get('streetTodayN').textContent, '2 decided');
+  assert.deepEqual(p.part('desk-record').children.slice(1, 3).map((x) => x.textContent), ['brought back Legal · now', 'retired The walls · now']);
+});
+
+test('1004580 the page: tapping a name opens its detail in place, and it moves from there', async () => {
+  const p = await rulesPage();
+  p.rowOf('The hall').children[0].children[1].fire('click');
+  const detail = p.rowOf('The hall').children[1];
+  assert.equal(detail.className, 'desk-facts');
+  assert.deepEqual(detail.children.slice(0, 3).map((c) => c.textContent).concat(detail.children[3].children.map((c) => c.textContent)), ['key hall', '3 of 3 in order', 'offered to new goals', 'move up'], 'the page’s detail: its key, its place, whether it is offered; the bottom one only moves up');
+  byAct(detail, 'move-up').fire('click');
+  await settle();
+  assert.deepEqual(p.sent, [{ method: 'PATCH', url: '/api/bongos/work-categories/3', body: { sort_order: 15 } }]);
+  assert.equal(p.byId.get('streetToast').textContent, 'Moved. New goals are offered the categories in this order.');
+  assert.equal(p.byId.get('streetTodayN').textContent, '1 decided');
+  assert.equal(p.part('desk-record').children[1].textContent, 'moved The hall · now');
+  assert.equal(p.rowOf('The hall').children[1].className, 'desk-facts', 'the detail stays open to move it again');
+});
+
+test('1004580 the page: a new category is added by its typed name, and the record names it', async () => {
+  const p = await rulesPage({ answer: (url, body) => (url.endsWith('/work-categories') ? { status: 201, body: { ok: true, created: true, category: { id: 9, label: body.label } } } : null) });
+  p.button(p.rowOf('New category'), 'add').fire('click');
+  const ask = p.rowOf('New category').children[1];
+  assert.equal(ask.children[0].textContent, 'its name');
+  assert.equal(ask.children[1].value || '', '', 'an add starts empty');
+  ask.children[1].value = 'Outreach';
+  ask.children[2].fire('click');
+  await settle();
+  assert.deepEqual(p.sent, [{ method: 'POST', url: '/api/bongos/work-categories', body: { label: 'Outreach' } }]);
+  assert.equal(p.byId.get('streetToast').textContent, 'Outreach is a category now. New goals can pick it.');
+  assert.equal(p.part('desk-record').children[1].textContent, 'added Outreach · now');
+});
+
+test('1004580 the page: a refused act says why, keeps the row, and counts nothing', async () => {
+  const p = await rulesPage({ answer: () => ({ status: 403, body: { error: { code: 'forbidden' } } }) });
+  p.button(p.rowOf('Money'), 'retire').fire('click');
+  await settle();
+  assert.equal(p.sent.length, 1);
+  assert.equal(p.byId.get('streetToast').textContent, 'That is not yours to do.');
+  assert.ok(p.rowOf('Money'));
+  assert.equal(p.byId.get('streetTodayN').textContent, '0 decided');
+  assert.ok(!walk(p.part('desk-record'), (n) => /retired Money/.test(n.textContent)).length, 'nothing on the record');
+  // a refused move stops at the first write and counts nothing
+  p.rowOf('Money').children[0].children[1].fire('click');
+  byAct(p.rowOf('Money').children[1], 'move-down').fire('click');
+  await settle();
+  assert.equal(p.sent.length, 2, 'the renumbering stopped at its first refusal');
+  assert.equal(p.byId.get('streetTodayN').textContent, '0 decided');
+});