@bongos/core 1.21.33 → 1.21.35

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

@@ -0,0 +1,386 @@
+// modules/hall-ui/public/street-desk.js — THE FLOOR DESK AND THE LINE RULE
+// (task 1004558, goal 1000125; round 2 of the Governor City).
+//
+// WHAT THIS IS. The desk from the reference board "Round 2 · floor desks"
+// (docs/design/mocks/governor-city/Desks.dc.html, its Component class): the
+// chosen floor of a building, as one panel you act from in place. A header
+// (the floor's sign, its name, its status), up to three tiles, the to-do rows
+// (a name, one fact, at most two buttons; tap the name for at most three facts
+// in place; reasons as one-tap chips), the quiet state when nothing needs you,
+// and the record line. The game layer around it (the today meter, rows
+// clearing away, a cleared floor lighting up, the toast) is drawn by
+// street.js; this file is pure.
+//
+// THE LINE RULE (Ground.dc.html, "the line rule and ground level"):
+//   a ROW     is a name of at most 3 words, one fact, at most two buttons, and
+//             at most three facts that open in place;
+//   a TILE    is one number and two words, and is hidden when it reads zero;
+//   a STATUS  is count, noun and oldest age, orange only when it needs you;
+//   a QUIET   floor shows one line and lights on, never an empty list;
+//   REASONS   and options are one-tap chips, never free text.
+// fit() is the ONE line formatter every desk string goes through, and breaks()
+// is the rule as a checker: tests/hall_street_desk.mjs runs every desk the
+// docket can produce through it.
+//
+// THE ACTS. A row's buttons are the matter card's own actions
+// (GovMatterCard.model, street-card.js) under the board's shorter words, and an
+// act is sent through GovMatterCard.request(): the same existing routes the
+// card uses, with their own permission checks. Nothing here invents a route.
+// Two of the board's touches have no route under them and are left out rather
+// than faked: a reason for "not now" on a join request (the route takes none),
+// and the abstain text action (it records nothing; a row has two buttons).
+//
+// API (what the next desks plug into):
+//   GovDesk.deskModel(input) → desk          pure; input below
+//   GovDesk.rowsFor(key, floor, docket, ctx) the rows of one floor
+//   GovDesk.floorMatters(key, floor, docket) which open matters sit on a floor
+//   GovDesk.firstNeeds(key, docket)          the floor that needs you first, or null
+//   GovDesk.fit(s, n, words)                 the line formatter
+//   GovDesk.breaks(desk)                     [] when the desk keeps the line rule
+//   GovDesk.todayPips(n)                     the street header's meter
+//   GovDesk.LIMITS, ACT_WORDS, CHIPS, NOUNS, CLEAR
+// A desk row is { key, matter, ini, name, fact, facts[], actions[{ key, label,
+// tone, go, ask }], chips { for, ask, options[{ key, label, input }] } | null,
+// wait, needs, card }: `card` is the GovMatterCard model the act is sent with.
+
+(function (root) {
+  'use strict';
+  const S = root.GovStreet || (typeof require === 'function' ? require('./street-draw.js') : null);
+  const I = root.GovInside || (typeof require === 'function' ? require('./street-inside.js') : null);
+  const C = root.GovMatterCard || (typeof require === 'function' ? require('./street-card.js') : null);
+
+  // Every limit of the line rule, in characters unless named otherwise.
+  const LIMITS = Object.freeze({
+    nameWords: 3, name: 20, fact: 26, facts: 3, factLen: 24, actions: 2,
+    tiles: 3, tileValue: 8, tileWords: 2, tileLabel: 14,
+    status: 44, clearLine: 30, clearSub: 40, record: 4, recordLen: 30,
+    chips: 5, chip: 16, todayTarget: 10,
+  });
+
+  // One line, never more: the house rule for every row, tile and status. A cap
+  // on words first (when given), then on characters; anything cut says so.
+  function fit(s, n, words) {
+    let t = String(s == null ? '' : s).replace(/\s+/g, ' ').trim();
+    let cut = false;
+    if (words) {
+      const w = t.split(' ');
+      if (w.length > words) { t = w.slice(0, words).join(' ').replace(/[,.;:·-]+$/, ''); cut = true; }
+    }
+    if (t.length > n) cut = true;
+    if (!cut) return t;
+    t = t.replace(/…$/, '');
+    if (t.length > n - 1) t = t.slice(0, n - 1).trimEnd();
+    return t + '…';
+  }
+  const wordCount = (s) => String(s).replace(/…$/, '').split(' ').filter(Boolean).length;
+
+  // An age in the board's words: '40 min', '5 hours', '2 days', '3 weeks'.
+  function ageWord(at, now) {
+    const t = at ? Date.parse(at) : NaN;
+    if (!isFinite(t) || !now) return '';
+    const m = Math.max(0, Math.round((now - t) / 60000));
+    if (m < 60) return (m || 1) + ' min';
+    const h = Math.round(m / 60);
+    if (h < 48) return h + (h === 1 ? ' hour' : ' hours');
+    const d = Math.round(h / 24);
+    if (d < 14) return d + ' days';
+    return Math.round(d / 7) + ' weeks';
+  }
+
+  // The words a floor counts its rows in, and says when it is cleared.
+  const NOUNS = Object.freeze({
+    access_requests: 'waiting', goal_join_requests: 'asking', override_requests: 'asked', gate_approvals: 'ready',
+    core_update: 'update', blockers: 'waiting', board: 'open vote', idea: 'open vote',
+  });
+  const CLEAR = Object.freeze({
+    access_requests: 'Everyone is in', goal_join_requests: 'No one is asking', override_requests: 'No overrides asked',
+    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',
+    // 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' });
+  const STATE = Object.freeze({ needs: 'needs you', moving: 'moving', settled: 'settled' });
+  const PEOPLE = Object.freeze(['access_requests', 'goal_join_requests']);
+
+  function str(v) { return v == null ? '' : String(v); }
+  function personOf(m) { return m && m.proposer ? str(m.proposer.name || m.proposer.login) : ''; }
+  function initials(t) {
+    const w = str(t).replace(/[^A-Za-z0-9 ]+/g, ' ').trim().split(/\s+/).filter(Boolean);
+    return (w.length > 1 ? w[0].charAt(0) + w[1].charAt(0) : str(w[0]).slice(0, 2)).toUpperCase() || '·';
+  }
+  function stateOf(m) { return m && STATE[m.state] ? m.state : 'moving'; }
+  function isIdea(m) { return !!m && m.source === 'board' && m.short === 'idea to ratify'; }
+
+  // ---------- which matters sit on which floor ----------
+  // A floor bound to a source holds that source's matters in this building; the
+  // ideas floor holds the board's open full ideas; every other open matter of
+  // the building (a board sitting, a source no floor names) sits on the first
+  // floor, the building's front desk. Settled matters are the record, not rows.
+  function floorMatters(key, floor, docket) {
+    const plan = I && I.PLAN[key];
+    if (!plan || !docket || !Array.isArray(docket.matters)) return [];
+    const specs = plan.floors;
+    const spec = specs[floor];
+    if (!spec) return [];
+    const bind = spec[2] || {};
+    const open = docket.matters.filter((m) => m && stateOf(m) !== 'settled');
+    const own = open.filter((m) => m.building === key);
+    const sources = new Set(specs.map((s) => s[2] && s[2].source).filter(Boolean));
+    const ideasHere = specs.some((s) => s[2] && s[2].floor === 'planning.ideas');
+    if (bind.source) return own.filter((m) => m.source === bind.source);
+    if (bind.floor === 'planning.ideas') return open.filter(isIdea);
+    if (floor !== 0) return [];
+    return own.filter((m) => !sources.has(m.source) && !(ideasHere && isIdea(m)));
+  }
+  // The floor that needs you first (so a building opens on its work), or null.
+  function firstNeeds(key, docket) {
+    const plan = I && I.PLAN[key];
+    if (!plan) return null;
+    for (let i = 0; i < plan.floors.length; i++) if (floorMatters(key, i, docket).some((m) => stateOf(m) === 'needs')) return i;
+    return null;
+  }
+
+  // ---------- one row ----------
+  // ctx { docket, room, constitution, now, viewerId }
+  function rowOf(m, ctx) {
+    const now = ctx.now || 0;
+    const person = personOf(m);
+    const people = PEOPLE.indexOf(m.source) >= 0;
+    const name = fit(people && person ? person : (m.title || m.short || 'a matter'), LIMITS.name, LIMITS.nameWords);
+    const age = ageWord(m.opened_at, now);
+    const lead = people ? (m.source === 'goal_join_requests' ? 'goal team' : 'to join') : person ? person.split(/\s+/)[0] : str(m.short || STATE[stateOf(m)]);
+    const fact = fit([lead, age].filter(Boolean).join(' · '), LIMITS.fact);
+    const when = S && S.whenWord ? S.whenWord(m.deadline, now) : '';
+    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 (m.title && name !== str(m.title)) add(m.title);
+    if (person && !people) add('by ' + person);
+    if (typeof m.tally === 'string') add(m.tally);
+    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;
+    if (cv && !cv.readOnly && !cv.loading) {
+      cv.actions.forEach((a) => {
+        if (actions.length >= LIMITS.actions || !ACT_WORDS[a.key]) return;
+        actions.push({ key: a.key, label: ACT_WORDS[a.key], tone: actions.length ? 'quiet' : 'primary', go: a.go || null, ask: a.key === 'object' });
+      });
+      if (actions.some((a) => a.ask)) {
+        chips = { for: 'object', ask: 'why', options: Object.keys(CHIPS).map((k) => ({ key: k, label: CHIPS[k], input: { section: k, reason: 'Objects to ' + CHIPS[k] + ' (one tap on the floor desk).' } })) };
+      }
+    }
+    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, 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 || {};
+    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)));
+  }
+
+  // ---------- the whole desk ----------
+  // input { key, floor (index), docket, goals (open), now, room, constitution,
+  //         viewerId, done {matterId: true}, mine [what you did here, newest
+  //         first], cleared (you cleared it this visit), today (decisions
+  //         today), sym {d, f} (the floor's sign, from buildingModel) }
+  function deskModel(input) {
+    const o = input || {};
+    const plan = I && I.PLAN[o.key];
+    if (!plan) return null;
+    const docket = o.docket && Array.isArray(o.docket.matters) ? o.docket : null;
+    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, 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 (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) : [];
+    // tiles: one number and two words, never a zero
+    const tiles = [];
+    const tile = (v, l) => {
+      const val = str(v).trim();
+      if (!/[0-9]/.test(val) || /^[$]?[0.,]+%?$/.test(val)) return;
+      // two words, read as a label: the rest of a longer line is left off, not marked cut
+      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(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 }))
+      .concat(history.map((h, i) => ({ key: 'h' + i, text: fit([h.title, h.outcome, ageWord(h.at, o.now)].filter(Boolean).join(' · '), LIMITS.recordLen), mine: false })))
+      .slice(0, LIMITS.record);
+    return {
+      key: o.key + ':' + floor, building: o.key, floor: floor, name: spec[0], sym: o.sym || { d: '', f: '' },
+      status: fit(status, LIMITS.status), hot: hot,
+      tiles: tiles.slice(0, LIMITS.tiles), rows: rows,
+      quiet: quiet, cleared: cleared,
+      clearLine: fit(cleared ? (CLEAR[src] || 'Floor clear') : 'Nothing needs you here', LIMITS.clearLine),
+      clearSub: fit(cleared ? 'lit up · ' + (o.today || 0) + ' decided today' : fl.line, LIMITS.clearSub),
+      record: record,
+    };
+  }
+
+  // ---------- the rule as a checker ----------
+  function breaks(desk) {
+    const out = [];
+    if (!desk) return out;
+    const bad = (what, v) => out.push(desk.key + ' ' + what + ': ' + JSON.stringify(v));
+    const oneLine = (s) => typeof s === 'string' && !/[\r\n]/.test(s);
+    if (!oneLine(desk.status) || desk.status.length > LIMITS.status) bad('status too long', desk.status);
+    if (desk.hot !== desk.rows.some((r) => r.needs)) bad('status is orange only when something needs you', desk.status);
+    if (desk.tiles.length > LIMITS.tiles) bad('more than three tiles', desk.tiles.length);
+    desk.tiles.forEach((t) => {
+      if (!/[0-9]/.test(t.v) || t.v.length > LIMITS.tileValue || /^[$]?[0.,]+%?$/.test(t.v)) bad('tile value', t.v);
+      if (!t.l || wordCount(t.l) > LIMITS.tileWords || t.l.length > LIMITS.tileLabel) bad('tile label', t.l);
+    });
+    if (desk.quiet !== (desk.rows.length === 0)) bad('quiet and rows disagree', desk.rows.length);
+    if (desk.quiet && (!desk.clearLine || desk.clearLine.length > LIMITS.clearLine || !oneLine(desk.clearSub) || desk.clearSub.length > LIMITS.clearSub)) bad('quiet line', [desk.clearLine, desk.clearSub]);
+    desk.rows.forEach((r) => {
+      if (!r.name || !oneLine(r.name) || wordCount(r.name) > LIMITS.nameWords || r.name.length > LIMITS.name) bad('row name', r.name);
+      if (!oneLine(r.fact) || r.fact.length > LIMITS.fact) bad('row fact', r.fact);
+      if (r.actions.length > LIMITS.actions) bad('more than two buttons', r.actions.map((a) => a.label));
+      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;
+  }
+
+  // The street header's meter: one pip per decision today, ten to a row.
+  function todayPips(n) {
+    const k = Math.max(0, Math.floor(Number(n) || 0));
+    const pips = [];
+    for (let i = 0; i < LIMITS.todayTarget; i++) pips.push({ key: i, on: i < k, fresh: k > 0 && i === Math.min(k, LIMITS.todayTarget) - 1 });
+    return { pips: pips, text: k + ' decided' };
+  }
+
+  const api = {
+    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;
+  if (typeof module !== 'undefined' && module.exports) module.exports = api;
+}(typeof window !== 'undefined' ? window : globalThis));

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

@@ -208,7 +208,9 @@
       const used = !!fl, sel = used && i === selFloor;
       const pend = used && fl.status === 'pending';
       const prop = used && (fl.status === 'proposed' || QUIET[fl.status] !== undefined);
-      const lit = sel || (used && st.evening);
+      // a floor you cleared this visit lights its windows and shows a tick (task 1004558)
+      const clr = used && Array.isArray(st.cleared) && st.cleared.indexOf(i) >= 0;
+      const lit = sel || clr || (used && st.evening);
       push(shapes, rect(X - 6, y1 - 5, W + 12, 5), fillOr(M2.slab), line, dash);
       push(shapes, rect(X + 9, y0, W - 18, FH - 5), fillOr(lit ? M2.roomLit : M2.room), line, dash);
       [X, X + W - 9].forEach((wx) => {
@@ -237,7 +239,8 @@
       if (pend) push(shapes, rect(X + 11, y0 + 2, W - 22, FH - 9), 'none', '#fb9569', '4 4');
       txt(X + 24, y0 + 24, cut(fl.name, 34), ghost || prop ? M2.faint : M2.name, 14.5, 500);
       txt(X + 24, y0 + 40, cut(fl.line, 44), pend ? T.accentText : M2.line, 12, 400);
-      if (fl.count) txt(X + W - 22, y0 + 34, fl.count, M2.name, 20, 300, 'end', sans, '-0.02em');
+      if (clr) push(shapes, 'M' + (X + W - 44) + ' ' + (y0 + 22) + 'l6 6 12-13', 'none', M2.name, 'none', 1.8);
+      else if (fl.count) txt(X + W - 22, y0 + 34, fl.count, M2.name, 20, 300, 'end', sans, '-0.02em');
       else if (pend) txt(X + W - 22, y0 + 32, 'being decided', T.accentText, 11.5, 500, 'end');
       else if (QUIET[fl.status]) txt(X + W - 22, y0 + 32, QUIET[fl.status], M2.faint, 11.5, 400, 'end');
     }
@@ -328,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,
@@ -348,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,
@@ -358,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'];
@@ -540,7 +543,8 @@
   }
 
   // The building interior as data: civicInfo() drawn by buildingView().
-  //   input { key, docket, goals, mode, now, floor, drawer, picks }
+  //   input { key, docket, goals, mode, now, floor, drawer, picks, cleared }
+  //   cleared: the floor indexes the viewer cleared at the desk this visit (street-desk.js)
   function buildingModel(input) {
     const o = input || {};
     if (S.CIVIC_KEYS.indexOf(o.key) < 0) return null;
@@ -550,7 +554,7 @@
     const b = civicInfo(o.key, { docket: o.docket, goals: goals, now: o.now });
     const docket = o.docket && Array.isArray(o.docket.matters) ? o.docket : null;
     const evening = !!docket && !(docket.counts && Number(docket.counts.needs) > 0);
-    const bv = buildingView(T, o.key, b, { floor: o.floor, drawer: o.drawer, picks: o.picks, vacant: b.vacant, reviewHeld: !b.vacant, evening: evening });
+    const bv = buildingView(T, o.key, b, { floor: o.floor, drawer: o.drawer, picks: o.picks, vacant: b.vacant, reviewHeld: !b.vacant, evening: evening, cleared: o.cleared });
     bv.table = bv.table.map((r) => Object.assign({}, r, { color: r.color === 'accent' ? T.accentText : T.ink }));
     bv.key = o.key; bv.mode = mode; bv.vacant = b.vacant;
     bv.label = b.name + ' in section: ' + b.floors.length + ' of ' + bv.cap + ' floors in use' + (bv.hasTable ? ', ' + bv.table.length + ' on the table' : '') + '.';

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

@@ -283,6 +283,59 @@ html[data-fullscreen="on"] .street-top { padding-right: 184px; }
 .inside-line { display: flex; justify-content: space-between; gap: 14px; padding: 9px 0; border-top: 1px solid var(--street-rule); font-size: 14.5px; line-height: 1.4; }
 .inside-line__meta { color: var(--ink-faint); white-space: nowrap; font-variant-numeric: tabular-nums; }
 
+/* THE FLOOR DESK (task 1004558; Desks.dc.html): the chosen floor as one panel
+   you act from. Status orange only when it needs you; tiles are one number and
+   two words; rows are a name, one fact and at most two chips; a quiet floor is
+   one lit line. Tokens only, so both modes come from the pack. */
+.desk { gap: 0; }
+.desk .inside-open__head { padding-bottom: 14px; }
+.desk-status { font-size: 14px; color: var(--ink-faint); white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+.desk-status--hot { color: var(--street-accent-text); }
+.desk-tiles { display: flex; flex-wrap: wrap; border-top: 1px solid var(--street-rule); }
+.desk-tile { min-width: 108px; padding: 10px 16px; border-left: 1px solid var(--street-rule); display: flex; flex-direction: column; gap: 2px; }
+.desk-tile:first-child { border-left: 0; padding-left: 0; }
+.desk-tile__v { font-size: 26px; font-weight: 300; letter-spacing: -0.03em; font-variant-numeric: tabular-nums; }
+.desk-tile__l { font-size: 12.5px; color: var(--ink-faint); white-space: nowrap; }
+.desk-rows { display: flex; flex-direction: column; border-top: 1px solid var(--street-rule); }
+.desk-row { border-bottom: 1px solid var(--street-rule); padding: 12px 0; animation: street-enter 300ms cubic-bezier(.16,1,.3,1) both; }
+.desk-row--gone { animation: desk-gone 320ms cubic-bezier(.4,0,.2,1) both; }
+.desk-row__main { display: flex; align-items: center; gap: 14px; min-height: 44px; }
+.desk-ini { width: 38px; height: 38px; border-radius: 999px; flex-shrink: 0; box-sizing: border-box; display: flex; align-items: center; justify-content: center; font-size: 12.5px; font-weight: 500; background: var(--street-wash); border: 1px solid var(--street-rule); }
+.desk-row--needs .desk-ini { border-color: var(--accent); }
+.desk-name { flex: 1 1 auto; min-width: 0; background: none; border: 0; padding: 4px 0; min-height: 24px; cursor: pointer; text-align: left; display: flex; flex-direction: column; gap: 3px; color: var(--ink); font-family: var(--font-body); }
+.desk-name__t { font-size: 15.5px; font-weight: 500; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; max-width: 100%; }
+.desk-name__f { font-size: 13px; color: var(--ink-soft); white-space: nowrap; overflow: hidden; text-overflow: ellipsis; max-width: 100%; }
+.desk-acts { display: flex; align-items: center; gap: 8px; flex: none; margin-left: auto; }
+.desk-chip { height: 34px; padding: 0 16px; border-radius: 999px; font-family: var(--font-body); font-size: 13.5px; font-weight: 500; cursor: pointer; white-space: nowrap; text-transform: lowercase; }
+.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; }
+.desk-facts, .desk-choices { display: flex; gap: 8px; flex-wrap: wrap; align-items: center; padding: 10px 0 2px 52px; animation: street-enter 300ms cubic-bezier(.16,1,.3,1) both; }
+.desk-fact { font-size: 13px; color: var(--ink-soft); background: var(--street-wash); border-radius: 6px; padding: 6px 10px; white-space: nowrap; }
+.desk-choices__ask { font-size: 12.5px; color: var(--ink-faint); margin-right: 4px; }
+.desk-quiet { min-height: 168px; display: flex; flex-direction: column; align-items: center; justify-content: center; gap: 12px; border-top: 1px solid var(--street-rule); text-align: center; animation: street-enter 300ms cubic-bezier(.16,1,.3,1) both; }
+.desk-quiet__tick { display: block; fill: none; stroke: var(--ink); stroke-width: 1.4; stroke-linecap: round; animation: desk-pop 420ms cubic-bezier(.2,.7,.3,1) both; }
+.desk-quiet--cleared .desk-quiet__tick { stroke: var(--street-accent-text); }
+.desk-quiet__line { font-size: 20px; font-weight: 300; }
+.desk-quiet__sub { font-size: 13.5px; color: var(--ink-faint); }
+.desk-record { display: flex; align-items: baseline; flex-wrap: wrap; gap: 8px 22px; border-top: 1px solid var(--street-rule); margin-top: 18px; padding-top: 14px; }
+.desk-record__label { font-size: 11.5px; letter-spacing: 0.12em; text-transform: uppercase; color: var(--ink-faint); }
+.desk-record__item { font-size: 13px; color: var(--ink-faint); white-space: nowrap; }
+.desk-record__item--mine { color: var(--ink); }
+.desk-pop { animation: desk-pop 420ms cubic-bezier(.2,.7,.3,1) both; }
+.desk-name:focus-visible, .desk-chip:focus-visible { outline: 2px solid var(--accent); outline-offset: 3px; }
+@keyframes desk-gone { to { opacity: 0; transform: translateX(24px); } }
+@keyframes desk-pop { 0% { transform: scale(.6); opacity: 0; } 60% { transform: scale(1.15); opacity: 1; } 100% { transform: scale(1); } }
+/* the today meter in the street header: one pip per decision */
+.street-today__pips { display: flex; gap: 5px; }
+.street-today__pip { width: 10px; height: 10px; border-radius: 3px; box-sizing: border-box; border: 1px solid var(--street-rule-strong); }
+.street-today__pip--on { background: var(--accent); border-color: var(--accent); }
+.street-today__n { font-size: 14px; color: var(--ink-soft); font-variant-numeric: tabular-nums; white-space: nowrap; }
+
 /* the record: one filing drawer a month */
 .inside-record { display: flex; flex-direction: column; gap: 10px; }
 .inside-record__head { display: flex; align-items: baseline; justify-content: space-between; gap: 12px; }
@@ -318,6 +371,13 @@ html[data-fullscreen="on"] .street-top { padding-right: 184px; }
   .inside-panel { order: 3; overflow: visible; }
   .inside-name { font-size: 32px; }
   .inside-gov__row { flex-wrap: wrap; row-gap: 4px; }
+  .desk-row__main { flex-wrap: wrap; row-gap: 8px; }
+  .desk-name { flex-basis: calc(100% - 52px); }
+  .desk-acts { margin-left: 52px; }
+  .desk-facts, .desk-choices { padding-left: 0; }
+  .desk-tile { min-width: 0; padding: 10px 14px; }
+  .street-today__pips { gap: 3px; }
+  .street-today__pip { width: 8px; height: 8px; }
 }
 
 /* the prototype's motion, verbatim */

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

@@ -11,7 +11,7 @@
        links, injected into this head by the server like every hall page's
        (tests/hall_tokens.mjs: no hall page hardcodes a web-font stylesheet). -->
   <link rel="stylesheet" href="/builders/style.css?v=2026-07-02-shell1">
-  <link rel="stylesheet" href="/builders/street.css?v=2026-10-02-inside1">
+  <link rel="stylesheet" href="/builders/street.css?v=2026-10-03-desk1">
   <link rel="stylesheet" href="/builders/street-card.css?v=2026-10-02-card1">
 </head>
 <!-- THE STREET (task 1004525, goal 1000125, R03). The street view of
@@ -67,6 +67,11 @@
     <h1 class="street-kicker">the street</h1>
   </div>
   <div class="street-hud">
+    <div class="street-hud__item street-today" title="decisions made today">
+      <span class="street-label">today</span>
+      <span class="street-today__pips" id="streetTodayPips" aria-hidden="true"></span>
+      <span class="street-today__n" id="streetTodayN">0 decided</span>
+    </div>
     <div class="street-hud__item">
       <span class="street-hud__dot" id="hudDot"></span>
       <span class="street-label">needs you</span>
@@ -210,8 +215,9 @@
 <script src="/builders/city-draw.js?v=2026-10-02-street1"></script>
 <script src="/builders/street-draw.js?v=2026-10-02-street1"></script>
 <script src="/builders/street-card.js?v=2026-10-02-amend1"></script>
-<script src="/builders/street-inside.js?v=2026-10-02-inside1"></script>
+<script src="/builders/street-inside.js?v=2026-10-03-desk1"></script>
+<script src="/builders/street-desk.js?v=2026-10-03-desk1"></script>
 <script src="/builders/street-amend.js?v=2026-10-02-amend1"></script>
-<script src="/builders/street.js?v=2026-10-02-amend1"></script>
+<script src="/builders/street.js?v=2026-10-03-desk1"></script>
 </body>
 </html>