@bongos/core 1.21.34 → 1.21.35

package/modules/hall-ui/public/street-desk.js

@@ -97,7 +97,23 @@
     gate_approvals: 'Everything ready is live', blockers: 'Nothing blocked on you', board: 'Every vote is in', idea: 'No ideas waiting',
   });
   // The card's acts under the desk's words (the board's button labels).
-  const ACT_WORDS = Object.freeze({ for: 'yes', object: 'no', fine: 'let in', refuse: 'not now', release: 'release', hold: 'hold' });
+  const ACT_WORDS = Object.freeze({
+    for: 'yes', object: 'no', fine: 'let in', refuse: 'not now', release: 'release', hold: 'hold',
+    // the acts the server hands a row (task 1004559), each its old page's route
+    confirm: 'confirm', dispute: 'dispute', fix: 'fixed', remove: 'remove', keep: 'keep',
+    signoff: 'sign off', record: 'record it', force: 'force',
+    switch_on: 'switch on', switch_off: 'switch off', allow: 'allow', disallow: 'disallow', first: 'first',
+    pause: 'pause', resume: 'resume', tier: 'tier', deactivate: 'deactivate', give: 'give', take: 'take back',
+    check: 'check', take_core: 'take it', rot: 'set', module_on: 'turn on', module_off: 'turn off', backup: 'back up', invite: 'invite', open: 'open',
+  });
+  // What a row's chips ask, per act (a reason or an option is one tap, never text).
+  const ASKS = Object.freeze({ check: 'check', take_core: 'move to', rot: 'stale after', module_off: 'sure', invite: 'their GitHub name', object: 'why', force: 'why', switch_off: 'why', pause: 'why', deactivate: 'why', signoff: 'confirm', allow: 'which goal', tier: 'which tier', give: 'to whom', take: 'from whom' });
+  // How a floor counts rows nobody is waiting on (desk rows), by its desk.
+  const DESK_NOUNS = Object.freeze({
+    'people.builders': 'builders', 'people.ranks': 'ranks', 'disputes.confirmed': 'to fix',
+    'automation.switch': 'switch', 'automation.goals': 'allowed', 'automation.runners': 'runners',
+    'people.invite': 'invites', 'release.core': 'update', 'rules.settings': 'settings', 'rules.modules': 'modules', 'treasury.backup': 'backups',
+  });
   // An objection's reason as one tap: the five sections the server accepts
   // (street-card.js SECTIONS), each in at most 16 characters.
   const CHIPS = Object.freeze({ scope: 'what it changes', purpose: 'its purpose', why_matters: 'why it matters', fit: 'how it fits', success: 'how to measure' });
@@ -161,6 +177,13 @@
     if (when) add('closes ' + when);
     if (m.where) add(str(m.where).toLowerCase());
     add(STATE[stateOf(m)]);
+    if (Array.isArray(m.acts) && m.acts.length && C && C.actsCard) {
+      const ac = C.actsCard({ key: m.id, kind: m.source, id: m.ref && m.ref.id != null ? m.ref.id : str(m.id).replace(/^[^:]*:/, ''), who: person || name, title: m.title, building: m.building, href: m.href });
+      return Object.assign(actedRow(m.acts, ac, ctx), {
+        key: str(m.id), matter: str(m.id), ini: initials(name), name: name, fact: fact, facts: facts,
+        needs: stateOf(m) === 'needs', source: m.source, opened: m.opened_at || null,
+      });
+    }
     const cv = C && C.model ? C.model({ docket: ctx.docket, key: m.id, room: ctx.room, constitution: ctx.constitution, now: now, viewerId: ctx.viewerId }) : null;
     const actions = [];
     let chips = null;
@@ -176,13 +199,82 @@
     const wait = actions.length ? '' : cv && cv.loading ? 'reading…' : stateOf(m) === 'needs' ? 'not from here' : 'moving';
     return {
       key: str(m.id), matter: str(m.id), ini: initials(name), name: name, fact: fact, facts: facts,
-      actions: actions, chips: chips, wait: wait, needs: stateOf(m) === 'needs', source: m.source, opened: m.opened_at || null, card: cv,
+      actions: actions, chips: chips, choices: chips ? { [chips.for]: chips } : {}, wait: wait, needs: stateOf(m) === 'needs', source: m.source, opened: m.opened_at || null, card: cv,
     };
   }
+
+  // The buttons and chips of a row whose acts the server handed it (task
+  // 1004559). An act with options asks first, with its options as one-tap chips;
+  // `pick: 'open_goals'` offers the open goals the street already reads; an act
+  // whose chips come out empty is left off rather than drawn dead. 'record'
+  // goes to the matter's own page (a sign-off that needs a recording).
+  function actedRow(acts, card, ctx) {
+    const titles = new Map((ctx.goals || []).map((g) => [str(g.id), str(g.title || 'goal ' + g.id)]));
+    const actions = [];
+    const choices = {};
+    acts.forEach((a) => {
+      // the core's 'take' is its own word ('take it'), not the rank's 'take back'
+      const word = a.key === 'take' && card.subject && card.subject.kind === 'core_pin' ? 'take_core' : a.key;
+      if (actions.length >= LIMITS.actions || !ACT_WORDS[word]) return;
+      let options = (a.options || []).map((o) => ({ key: str(o.key), label: fit(o.label, LIMITS.chip), input: { option: str(o.key), label: str(o.label) } }));
+      if (a.pick === 'open_goals') {
+        const except = new Set((a.except || []).map(str));
+        options = (ctx.goals || []).filter((g) => g && !except.has(str(g.id))).slice(0, LIMITS.chips)
+          .map((g) => ({ key: str(g.id), label: fit(titles.get(str(g.id)), LIMITS.chip), input: { option: str(g.id), label: titles.get(str(g.id)) } }));
+        if (!options.length) return;
+      }
+      options = options.slice(0, LIMITS.chips);
+      const goes = a.key === 'record' || a.key === 'open';
+      if (goes && !card.href) return;
+      const field = a.field || null;
+      const ask = options.length > 0 || !!field;
+      if (ask) choices[a.key] = field ? { for: a.key, ask: ASKS[word] || 'which', field: field, options: [] } : { for: a.key, ask: ASKS[word] || 'which', options: options };
+      actions.push({ key: a.key, label: ACT_WORDS[word], tone: actions.length ? 'quiet' : 'primary', go: goes ? card.href : null, ask: ask });
+    });
+    const first = actions.find((a) => a.ask);
+    return { actions: actions, chips: first ? choices[first.key] : null, choices: choices, wait: actions.length ? '' : 'not from here', card: card };
+  }
+
+  // A desk row (task 1004559): something on this floor the viewer may act on that
+  // no one is waiting on, read by the module that owns its route.
+  function deskRowOf(d, ctx) {
+    const titles = new Map((ctx.goals || []).map((g) => [str(g.id), str(g.title || '')]));
+    const hit = /^goal (\d+)$/.exec(str(d.name));
+    const full = hit && titles.get(hit[1]) ? titles.get(hit[1]) : str(d.name);
+    const name = fit(full, LIMITS.name, LIMITS.nameWords);
+    const age = ageWord(d.opened_at, ctx.now || 0);
+    const facts = [];
+    const add = (t) => { const v = fit(t, LIMITS.factLen); if (v && facts.indexOf(v) < 0 && facts.length < LIMITS.facts) facts.push(v); };
+    if (full !== name) add(full);
+    (d.facts || []).forEach(add);
+    if (age) add('since ' + age);
+    const ref = d.ref || {};
+    const card = C && C.actsCard ? C.actsCard({ key: d.id, kind: ref.type, id: ref.id, who: full, title: full, building: d.building, href: d.href }) : null;
+    return Object.assign(actedRow(d.acts || [], card || { href: null }, ctx), {
+      key: str(d.id), matter: str(d.id), ini: initials(name), name: name, fact: fit(d.fact, LIMITS.fact), facts: facts,
+      needs: d.needs === true, source: d.desk, opened: d.opened_at || null, desk: true, tool: d.tool === true, over: d.over || null,
+    });
+  }
+  // The desk rows of one floor: those of the desk its PLAN entry names.
+  function deskRows(key, floor, docket, ctx) {
+    const plan = I && I.PLAN[key];
+    const spec = plan && plan.floors[floor];
+    const bind = (spec && spec[2]) || {};
+    if (!bind.desk || !docket || !Array.isArray(docket.desks)) return [];
+    // a floor may hold more than one desk (Rules in force: the settings and the modules)
+    const keys = [].concat(bind.desk);
+    return docket.desks.filter((x) => x && keys.indexOf(x.key) >= 0 && x.status === 'live' && Array.isArray(x.rows))
+      .reduce((all, x) => all.concat(x.rows.filter((r) => r && r.building === key)), []);
+  }
   function rowsFor(key, floor, docket, ctx) {
     const c = Object.assign({ docket: docket }, ctx || {});
     const done = c.done || {};
-    return floorMatters(key, floor, docket).filter((m) => !done[str(m.id)]).map((m) => rowOf(m, c))
+    const desked = deskRows(key, floor, docket).filter((d) => !done[str(d.id)]).map((d) => deskRowOf(d, c)).filter((r) => r.actions.length);
+    // a desk row that stands in for a source (the core update's check-then-take)
+    // replaces that source's matter rows on this floor
+    const over = desked.map((r) => r.over).filter(Boolean);
+    return floorMatters(key, floor, docket).filter((m) => !done[str(m.id)] && over.indexOf(m.source) < 0).map((m) => rowOf(m, c))
+      .concat(desked)
       .sort((a, b) => (b.needs - a.needs) || ((Date.parse(a.opened || 0) || 0) - (Date.parse(b.opened || 0) || 0)));
   }
 
@@ -199,19 +291,23 @@
     const floor = Math.max(0, Math.min(Number(o.floor) || 0, plan.floors.length - 1));
     const spec = plan.floors[floor];
     const fl = I.floorFor(spec, { key: o.key, docket: docket, goals: o.goals || [], now: o.now || 0 });
-    const ctx = { room: o.room, constitution: o.constitution, now: o.now || 0, viewerId: o.viewerId, done: o.done };
+    const ctx = { room: o.room, constitution: o.constitution, now: o.now || 0, viewerId: o.viewerId, done: o.done, goals: o.goals || [] };
     const rows = docket ? rowsFor(o.key, floor, docket, ctx) : [];
     const bind = spec[2] || {};
     const src = bind.source ? bind.source : bind.floor === 'planning.ideas' ? 'idea' : floor === 0 ? 'board' : null;
     const needs = rows.filter((r) => r.needs);
     const noun = NOUNS[src] || 'open';
+    // rows nobody waits on: 'moving' for matters, the desk's own noun for desk rows
+    const moving = rows.length && rows.every((r) => r.desk) ? (DESK_NOUNS[rows[0].source] || 'here') : 'moving';
+    const counted = rows.filter((r) => !r.tool);
     const oldestOf = (list) => list.reduce((a, r) => (r.opened && (!a || Date.parse(r.opened) < Date.parse(a)) ? r.opened : a), null);
     const cleared = !!o.cleared && rows.length === 0;
     const quiet = rows.length === 0;
     let status, hot = false;
     if (!docket) status = 'the docket could not be read';
     else if (needs.length) { hot = true; const age = ageWord(oldestOf(needs), o.now); status = needs.length + ' ' + noun + (age ? ' · oldest ' + age : ''); }
-    else if (rows.length) { const age = ageWord(oldestOf(rows), o.now); status = rows.length + ' moving' + (age ? ' · oldest ' + age : ''); }
+    else if (counted.length) { const age = ageWord(oldestOf(counted), o.now); status = counted.length + ' ' + moving + (age ? ' · oldest ' + age : ''); }
+    else if (rows.length) status = fl.line;
     else if (cleared) status = 'floor clear';
     else status = 'nothing needs you · ' + fl.line;
     const history = docket && Array.isArray(docket.history) ? docket.history.filter((h) => h && h.building === o.key) : [];
@@ -224,7 +320,7 @@
       const words = str(l).replace(/\s+/g, ' ').trim().split(' ').slice(0, LIMITS.tileWords).join(' ').replace(/[,.;:·-]+$/, '');
       tiles.push({ key: 't' + tiles.length, v: fit(val, LIMITS.tileValue), l: fit(words, LIMITS.tileLabel) });
     };
-    if (rows.length) { tile(needs.length, noun); tile(rows.length - needs.length, 'moving'); }
+    if (rows.length) { tile(needs.length, noun); tile(counted.length - needs.length, moving); }
     else if (fl.count) tile(fl.count, str(fl.line).replace(/^[$]?[0-9][0-9,.%]*\s*/, '') || 'on this floor');
     tile(history.length, 'on record');
     const record = (o.mine || []).map((t, i) => ({ key: 'm' + i, text: fit(t + ' · now', LIMITS.recordLen), mine: true }))
@@ -263,6 +359,11 @@
       if (r.facts.length > LIMITS.facts || r.facts.some((f) => !oneLine(f) || f.length > LIMITS.factLen)) bad('row facts', r.facts);
       if (r.chips && (r.chips.options.length > LIMITS.chips || r.chips.options.some((c) => c.label.length > LIMITS.chip))) bad('chips', r.chips.options.map((c) => c.label));
       if (r.actions.some((a) => a.ask) && !r.chips) bad('a reason without chips', r.name);
+      Object.keys(r.choices || {}).forEach((k) => {
+        const c = r.choices[k];
+        if ((!c.field && !c.options.length) || c.options.length > LIMITS.chips || c.options.some((x) => !x.label || x.label.length > LIMITS.chip)) bad('chips', c.options.map((x) => x.label));
+      });
+      if (r.actions.some((a) => a.ask && !(r.choices || {})[a.key])) bad('an ask without its own chips', r.name);
     });
     if (desk.record.length > LIMITS.record || desk.record.some((x) => !oneLine(x.text) || x.text.length > LIMITS.recordLen)) bad('record line', desk.record.map((x) => x.text));
     return out;
@@ -277,7 +378,7 @@
   }
 
   const api = {
-    LIMITS: LIMITS, ACT_WORDS: ACT_WORDS, CHIPS: CHIPS, NOUNS: NOUNS, CLEAR: CLEAR,
+    LIMITS: LIMITS, ACT_WORDS: ACT_WORDS, ASKS: ASKS, DESK_NOUNS: DESK_NOUNS, CHIPS: CHIPS, NOUNS: NOUNS, CLEAR: CLEAR,
     fit: fit, ageWord: ageWord, floorMatters: floorMatters, firstNeeds: firstNeeds, rowsFor: rowsFor, deskModel: deskModel, breaks: breaks, todayPips: todayPips,
   };
   root.GovDesk = api;

package/modules/hall-ui/public/street-inside.js

@@ -331,17 +331,17 @@
     rules: {
       holds: 'Standing rules. Each one settles a kind of matter so the council never votes on it again.', rule: 'majority', cap: 8,
       growth: 'When the hall fills, the council can open an annex for one area, such as money rules.', annex: 'room for an annex, such as money rules',
-      floors: [['Rules in force', 'the rules settling matters now', { floor: 'rules.in_force', reading: 'rules' }], ['New rules', 'a rule put to the council', { source: 'standing_rules' }]],
+      floors: [['Rules in force', 'the rules settling matters now', { floor: 'rules.in_force', reading: 'rules', desk: ['rules.settings', 'rules.modules'] }], ['New rules', 'a rule put to the council', { source: 'standing_rules' }]],
     },
     disputes: {
       holds: 'Grade appeals, removal requests and security reports. Every ruling becomes precedent for the next one.', rule: 'decide', cap: 5,
       growth: 'Busy weeks go to a panel of three once a second room is built.', annex: 'room for a second room, a panel of three',
-      floors: [['Security reports', 'flaws found in our own walls', { source: 'redteam_reports' }], ['Removals', 'work proposed for removal', { source: 'removal_proposals' }], ['Grade appeals', 'a grade someone asks to change', { source: 'grade_appeals' }]],
+      floors: [['Security reports', 'flaws found in our own walls', { source: 'redteam_reports', desk: 'disputes.confirmed' }], ['Removals', 'work proposed for removal', { source: 'removal_proposals' }], ['Grade appeals', 'a grade someone asks to change', { source: 'grade_appeals' }]],
     },
     people: {
       holds: 'Who belongs, the rank each person holds, and who sits in which seat.', rule: 'consent', cap: 8,
       growth: 'A new floor opens whenever the charter creates a new seat.', annex: 'room for an annex of seats',
-      floors: [['The council', 'who sits, and for how long', { floor: 'people.council' }], ['Testers', 'who signs off finished work', { floor: 'people.testers' }], ['Builders', 'who builds here', { reading: 'people' }], ['Newcomers', 'builders on newcomer tasks', { floor: 'people.newcomers' }], ['Waiting to join', 'asked to join the project', { source: 'access_requests' }], ['Ranks', 'the ranks, and who holds each', { floor: 'people.ranks' }], ['Goal teams', 'asked to join a goal team', { source: 'goal_join_requests' }]],
+      floors: [['The council', 'who sits, and for how long', { floor: 'people.council' }], ['Testers', 'who signs off finished work', { floor: 'people.testers' }], ['Builders', 'who builds here', { reading: 'people', desk: 'people.builders' }], ['Newcomers', 'builders on newcomer tasks', { floor: 'people.newcomers' }], ['Waiting to join', 'asked to join the project', { source: 'access_requests', desk: 'people.invite' }], ['Ranks', 'the ranks, and who holds each', { floor: 'people.ranks', desk: 'people.ranks' }], ['Goal teams', 'asked to join a goal team', { source: 'goal_join_requests' }]],
     },
     planning: {
       holds: 'Goals, and the promises that say when each one is done. Kept promises are what the project owes its users.', rule: 'majority', cap: 9,
@@ -351,7 +351,7 @@
     automation: {
       holds: 'AI builders working on their own. You choose which goals they may build and how much they may spend, and you can stop them at any time.', rule: 'decide', cap: 6,
       growth: 'A new floor opens for each goal you let it build.', annex: 'room for an annex',
-      floors: [['The switch', 'unattended building, on or off', { source: 'autobongos_fence' }], ['Allowed goals', 'the goals it may build', { floor: 'automation.allowed_goals' }], ['Running now', 'builds in progress', { floor: 'automation.running' }], ['Spending limit', 'what it may spend', { floor: 'automation.spending_limit' }], ['Reports', 'what it did, told without asking', { floor: 'automation.reports' }]],
+      floors: [['The switch', 'unattended building, on or off', { source: 'autobongos_fence', desk: 'automation.switch' }], ['Allowed goals', 'the goals it may build', { floor: 'automation.allowed_goals', desk: 'automation.goals' }], ['Running now', 'builds in progress', { floor: 'automation.running', desk: 'automation.runners' }], ['Spending limit', 'what it may spend', { floor: 'automation.spending_limit' }], ['Reports', 'what it did, told without asking', { floor: 'automation.reports' }]],
     },
     review: {
       holds: 'Testing finished work and signing it off. Work does not count until someone who did not build it says it works.', rule: 'signoff', cap: 5,
@@ -361,12 +361,12 @@
     release: {
       holds: 'Putting finished work live, and taking updates to Bongos itself.', rule: 'decide', cap: 7,
       growth: 'Room for a second gate if releases are ever split by area.', annex: 'room for a second gate',
-      floors: [['Overrides', 'past a failed check or grade', { source: 'override_requests' }], ['Modules', 'listed modules, and their re-checks', { source: 'module_rechecks' }], ['Held back', 'work held from going live', { floor: 'release.held_back' }], ['Core update', 'a new version of Bongos', { source: 'core_update' }], ['Live this month', 'what went live', { floor: 'release.live_month' }], ['Ready to go', 'signed off, waiting to go live', { source: 'gate_approvals' }]],
+      floors: [['Overrides', 'past a failed check or grade', { source: 'override_requests' }], ['Modules', 'listed modules, and their re-checks', { source: 'module_rechecks' }], ['Held back', 'work held from going live', { floor: 'release.held_back' }], ['Core update', 'a new version of Bongos', { source: 'core_update', desk: 'release.core' }], ['Live this month', 'what went live', { floor: 'release.live_month' }], ['Ready to go', 'signed off, waiting to go live', { source: 'gate_approvals' }]],
     },
     treasury: {
       holds: 'The budget, and who gets paid for what.', rule: 'majority', cap: 7,
       growth: 'Each new spending line takes a floor.', annex: 'room for an annex of spending lines',
-      floors: [['Builder rewards', 'paid for shipped work', { floor: 'treasury.rewards' }], ['AI grading', 'the reviewer that grades every ship', { floor: 'treasury.grading' }], ['Hosting', 'servers and storage', { floor: 'treasury.hosting' }], ['Reserve', 'what is left this month', { reading: 'money' }], ['Spending matters', 'spending put to a vote', { source: 'treasury_spending' }]],
+      floors: [['Builder rewards', 'paid for shipped work', { floor: 'treasury.rewards' }], ['AI grading', 'the reviewer that grades every ship', { floor: 'treasury.grading' }], ['Hosting', 'servers and storage', { floor: 'treasury.hosting', desk: 'treasury.backup' }], ['Reserve', 'what is left this month', { reading: 'money' }], ['Spending matters', 'spending put to a vote', { source: 'treasury_spending' }]],
     },
   });
   const MONTHS = ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec'];

package/modules/hall-ui/public/street.css

@@ -310,6 +310,7 @@ html[data-fullscreen="on"] .street-top { padding-right: 184px; }
 .desk-chip--primary { background: var(--ink); border: 0; color: var(--bg); }
 .desk-chip--quiet, .desk-chip--choice { background: none; border: 1px solid var(--street-rule-strong); color: var(--ink); }
 .desk-chip--choice { height: 30px; padding: 0 14px; }
+.desk-field { height: 30px; min-width: 0; flex: 1 1 140px; max-width: 220px; padding: 0 12px; border-radius: 999px; border: 1px solid var(--street-rule-strong); background: none; color: var(--ink); font-family: var(--font-body); font-size: 13.5px; }
 .desk-chip:hover { filter: brightness(1.08); }
 .desk-chip[disabled] { opacity: 0.55; cursor: progress; }
 .desk-wait { font-size: 13px; color: var(--ink-faint); border: 1px dashed var(--street-rule-strong); border-radius: 999px; padding: 6px 12px; white-space: nowrap; }

package/modules/hall-ui/public/street.js

@@ -621,7 +621,7 @@
     r.actions.slice().reverse().forEach(function (a) {
       acts.appendChild(chipBtn('desk-chip--' + a.tone, a.label, function () {
         if (a.go) { window.location.href = a.go; return; }
-        if (a.ask) { desk.ask = desk.ask === r.key ? null : r.key; desk.open = null; draw(); focusRow(r.key, 'chip'); return; }
+        if (a.ask) { var at = r.key + '|' + a.key; desk.ask = desk.ask === at ? null : at; desk.open = null; draw(); focusRow(r.key, 'chip'); return; }
         deskAct(r, a.key, {});
       }));
     });
@@ -632,10 +632,23 @@
       r.facts.forEach(function (f) { facts.appendChild(node('span', 'desk-fact', f)); });
       row.appendChild(facts);
     }
-    if (desk.ask === r.key && r.chips) {
+    var asked = desk.ask && desk.ask.indexOf(r.key + '|') === 0 ? (r.choices || {})[desk.ask.slice(r.key.length + 1)] : null;
+    if (asked) {
       var chips = node('div', 'desk-choices');
-      chips.appendChild(node('span', 'desk-choices__ask', r.chips.ask));
-      r.chips.options.forEach(function (c) { chips.appendChild(chipBtn('desk-chip--choice', c.label, function () { deskAct(r, r.chips.for, c.input); })); });
+      chips.appendChild(node('span', 'desk-choices__ask', asked.ask));
+      asked.options.forEach(function (c) { chips.appendChild(chipBtn('desk-chip--choice', c.label, function () { deskAct(r, asked.for, c.input); })); });
+      if (asked.field) {
+        // the one typed value a desk takes: a name to invite (never a reason)
+        var input = node('input', 'desk-field');
+        input.setAttribute('type', 'text');
+        input.setAttribute('aria-label', asked.ask);
+        input.setAttribute('autocomplete', 'off');
+        input.setAttribute('maxlength', '60');
+        var send = function () { var v = input.value.trim(); if (v) deskAct(r, asked.for, { option: v, label: v }); };
+        input.addEventListener('keydown', function (e) { if (e.key === 'Enter') send(); });
+        chips.appendChild(input);
+        chips.appendChild(chipBtn('desk-chip--primary', 'send', send));
+      }
       row.appendChild(chips);
     }
     return row;
@@ -666,7 +679,13 @@
     if (typeof setTimeout !== 'function') return then();
     setTimeout(then, 320);
   }
-  var DONE_WORDS = { for: 'voted yes', object: 'voted no', fine: 'let in', refuse: 'turned away', release: 'released', hold: 'held' };
+  var DONE_WORDS = {
+    for: 'voted yes', object: 'voted no', fine: 'let in', refuse: 'turned away', release: 'released', hold: 'held',
+    confirm: 'confirmed', dispute: 'disputed', fix: 'fixed', remove: 'removed', keep: 'kept', signoff: 'signed off', force: 'forced',
+    switch_on: 'switched on', switch_off: 'switched off', allow: 'allowed', disallow: 'disallowed', first: 'put first',
+    pause: 'paused', resume: 'resumed', tier: 'new tier', deactivate: 'deactivated', give: 'gave', take: 'took back',
+    check: 'checked', rot: 'set', module_on: 'turned on', module_off: 'turned off', backup: 'backed up', invite: 'invited',
+  };
   // One act from a row: checked, sent through the card's own request (the
   // server's permission checks decide), then the row clears, the floor counts
   // it, the meter takes a pip and the toast says what happened. An act that

package/modules/hall-ui/public/street.states.json

@@ -55,14 +55,37 @@
       "auth": true,
       "_": "In the hall since task 1004544: the shell's full-screen switch pressed, the sidebar and the top bar gone, the street filling the window and the one exit in the corner (the sky's mechanism, task 1004327).",
       "actions": [
-        ["wait", 900],
-        ["click", "#fullscreen-toggle"],
-        ["wait", 500]
+        [
+          "wait",
+          900
+        ],
+        [
+          "click",
+          "#fullscreen-toggle"
+        ],
+        [
+          "wait",
+          500
+        ]
       ],
       "expect": {
-        "visible": ["#streetBoard", "#streetSigns", "#streetMode", "#fullscreen-toggle"],
-        "hidden": ["#app-sidebar", "#topbar-title"],
-        "attr": [["#fullscreen-toggle", "aria-pressed", "true"]]
+        "visible": [
+          "#streetBoard",
+          "#streetSigns",
+          "#streetMode",
+          "#fullscreen-toggle"
+        ],
+        "hidden": [
+          "#app-sidebar",
+          "#topbar-title"
+        ],
+        "attr": [
+          [
+            "#fullscreen-toggle",
+            "aria-pressed",
+            "true"
+          ]
+        ]
       }
     },
     "card": {
@@ -456,6 +479,208 @@
           ".desk-quiet"
         ]
       }
+    },
+    "desk-people-builders": {
+      "auth": true,
+      "_": "Task 1004559: People, Builders floor. Each builder is a row with tier and deactivate, the acts the old builders page held.",
+      "url": "/builders/street#building=people",
+      "actions": [
+        [
+          "wait",
+          900
+        ],
+        [
+          "clickIfVisible",
+          "[data-craft-close]"
+        ],
+        [
+          "wait",
+          300
+        ],
+        [
+          "click",
+          "[data-floor=\"2\"]"
+        ],
+        [
+          "wait",
+          600
+        ]
+      ],
+      "expect": {
+        "visible": [
+          ".desk-rows",
+          ".desk-chip--primary"
+        ]
+      }
+    },
+    "desk-people-tier": {
+      "auth": true,
+      "_": "Task 1004559: the tier button opens its tiers as one-tap chips in place (one rung up at most).",
+      "url": "/builders/street#building=people",
+      "actions": [
+        [
+          "wait",
+          900
+        ],
+        [
+          "clickIfVisible",
+          "[data-craft-close]"
+        ],
+        [
+          "wait",
+          300
+        ],
+        [
+          "click",
+          "[data-floor=\"2\"]"
+        ],
+        [
+          "wait",
+          600
+        ],
+        [
+          "click",
+          ".desk-row .desk-chip--primary"
+        ],
+        [
+          "wait",
+          400
+        ]
+      ],
+      "expect": {
+        "visible": [
+          ".desk-choices"
+        ]
+      }
+    },
+    "desk-disputes": {
+      "auth": true,
+      "_": "Task 1004559: Disputes, Security reports. Confirm or dispute an open report; mark a confirmed one fixed.",
+      "url": "/builders/street#building=disputes",
+      "actions": [
+        [
+          "wait",
+          900
+        ],
+        [
+          "clickIfVisible",
+          "[data-craft-close]"
+        ],
+        [
+          "wait",
+          300
+        ],
+        [
+          "click",
+          "[data-floor=\"0\"]"
+        ],
+        [
+          "wait",
+          600
+        ]
+      ],
+      "expect": {
+        "visible": [
+          ".desk-rows",
+          ".desk-status--hot"
+        ]
+      }
+    },
+    "desk-automation-goals": {
+      "auth": true,
+      "_": "Task 1004559: Automation, Allowed goals. Disallow, put first, or allow an open goal from chips.",
+      "url": "/builders/street#building=automation",
+      "actions": [
+        [
+          "wait",
+          900
+        ],
+        [
+          "clickIfVisible",
+          "[data-craft-close]"
+        ],
+        [
+          "wait",
+          300
+        ],
+        [
+          "click",
+          "[data-floor=\"1\"]"
+        ],
+        [
+          "wait",
+          600
+        ]
+      ],
+      "expect": {
+        "visible": [
+          ".desk-rows"
+        ]
+      }
+    },
+    "desk-release-core": {
+      "auth": true,
+      "_": "Task 1004559: Release, Core update. Check first (a dry run); take it is offered only after the check passed for that version.",
+      "url": "/builders/street#building=release",
+      "actions": [
+        [
+          "wait",
+          900
+        ],
+        [
+          "clickIfVisible",
+          "[data-craft-close]"
+        ],
+        [
+          "wait",
+          300
+        ],
+        [
+          "click",
+          "[data-floor=\"3\"]"
+        ],
+        [
+          "wait",
+          600
+        ]
+      ],
+      "expect": {
+        "visible": [
+          ".desk-rows"
+        ]
+      }
+    },
+    "desk-rules": {
+      "auth": true,
+      "_": "Task 1004559: Rules in force. The rot timer as day chips, work categories as a link, each module on or off.",
+      "url": "/builders/street#building=rules",
+      "actions": [
+        [
+          "wait",
+          900
+        ],
+        [
+          "clickIfVisible",
+          "[data-craft-close]"
+        ],
+        [
+          "wait",
+          300
+        ],
+        [
+          "click",
+          "[data-floor=\"0\"]"
+        ],
+        [
+          "wait",
+          600
+        ]
+      ],
+      "expect": {
+        "visible": [
+          ".desk-rows"
+        ]
+      }
     }
   },
   "reducedMotion": {

package/modules/lifecycle/governor-docket.js

@@ -58,10 +58,29 @@ function removalMatter(r) {
     tally: null,
     href: `/task/${encodeURIComponent(r.proposal_task_id)}`,
     ref: { type: 'task', id: r.proposal_task_id },
+    // POST /removal-proposals/:id/decide, the docket source's own atom (task 1004559)
+    acts: [{ key: 'remove' }, { key: 'keep' }],
   };
 }
 
-function uatMatter(c) {
+// The one-tap reasons a force sign-off may give (POST /done-when/:id/satisfy
+// requires one); the desk sends the label as the override reason.
+const FORCE_REASONS = Object.freeze([
+  { key: 'tested_by_hand', label: 'tested by hand' },
+  { key: 'checked_review', label: 'seen in review' },
+  { key: 'no_longer', label: 'no longer applies' },
+]);
+// What the viewer may do on a criterion waiting for a tester (task 1004559). A
+// backend-only criterion signs off in one tap (with the live attestation as its
+// chip); a user-facing one needs a recording, so its act goes to the goal's page.
+// Force sign-off only for a holder of criterion.satisfy, that route's own atom.
+function uatActs(c, { force = false } = {}) {
+  const acts = [c.backend_only === true ? { key: 'signoff', options: [{ key: 'live', label: 'tested it live' }] } : { key: 'record' }];
+  if (force) acts.push({ key: 'force', options: FORCE_REASONS });
+  return acts;
+}
+
+function uatMatter(c, opts) {
   return {
     id: c.id,
     rule: 'signoff',
@@ -75,6 +94,7 @@ function uatMatter(c) {
     tally: { for: c.shipped_total, against: 0, open: 0, needs: 'one sign-off by someone who did not build it' },
     href: c.goal_id ? `/goals#/goal/${encodeURIComponent(c.goal_id)}` : '/goals',
     ref: { type: 'criterion', id: c.id },
+    acts: uatActs(c, opts),
   };
 }
 
@@ -326,7 +346,8 @@ function contributeLifecycleToDocket() {
     source: 'criteria_uat',
     building: 'review',
     gate: { permission: 'criterion.review' },
-    read: async () => (await doneWhen.listPendingReviewCriteria({})).filter((c) => c.awaiting_uat === true).map(uatMatter),
+    read: async (ctx) => (await doneWhen.listPendingReviewCriteria({})).filter((c) => c.awaiting_uat === true)
+      .map((c) => uatMatter(c, { force: ctx.has('criterion.satisfy') })),
   });
   // Own-scoped by its read, like GET /goals/inbox: a goal's lead sees the requests
   // to join their goals, and everyone sees their own pending ones. An Archon is
@@ -371,6 +392,7 @@ module.exports = {
   overrideMatter,
   removalMatter,
   uatMatter,
+  uatActs,
   joinRequestMatter,
   flowReading,
   promisesReading,

package/modules/lifecycle/routes/project-settings.js

@@ -134,7 +134,29 @@ function upmarketRow() {
   };
 }
 
+// The Rules desk's settings rows (task 1004559), under this page's own atom: the
+// rot timer as one-tap day counts (PATCH /project-settings/rot-days), and the
+// work categories as a link to this page, since a category is named in words.
+// Pure; exported for tests.
+const ROT_CHOICES = Object.freeze([7, 14, 30, 60, 90]);
+function settingsDeskRows({ days, categories }) {
+  const live = (categories || []).filter((c) => c && c.active !== false).length;
+  return [
+    { id: 'rot', name: 'Rot timer', fact: `stale after ${days} ${days === 1 ? 'day' : 'days'}`, facts: ['raising it only asks a person'], tool: true, ref: { type: 'project_setting', id: 'rot_days' },
+      acts: [{ key: 'rot', options: ROT_CHOICES.filter((d) => d !== Number(days)).slice(0, 4).map((d) => ({ key: String(d), label: `${d} days` })) }] },
+    { id: 'categories', name: 'Work categories', fact: `${live} in use`, tool: true, href: '/project-settings', ref: { type: 'project_setting', id: 'work_categories' }, acts: [{ key: 'open' }] },
+  ];
+}
+function contributeSettingsDesk() {
+  api.contribute('governor.docket', {
+    desk: 'rules.settings',
+    gate: { permission: 'project.settings.manage' },
+    read: async () => settingsDeskRows({ days: (await api.resolveRotDays()).days, categories: await goalCategory.listCategories({ includeInactive: true }) }),
+  });
+}
+
 module.exports = function buildProjectSettingsRouter() {
+  contributeSettingsDesk();
   const router = express.Router();
 
   // GET /project-settings — all five rows in ONE read.
@@ -261,3 +283,5 @@ module.exports = function buildProjectSettingsRouter() {
 
   return router;
 };
+
+module.exports.settingsDeskRows = settingsDeskRows;