@bongos/core 1.21.53 → 1.21.55

package/tests/hall_street_desk.mjs

@@ -271,26 +271,33 @@ 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, over = {} } = {}) {
+// xhr: an XMLHttpRequest stand-in (the recorded sign-off's upload); answer(url,
+// body): a response of its own for a write, else the default; extra: more feeds
+async function bootPage(hash, ms, { refuse = false, over = {}, xhr = null, answer = null, extra = {} } = {}) {
   const { document, byId, focused } = fakeDom();
   const sent = [];
   const store = new Map();
   let matters = ms.slice();
-  const feeds = () => ({ '/api/bongos/government/docket': docket(matters, over), '/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: [] }, ...extra });
+  const reads = [];
   const location = { hash, href: '' };
   const window = {
     innerWidth: 1440, innerHeight: 900, location,
     localStorage: { getItem: (k) => (store.has(k) ? store.get(k) : null), setItem: (k, v) => store.set(k, String(v)) },
     matchMedia: () => ({ matches: true, addEventListener() {} }),
     addEventListener() {}, history: { pushState() {} },
+    XMLHttpRequest: xhr || undefined,
   };
   const fetch = (url, init) => {
     if (init && init.method && init.method !== 'GET') {
       sent.push({ method: init.method, url, body: JSON.parse(init.body || '{}') });
+      const own = answer ? answer(url, JSON.parse(init.body || '{}')) : null;
+      if (own) return Promise.resolve({ ok: own.status < 300, status: own.status, json: async () => own.body || {} });
       if (refuse) return Promise.resolve({ ok: false, status: 409, json: async () => ({ error: { code: 'not_pending' } }) });
       matters = matters.filter((m) => !url.includes('/' + String(m.id).split(':')[1]));
       return Promise.resolve({ ok: true, status: 200, json: async () => ({ ok: true }) });
     }
+    reads.push(url);
     const body = feeds()[url];
     return Promise.resolve(body === undefined ? { ok: false, json: async () => ({}) } : { ok: true, json: async () => body });
   };
@@ -301,7 +308,7 @@ async function bootPage(hash, ms, { refuse = false, over = {} } = {}) {
   await new Promise((r) => setTimeout(r, 0));
   const deskEl = () => (byId.get('insideOpenA').hidden ? byId.get('insideOpenB') : byId.get('insideOpenA'));
   const part = (cls) => deskEl().children.find((c) => c.className.split(' ').includes(cls));
-  return { window, byId, focused, sent, store, deskEl, part };
+  return { window, byId, focused, sent, store, deskEl, part, reads };
 }
 
 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 () => {
@@ -490,13 +497,16 @@ test('Automation: switch on and off, allow a goal from the open goals, first in
   assert.ok(!none.some((r) => r.actions.some((a) => a.key === 'allow')));
 });
 
-test('Review: a backend-only promise signs off in one tap; a recorded one goes to its page; force sign-off only with its atom', () => {
+test('Review: a backend-only promise signs off in one tap; a recorded one is recorded in place; force sign-off only with its atom', () => {
   const rows = actedRows(actedDocket(), 'review', 1);
   const backend = rows.find((r) => r.actions[0].key === 'signoff');
   assert.deepEqual(j(C.request(backend.card, 'signoff', backend.choices.signoff.options[0].input)), { method: 'POST', url: '/api/bongos/done-when/8/uat', body: { kind: 'backend_signoff', live_attested: true } });
   assert.deepEqual(j(C.request(backend.card, 'force', backend.choices.force.options[0].input)), { method: 'POST', url: '/api/bongos/done-when/8/satisfy', body: { override_reason: 'Signed off on the floor desk: tested by hand.' } });
   const ui = rows.find((r) => r.actions[0].key === 'record');
-  assert.equal(ui.actions[0].go, '/goals#/goal/4');
+  assert.equal(ui.actions[0].go, null, 'no link to the goal page (task 1004579)');
+  assert.equal(ui.actions[0].label, 'record it');
+  assert.deepEqual(j(ui.choices.record), { for: 'record', ask: 'the recording', file: true, options: [] }, 'it asks for the recording in place');
+  assert.ok(ui.actions.every((a) => !a.go), 'nothing on the row leaves the desk');
   const noForce = actedRows(actedDocket({ force: false }), 'review', 1);
   assert.ok(noForce.every((r) => !r.actions.some((a) => a.key === 'force')));
 });
@@ -515,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 } = {}) {
@@ -524,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]),
@@ -633,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');
@@ -935,3 +953,517 @@ test('walkthrough 1004531: a card act that records nothing takes no pip', async
   await settle();
   assert.equal(p.byId.get('streetTodayN').textContent, '0 decided', 'a refused act is not a decision');
 });
+
+// ── the recorded sign-off from the card (task 1004579) ───────────────────────
+// A promise that needs a recording is recorded in place: the file is picked or
+// dropped on its one line, sent with its progress on that line, then signed off
+// through the goal page's own two routes. The row clears, the meter takes a
+// pip, the toast speaks; a refused or failed upload says why on the line and
+// offers to try again, and counts nothing.
+const REC_NAME = 'uat-9-0123456789abcdef.mp4';
+const VIDEO = { name: 'walkthrough of the city.mp4', type: 'video/mp4', size: 12 * 1024 * 1024 };
+const uatMatters = () => [DK.normalizeMatter(lifeDocket.uatMatter({ id: 9, criterion_md: 'The city draws', goal_id: 4, shipped_total: 2, backend_only: false }, { force: false }), { source: 'criteria_uat', building: 'review' })];
+// an XMLHttpRequest stand-in: each send takes the next planned answer; `hold`
+// keeps it open until the test lets it go, so progress can be seen mid-flight
+function fakeXhr(plan = []) {
+  const calls = [];
+  const held = [];
+  class X {
+    constructor() { this.upload = {}; this.headers = {}; }
+    open(method, url) { this.method = method; this.url = url; }
+    setRequestHeader(k, v) { this.headers[k] = v; }
+    send(file) {
+      calls.push({ method: this.method, url: this.url, type: this.headers['Content-Type'], file, withCredentials: this.withCredentials, xhr: this });
+      const p = plan.shift() || { status: 201, body: { ok: true, recording: REC_NAME } };
+      const go = () => {
+        (p.progress || []).forEach((n) => this.upload.onprogress && this.upload.onprogress({ lengthComputable: true, loaded: n, total: 100 }));
+        if (p.status === 0) { this.onerror(); return; }
+        this.status = p.status;
+        this.responseText = JSON.stringify(p.body || {});
+        this.onload();
+      };
+      if (p.hold) held.push(go); else setTimeout(go, 0);
+    }
+  }
+  return { X, calls, held };
+}
+function walk(n, pred, out = []) {
+  if (!n) return out;
+  if (pred(n)) out.push(n);
+  (n.kids || []).forEach((k) => walk(k, pred, out));
+  return out;
+}
+const byAct = (root, act) => walk(root, (n) => n.attrs && n.attrs['data-act'] === act)[0];
+const recLine = (root) => walk(root, (n) => /\brec__line\b/.test(n.className))[0];
+const recBox = (root) => walk(root, (n) => /(^| )rec( |$)/.test(n.className))[0];
+const fileInput = (root) => walk(root, (n) => n.attrs && n.attrs.type === 'file')[0];
+function pickFile(root, file) {
+  const input = fileInput(root);
+  input.files = [file];
+  input.fire('change');
+}
+async function reviewDesk(opts = {}) {
+  const p = await bootPage('#building=review', uatMatters(), opts);
+  const row = () => p.part('desk-rows') && p.part('desk-rows').children[0];
+  return { ...p, row };
+}
+
+test('1004579 the line: what it says in each phase, in one line, with at most two chips', () => {
+  assert.deepEqual(j(C.recordLine({ phase: 'empty' })), { text: 'mp4 or webm, up to 100 MB', pct: null, busy: false, error: false, chips: [{ key: 'pick', label: 'pick or drop it' }] });
+  const picked = C.recordPick({}, VIDEO);
+  assert.equal(picked.phase, 'picked');
+  assert.deepEqual(j(C.recordLine(picked)).chips, [{ key: 'pick', label: 'pick another' }, { key: 'send', label: 'tested it live' }], 'the live attestation is the one-tap chip that sends it');
+  assert.equal(C.recordLine(picked).text, 'walkthrough of the city.mp4 · 12 MB');
+  assert.equal(C.recordLine({ file: VIDEO, phase: 'uploading', pct: 42 }).text, 'walkthrough of the city.mp4 · 42% sent');
+  assert.equal(C.recordLine({ file: VIDEO, phase: 'uploading', pct: 42 }).pct, 42);
+  assert.deepEqual(C.recordLine({ file: VIDEO, phase: 'uploading', pct: 42 }).chips, [], 'nothing to tap while it is sent');
+  assert.equal(C.recordLine({ file: VIDEO, phase: 'signing' }).text, 'walkthrough of the city.mp4 · sent, signing off…');
+  for (const st of [{ phase: 'empty' }, picked, { file: VIDEO, phase: 'uploading', pct: 99 }, { file: VIDEO, phase: 'failed', why: C.recordWhy(0, {}), retry: true }]) {
+    const ln = C.recordLine(st);
+    assert.ok(!/[\r\n]/.test(ln.text), 'one line');
+    assert.ok(ln.chips.length <= 2, 'at most two chips');
+    assert.ok(ln.chips.every((c) => c.label.length <= D.LIMITS.chip), 'each chip within the desk chip cap');
+  }
+  const long = C.recordPick({}, { name: 'a very long name for a screen recording of the whole walkthrough.webm', type: 'video/webm', size: 2048 });
+  assert.ok(C.recordLine(long).text.length <= 40, 'a long file name is cut, never wrapped');
+});
+
+test('1004579 a wrong file says why before anything is sent, and asks for another', () => {
+  const st = C.recordPick({}, { name: 'notes.pdf', type: 'application/pdf', size: 100 });
+  assert.equal(st.phase, 'failed');
+  assert.equal(st.why, 'Only an mp4 or webm video can go.');
+  assert.deepEqual(j(C.recordLine(st).chips), [{ key: 'pick', label: 'pick another' }], 'no "try again" for a file that cannot go');
+  assert.equal(C.recordPick({}, { name: 'big.mp4', type: 'video/mp4', size: C.RECORD_MAX + 1 }).why, 'Over the 100 MB cap. Record a shorter pass.');
+  assert.equal(C.recordPick({}, { name: 'empty.webm', type: 'video/webm', size: 0 }).why, 'That file is empty.');
+  assert.deepEqual(C.RECORD_TYPES, ['video/mp4', 'video/webm']);
+  const lifecycle = SRV('modules/lifecycle/criterion-uat.js');
+  assert.deepEqual(C.RECORD_TYPES.slice().sort(), Object.keys(lifecycle.EXT_BY_TYPE).sort(), 'the same types the server stores');
+  assert.equal(C.RECORD_MAX, lifecycle.MAX_RECORDING_BYTES, 'the same cap the server screens');
+});
+
+test('1004579 the routes are the goal page\'s own two: the raw video, then the sign-off with its stored name', () => {
+  const r = C.recordRoutes(9);
+  assert.equal(r.upload, '/api/bongos/done-when/9/uat/recording');
+  assert.deepEqual(j(r.signoff(REC_NAME)), { method: 'POST', url: '/api/bongos/done-when/9/uat', body: { kind: 'uat', recording: REC_NAME, live_attested: true } });
+  const old = read('criterion-uat-ui.js');
+  assert.match(old, /\/done-when\/\$\{encodeURIComponent\(id\)\}\/uat\/recording/, 'the goal page uploads to the same route');
+  assert.match(old, /kind: backend \? 'backend_signoff' : 'uat'/, 'and signs off with the same kind');
+  const route = read('../../lifecycle/routes/criterion-uat.js');
+  assert.match(route, /router\.post\('\/done-when\/:criterionId\/uat\/recording'/);
+  assert.match(route, /router\.post\('\/done-when\/:criterionId\/uat',/);
+});
+
+test('1004579 a refusal is one short sentence a person can act on', () => {
+  const said = [
+    [413, {}],
+    [400, { error: { code: 'bad_type', message: 'A UAT recording must be an mp4 or webm video.' } }],
+    [403, { error: { code: 'signer_shipped_this_work', message: 'You shipped work linked to this criterion, so someone else has to sign it off. Any other reviewer, or the project owner, can.' } }],
+    [409, { error: { code: 'work_not_live', message: 'Some of this work is shipped but not running on the site yet.' } }],
+    [0, {}],
+    [500, { error: { code: 'uat_signoff_failed', message: 'uat_signoff_failed' } }],
+    [409, { error: { code: 'something_new', message: 'A brand new refusal from the server. With a second sentence that goes on and on.' } }],
+  ].map(([s, b]) => C.recordWhy(s, b));
+  assert.deepEqual(said, [
+    'Over the 100 MB cap. Record a shorter pass.',
+    'Only an mp4 or webm video can go.',
+    'You built this, so someone else signs it off.',
+    'It is not on the live site yet. Sign off once it is.',
+    'The upload broke off. Try again.',
+    'It did not go through. Try again.',
+    'A brand new refusal from the server.',
+  ]);
+  for (const w of said) { assert.ok(w.length <= 72, w); assert.ok(!/[\r\n]/.test(w)); }
+});
+
+test('1004579 recordRun: sends the video with its progress, then signs off with the stored name', async () => {
+  const st = C.recordPick({}, VIDEO);
+  const phases = [];
+  const pcts = [];
+  const sent = [];
+  const out = await C.recordRun('9', st, {
+    upload: async (url, file, onPct) => { assert.equal(url, '/api/bongos/done-when/9/uat/recording'); assert.equal(file, VIDEO); onPct(30); onPct(80); return { ok: true, status: 201, body: { recording: REC_NAME } }; },
+    send: async (req) => { sent.push(j(req)); return { ok: true, status: 201, body: { ok: true, criterion_closed: true } }; },
+    change: (s) => phases.push(s.phase),
+    progress: (s) => pcts.push(s.pct),
+  });
+  assert.equal(out.ok, true);
+  assert.deepEqual(phases, ['uploading', 'signing']);
+  assert.deepEqual(pcts, [30, 80]);
+  assert.deepEqual(sent, [{ method: 'POST', url: '/api/bongos/done-when/9/uat', body: { kind: 'uat', recording: REC_NAME, live_attested: true } }]);
+  assert.equal(st.phase, 'done');
+});
+
+test('1004579 recordRun: a failed upload says why and offers to try again; a refused sign-off keeps the upload, so trying again does not send the video twice', async () => {
+  const st = C.recordPick({}, VIDEO);
+  let uploads = 0;
+  const broke = await C.recordRun('9', st, { upload: async () => { uploads += 1; return { ok: false, status: 0, body: {} }; }, send: async () => assert.fail('no sign-off after a failed upload') });
+  assert.equal(broke.ok, false);
+  assert.equal(st.phase, 'failed');
+  assert.equal(C.recordLine(st).text, 'The upload broke off. Try again.');
+  assert.deepEqual(C.recordLine(st).chips.map((c) => c.label), ['try again', 'pick another']);
+  let signs = 0;
+  const refused = await C.recordRun('9', st, {
+    upload: async () => { uploads += 1; return { ok: true, status: 201, body: { recording: REC_NAME } }; },
+    send: async () => { signs += 1; return signs === 1 ? { ok: false, status: 409, body: { error: { code: 'work_not_live', message: 'x' } } } : { ok: true, status: 201, body: {} }; },
+  });
+  assert.equal(refused.ok, false);
+  assert.equal(C.recordLine(st).text, 'It is not on the live site yet. Sign off once it is.');
+  assert.equal(st.recording, REC_NAME, 'the stored recording is kept');
+  const again = await C.recordRun('9', st, { upload: async () => assert.fail('the video is not sent twice'), send: async () => { signs += 1; return { ok: true, status: 201, body: {} }; } });
+  assert.equal(again.ok, true);
+  assert.equal(uploads, 2);
+  // a refusal no new try can fix offers neither a retry nor (for a sign-off that is not yours) another file
+  const mine = C.recordPick({}, VIDEO);
+  await C.recordRun('9', mine, { upload: async () => ({ ok: true, status: 201, body: { recording: REC_NAME } }), send: async () => ({ ok: false, status: 403, body: { error: { code: 'signer_shipped_this_work' } } }) });
+  assert.deepEqual(C.recordLine(mine).chips, [], 'you built it: nothing to tap but close');
+  assert.equal(C.recordLine(mine).text, 'You built this, so someone else signs it off.');
+  // a file the server refused asks for another file, not the same one again
+  const odd = C.recordPick({}, VIDEO);
+  await C.recordRun('9', odd, { upload: async () => ({ ok: false, status: 400, body: { error: { code: 'sniff_mismatch' } } }), send: async () => assert.fail() });
+  assert.deepEqual(C.recordLine(odd).chips.map((c) => c.key), ['pick']);
+});
+
+test('1004579 uploadXhr: the raw file with its type, its progress, and the answer', async () => {
+  const x = fakeXhr([{ status: 201, body: { ok: true, recording: REC_NAME }, progress: [25, 50, 100] }]);
+  const pcts = [];
+  const out = await C.uploadXhr(x.X, '/api/bongos/done-when/9/uat/recording', VIDEO, (p) => pcts.push(p));
+  assert.deepEqual(out, { ok: true, status: 201, body: { ok: true, recording: REC_NAME } });
+  assert.deepEqual(x.calls.map((c) => [c.method, c.url, c.type, c.file === VIDEO, c.withCredentials]), [['POST', '/api/bongos/done-when/9/uat/recording', 'video/mp4', true, true]]);
+  assert.deepEqual(pcts, [25, 50, 99], 'the bar stops short of full until the server has answered');
+  const broke = await C.uploadXhr(fakeXhr([{ status: 0 }]).X, '/u', VIDEO, () => {});
+  assert.deepEqual(broke, { ok: false, status: 0, body: {} });
+  const none = await C.uploadXhr(undefined, '/u', VIDEO, () => {});
+  assert.equal(none.ok, false, 'no XMLHttpRequest: a failure, never a throw');
+});
+
+test('1004579 the page: record it opens its line in place, the upload shows its progress, and the sign-off clears the row', async () => {
+  const x = fakeXhr([{ status: 201, body: { ok: true, recording: REC_NAME }, hold: true }]);
+  const p = await reviewDesk({ xhr: x.X });
+  assert.equal(p.byId.get('insideFloors').children[1].attrs['aria-pressed'], 'true', 'Review opens on the promises waiting for a tester');
+  const acts = p.row().children[0].children[2].children;
+  assert.deepEqual(acts.map((b) => b.textContent), ['record it']);
+  assert.ok(walk(p.deskEl(), (n) => n.tagName === 'a').length === 0, 'no link on the desk');
+  acts[0].fire('click');
+  const strip = p.row().children[1];
+  assert.equal(strip.className, 'desk-choices');
+  assert.equal(strip.children[0].textContent, 'the recording');
+  assert.equal(recLine(strip).textContent, 'mp4 or webm, up to 100 MB');
+  assert.equal(fileInput(strip).attrs.accept, 'video/mp4,video/webm');
+  pickFile(strip, VIDEO);
+  assert.equal(recLine(p.row()).textContent, 'walkthrough of the city.mp4 · 12 MB');
+  const go = byAct(p.row(), 'record-send');
+  assert.equal(go.textContent, 'tested it live');
+  assert.equal(p.focused.el, go, 'focus moves to the chip that sends it');
+  go.fire('click');
+  await settle();
+  assert.equal(x.calls.length, 1, 'the video went up');
+  assert.match(recLine(p.row()).textContent, /0% sent$/);
+  const line = recLine(p.row());
+  x.held.shift()();
+  await settle();
+  assert.equal(p.sent.length, 1, 'then the sign-off');
+  assert.deepEqual(p.sent[0], { method: 'POST', url: '/api/bongos/done-when/9/uat', body: { kind: 'uat', recording: REC_NAME, live_attested: true } });
+  await new Promise((r) => setTimeout(r, 360));
+  await settle();
+  assert.equal(p.part('desk-rows'), undefined, 'the row cleared away');
+  assert.ok(p.part('desk-quiet').className.includes('desk-quiet--cleared'), 'the floor lights');
+  assert.equal(p.byId.get('streetTodayN').textContent, '1 decided', 'the meter takes a pip');
+  assert.equal(p.byId.get('streetToast').textContent, 'Signed off with the recording. The promise counts as kept.');
+  assert.match(p.byId.get('streetToast').className, /street-toast--desk/);
+  assert.equal(p.part('desk-record').children[1].textContent, 'signed off The city dra… · now', 'the record gains the line (cut at the record cap)');
+  assert.ok(line, 'the line was drawn while it was sent');
+});
+
+test('1004579 the page: progress is painted on the line in place while the video is sent', async () => {
+  const x = fakeXhr([{ status: 201, body: { ok: true, recording: REC_NAME }, hold: true }]);
+  const p = await reviewDesk({ xhr: x.X });
+  p.row().children[0].children[2].children[0].fire('click');
+  pickFile(p.row(), VIDEO);
+  byAct(p.row(), 'record-send').fire('click');
+  await settle();
+  const line = recLine(p.row());
+  const fill = walk(p.row(), (n) => n.className === 'rec__fill')[0];
+  assert.ok(walk(p.row(), (n) => /\brec--busy\b/.test(n.className))[0], 'the line reads as busy while it is sent');
+  assert.equal(fileInput(p.row()), undefined, 'no file chip while it is sent');
+  assert.equal(line.textContent, 'walkthrough of the city.mp4 · 0% sent');
+  assert.equal(fill.style.width, '0%');
+  // the open request reports progress through its own upload hook
+  x.calls[0].xhr.upload.onprogress({ lengthComputable: true, loaded: 42, total: 100 });
+  assert.equal(recLine(p.row()), line, 'the same line node: progress never redraws the desk');
+  assert.equal(line.textContent, 'walkthrough of the city.mp4 · 42% sent');
+  assert.equal(fill.style.width, '42%', 'the bar fills');
+  x.calls[0].xhr.upload.onprogress({ lengthComputable: true, loaded: 100, total: 100 });
+  assert.equal(line.textContent, 'walkthrough of the city.mp4 · 99% sent', 'never full before the server answers');
+  x.held.shift()();
+  await settle();
+  assert.equal(p.sent.length, 1, 'the sign-off follows the upload');
+});
+
+test('1004579 the page: a refused upload says why on the line, keeps the row, counts nothing, and lets them try again', async () => {
+  const x = fakeXhr([{ status: 413, body: {} }, { status: 0 }, { status: 201, body: { ok: true, recording: REC_NAME } }]);
+  const p = await reviewDesk({ xhr: x.X });
+  p.row().children[0].children[2].children[0].fire('click');
+  pickFile(p.row(), VIDEO);
+  byAct(p.row(), 'record-send').fire('click');
+  await settle();
+  assert.equal(recLine(p.row()).textContent, 'Over the 100 MB cap. Record a shorter pass.');
+  assert.equal(recLine(p.row()).attrs.role, 'alert', 'the why is said, not just shown');
+  assert.equal(recBox(p.row()).attrs['data-record'], 'failed');
+  assert.equal(byAct(p.row(), 'record-send'), undefined, 'a file over the cap is not offered again');
+  assert.ok(fileInput(p.row()), 'pick another is offered');
+  assert.equal(p.byId.get('streetTodayN').textContent, '0 decided');
+  assert.equal(p.sent.length, 0, 'no sign-off after a refused upload');
+  assert.equal(p.part('desk-rows').children.length, 1, 'the row stays');
+  // another file; the connection breaks; try again goes through
+  pickFile(p.row(), VIDEO);
+  byAct(p.row(), 'record-send').fire('click');
+  await settle();
+  assert.equal(recLine(p.row()).textContent, 'The upload broke off. Try again.');
+  const retry = byAct(p.row(), 'record-send');
+  assert.equal(retry.textContent, 'try again');
+  retry.fire('click');
+  await settle();
+  await new Promise((r) => setTimeout(r, 360));
+  await settle();
+  assert.equal(x.calls.length, 3);
+  assert.equal(p.sent.length, 1);
+  assert.equal(p.part('desk-rows'), undefined, 'signed off on the retry: the row cleared');
+  assert.equal(p.byId.get('streetTodayN').textContent, '1 decided');
+});
+
+test('1004579 the page: a refused sign-off says why on the line; nothing is counted', async () => {
+  const x = fakeXhr();
+  const p = await reviewDesk({ xhr: x.X, answer: (url) => (/\/uat$/.test(url) ? { status: 403, body: { error: { code: 'signer_shipped_this_work', message: 'You shipped work linked to this criterion.' } } } : null) });
+  p.row().children[0].children[2].children[0].fire('click');
+  pickFile(p.row(), VIDEO);
+  byAct(p.row(), 'record-send').fire('click');
+  await settle();
+  assert.equal(recLine(p.row()).textContent, 'You built this, so someone else signs it off.');
+  assert.equal(p.byId.get('streetToast').hidden, true, 'the line says it; no toast claims a decision');
+  assert.equal(p.byId.get('streetTodayN').textContent, '0 decided');
+  assert.equal(p.part('desk-rows').children.length, 1);
+});
+
+test('1004579 the page: a recording dropped on its row is taken and its line opens', async () => {
+  const p = await reviewDesk({ xhr: fakeXhr().X });
+  const row = p.row();
+  row.listeners.drop[0]({ preventDefault() {}, dataTransfer: { files: [VIDEO] } });
+  assert.equal(recLine(p.row()).textContent, 'walkthrough of the city.mp4 · 12 MB');
+  assert.equal(byAct(p.row(), 'record-send').textContent, 'tested it live');
+});
+
+test('1004579 the page: tapping its name opens the goal page\'s three checks in place', async () => {
+  const view = { uat_state: 'awaiting_uat', checks: { code: true, live: { available: true, live: true }, uat: null, stale_uat: null } };
+  const p = await reviewDesk({ xhr: fakeXhr().X, extra: { '/api/bongos/done-when/9/uat': view } });
+  p.row().children[0].children[1].fire('click');
+  await settle();
+  assert.ok(p.reads.includes('/api/bongos/done-when/9/uat'), 'the same read the goal page opens');
+  assert.deepEqual(p.row().children[1].children.map((x) => x.textContent), ['code done', 'running live', 'not signed off yet']);
+  assert.deepEqual(D.breaks({ ...D.deskModel({ key: 'review', floor: 1, docket: docket(uatMatters()), now: NOW }) }), []);
+});
+
+test('1004579 the card: record it on the street card records in place too, and the card closes on the sign-off', async () => {
+  const x = fakeXhr();
+  const view = { uat_state: 'awaiting_uat', checks: { code: true, live: { available: false }, uat: null, stale_uat: { signed_off_by_login: 'mira', created_at: '2026-09-30T10:00:00.000Z' } } };
+  const p = await bootPage('', uatMatters(), { xhr: x.X, extra: { '/api/bongos/done-when/9/uat': view } });
+  p.window.GovStreetPage.openCard('criteria_uat:9');
+  const body = p.byId.get('streetCardBody');
+  const rec = byAct(body, 'record');
+  assert.equal(rec.tagName, 'button', 'a button, not a link');
+  assert.equal(walk(body, (n) => n.tagName === 'a').length, 0, 'no link on the card');
+  // more: the checks the goal page showed
+  byAct(body, 'more').fire('click');
+  await settle();
+  const more = walk(body, (n) => n.className === 'mcard-more')[0];
+  const words = walk(more, (n) => n.className === 'mcard-more__text').map((n) => n.textContent);
+  assert.ok(words.includes('code · every linked task is done'));
+  assert.ok(words.includes('live · this site cannot tell, so the sign-off says you tried it live'));
+  assert.ok(words.some((w) => /^sign-off · an earlier one by mira on .* no longer counts/.test(w)));
+  byAct(body, 'more').fire('click');
+  byAct(body, 'record').fire('click');
+  assert.equal(walk(body, (n) => n.className === 'mcard-chips__ask')[0].textContent, 'the recording');
+  pickFile(body, VIDEO);
+  assert.equal(recLine(body).textContent, 'walkthrough of the city.mp4 · 12 MB');
+  byAct(body, 'record-send').fire('click');
+  await settle();
+  await settle();
+  assert.equal(x.calls.length, 1);
+  assert.deepEqual(p.sent, [{ method: 'POST', url: '/api/bongos/done-when/9/uat', body: { kind: 'uat', recording: REC_NAME, live_attested: true } }]);
+  assert.equal(p.byId.get('streetCard').hidden, true, 'the card closes: the matter is done');
+  assert.equal(p.byId.get('streetTodayN').textContent, '1 decided');
+  assert.equal(p.byId.get('streetToast').textContent, 'Signed off with the recording. The promise counts as kept.');
+});
+
+test('1004579 the card: a failed upload says why on the card\'s line and keeps the card open', async () => {
+  const x = fakeXhr([{ status: 400, body: { error: { code: 'bad_type', message: 'A UAT recording must be an mp4 or webm video.' } } }]);
+  const p = await bootPage('', uatMatters(), { xhr: x.X });
+  p.window.GovStreetPage.openCard('criteria_uat:9');
+  const body = p.byId.get('streetCardBody');
+  byAct(body, 'record').fire('click');
+  pickFile(body, VIDEO);
+  byAct(body, 'record-send').fire('click');
+  await settle();
+  assert.equal(recLine(body).textContent, 'Only an mp4 or webm video can go.');
+  assert.equal(p.byId.get('streetCard').hidden, false);
+  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');
+});