@bongos/core 1.19.642 → 1.19.643

package/tests/hall_nav.mjs

@@ -81,6 +81,31 @@ function boot({ page = 'settings', hash = '', pathname = '/settings' } = {}) {
     return out;
   }
 
+  // task 1003737: the badge nodes applyCounts() settles. They are THE SAME
+  // element objects gatedNodes() hands back — keyed by the same id — because
+  // applyCounts reads `el.hidden`, which the gate loop is what sets. A separate
+  // stub object here would read a hidden that nothing ever wrote, and the
+  // "a badge never out-runs its gate" assertion would pass vacuously.
+  function countNodes() {
+    const html = els.has('app-sidebar') ? String(els.get('app-sidebar').innerHTML) : '';
+    const out = [];
+    for (const tag of html.split('<')) {
+      const count = attr(tag, 'data-count');
+      if (count === undefined) continue;
+      const key = attr(tag, 'id');
+      if (!gatedEls.has(key)) gatedEls.set(key, { key, dataset: {}, hidden: true });
+      const el = gatedEls.get(key);
+      el.dataset.count = count;
+      if (!el._badge) {
+        el._badge = { hidden: true, textContent: '' };
+        el._label = { textContent: '' };
+        el.querySelector = (sel) => (sel === '[data-badge]' ? el._badge : sel === '[data-badge-label]' ? el._label : null);
+      }
+      out.push(el);
+    }
+    return out;
+  }
+
   const documentObj = {
     body: { dataset: { page } },
     documentElement: { dataset: {}, style: {}, classList: { add() {}, remove() {}, toggle() { return false; }, contains() { return false; } } },
@@ -88,7 +113,11 @@ function boot({ page = 'settings', hash = '', pathname = '/settings' } = {}) {
       if (!els.has(id)) els.set(id, makeEl());
       return els.get(id);
     },
-    querySelectorAll(sel) { return sel === '#app-sidebar [data-gate]' ? gatedNodes() : []; },
+    querySelectorAll(sel) {
+      if (sel === '#app-sidebar [data-gate]') return gatedNodes();
+      if (sel === '#app-sidebar .nav-item[data-count]') return countNodes();
+      return [];
+    },
     createElement() { return makeEl(); },
     addEventListener() {},
     dispatchEvent() {},
@@ -130,6 +159,14 @@ function boot({ page = 'settings', hash = '', pathname = '/settings' } = {}) {
       assert.ok(el, `nav item ${id} rendered`);
       return el.hidden;
     },
+    // task 1003737: what the badge on that item says right now — null when it is
+    // not showing, which is the state ZERO IS SILENT is about.
+    navBadge: (id) => {
+      const el = gatedEls.get('nav-' + id);
+      assert.ok(el, `nav item ${id} rendered`);
+      assert.ok(el._badge, `nav item ${id} declares a count`);
+      return el._badge.hidden ? null : { text: el._badge.textContent, label: el._label.textContent };
+    },
   };
 }
 
@@ -446,3 +483,115 @@ test('collapsible groups carry a stable storage key (collapse persistence)', ()
   assert.ok(!/nav-group--collapsible[^>]*>(?!<button)/.test(html.split('<div class="nav-group')[1] || ''),
     'the unlabeled project group stays always-expanded');
 });
+
+// ── a nav item can carry a COUNT badge (task 1003737) ───────────────────────
+//
+// The owner's ask: show that sittings wait on your vote WITHOUT going inside.
+// The count already rode /me (boardVotesNeed, pre-filtered to ballots this viewer
+// could actually cast); what the hall had was no badge/bell/dot mechanism of ANY
+// kind. These pin the MECHANISM, not the one consumer — the rules below are what
+// a second adopter (help requests, the idea inbox) inherits for free.
+
+const boardNeeds = (count, extra = {}) => ({
+  items: [{
+    id: 'board_votes', state: 'action_needed', count,
+    title: `${count} ideas are waiting on your vote`, ...extra,
+  }],
+});
+const seeingBoard = { authed: true, rank: 'xenos', permissions: { 'board.vote.cast': true } };
+
+test('THE ASK: a waiting sitting puts a count on the Board Room item', () => {
+  const b = boot();
+  b.shell.applyAccess({ ...seeingBoard, needs: boardNeeds(3) });
+  assert.deepEqual(b.navBadge('board-room'), { text: '3', label: '3 ideas are waiting on your vote' });
+});
+
+test('ZERO IS SILENT — and so is every other kind of nothing', () => {
+  // Five different nothings, one answer. A reader must not be able to tell an
+  // empty board from a /me that has not landed: both mean "nothing to act on".
+  const cases = {
+    'no needs key at all': undefined,
+    'needs is null (not yet told)': null,
+    'a roster with no board need': { items: [{ id: 'art_key', state: 'action_needed' }] },
+    'the need exists but counts zero': boardNeeds(0),
+    'a need carrying no count at all': { items: [{ id: 'board_votes', state: 'action_needed' }] },
+  };
+  for (const [name, needs] of Object.entries(cases)) {
+    const b = boot();
+    b.shell.applyAccess({ ...seeingBoard, needs });
+    assert.equal(b.navBadge('board-room'), null, `${name} → no badge`);
+  }
+});
+
+test('the founding grace silences the badge, because a badge is a demand', () => {
+  // computeNeeds rewrites every action_needed row to 'covered' during a new
+  // instance's first days, precisely so it does not greet its owner with demands.
+  // The count SURVIVES that rewrite (the grace spreads the row), so a badge keyed
+  // on the number alone would shout straight through the grace.
+  const b = boot();
+  b.shell.applyAccess({ ...seeingBoard, needs: boardNeeds(4, { state: 'covered' }) });
+  assert.equal(b.navBadge('board-room'), null, 'covered is not action_needed');
+});
+
+test('A BADGE NEVER OUT-RUNS ITS GATE — no count on a room you cannot see', () => {
+  // The disclosure rule. The count is real and the viewer holds no atom, so the
+  // item is hidden; the badge must not be written anyway. If it were, the DOM —
+  // and a screen reader walking it — would carry board activity to someone with
+  // no access to the room.
+  const b = boot();
+  b.shell.applyAccess({
+    authed: true, rank: 'archon', permissions: { 'board.vote.cast': false }, needs: boardNeeds(7),
+  });
+  assert.equal(b.navHidden('board-room'), true, 'precondition: the gate hides it');
+  assert.equal(b.navBadge('board-room'), null, 'a hidden item carries no count');
+});
+
+test('a badge already shown is CLEARED when access goes away', () => {
+  // The stale-count case: skipping hidden items rather than clearing them would
+  // leave the previous state's number sitting in the DOM after a sign-out.
+  const b = boot();
+  b.shell.applyAccess({ ...seeingBoard, needs: boardNeeds(2) });
+  assert.ok(b.navBadge('board-room'), 'precondition: it showed');
+  b.shell.applyAccess({ authed: false });
+  assert.equal(b.navBadge('board-room'), null, 'signing out takes the count with it');
+});
+
+test('a big count is capped rather than allowed to stretch the rail', () => {
+  const b = boot();
+  b.shell.applyAccess({ ...seeingBoard, needs: boardNeeds(140) });
+  assert.equal(b.navBadge('board-room').text, '99+');
+});
+
+test('the count reaches a screen reader as WORDS, not a floating numeral', () => {
+  // The numeral is aria-hidden decoration; the need's own sentence rides beside
+  // it in an sr-only span. "3" alone inside a link named Board Room says nothing.
+  const html = boot().sidebarHtml;
+  const item = html.split('<a class="nav-item"').find((t) => t.includes('id="nav-board-room"'));
+  assert.ok(item, 'the Board Room item renders');
+  assert.match(item, /class="nav-item__badge" data-badge aria-hidden="true" hidden/, 'the numeral is decoration');
+  assert.match(item, /class="sr-only" data-badge-label/, 'the words are what a reader gets');
+  // An item that declared no count grows neither node — the badge is opt-in.
+  const home = html.split('<a class="nav-item"').find((t) => t.includes('id="nav-home"'));
+  assert.ok(!/data-badge/.test(home), 'no count declared, no badge markup');
+});
+
+test('the mechanism is GENERIC — it keys on a declared need id, not on the board', () => {
+  // What makes a second consumer cheap: shell.js names a need id in `count:` and
+  // reads that row's number. Nothing in the badge path knows what a board IS, so
+  // adopting it is one field here plus one field on the need.
+  const fn = SRC.slice(SRC.indexOf('function applyCounts'), SRC.indexOf('// applyAccess({'));
+  assert.ok(fn.length > 0, 'applyCounts exists');
+  assert.ok(!/board/i.test(fn), 'the badge resolver names no specific need');
+  assert.match(fn, /dataset\.count/, 'it keys on the item’s own declared need id');
+});
+
+test('the badge is styled for BOTH shapes of the rail', () => {
+  // The rail is a 64px icon strip until hover/focus opens it, and the drawer is
+  // it permanently open with no hover to trigger anything. A badge positioned for
+  // one of the three reads wrong in the others, and no unit test would catch it.
+  const css = fs.readFileSync(path.join(HALL, 'style.css'), 'utf8');
+  assert.match(css, /\.nav-item__badge \{/, 'the collapsed (icon-only) position');
+  assert.match(css, /:focus-within \.nav-item__badge/, 'the open-rail position');
+  const drawer = css.slice(css.indexOf('html.drawer-open .app-sidebar'));
+  assert.match(drawer, /\.nav-item__badge \{ top: 50%/, 'the mobile drawer position');
+});

package/tests/rot_inbox.mjs

@@ -309,13 +309,89 @@ test('an unattributed thing is visible ONLY to canSeeAll — it has no creator t
     'a NULL creator must not be OR-ed into every builder\'s inbox');
 });
 
-test('each row carries the verbs for ITS tier, so the client never hardcodes the mapping', async () => {
-  expect({ rows: [rotRow(), rotRow({ tier: 'goal', id: '9' })] });
+test('each row carries the verbs for ITS tier AND ITS status, so the client never hardcodes the mapping', async () => {
+  expect({ rows: [rotRow(), rotRow({ tier: 'goal', id: '9', status: 'open' })] });
   const got = await rot.rottingFor({ builderId: 77, rotDays: 30 });
-  assert.deepEqual(got.rows[0].verbs.map((v) => v.verb), ['prioritise', 'prune', 'kill', 'water']);
+  // rotRow() is a BACKLOG task: promote accepts it, demote does not.
+  assert.deepEqual(got.rows[0].verbs.map((v) => v.verb), ['prioritise', 'kill', 'water']);
   assert.deepEqual(got.rows[1].verbs.map((v) => v.verb), ['kill', 'water']);
 });
 
+// ---- 4b. the offer must be the row's, not the tier's (task 1003751) ---------
+//
+// The regression this replaces: verbs were attached as `tier === 'task' ? TASK_VERBS
+// : GOAL_VERBS`, by tier only. Since TASK_ROTTABLE_STATUSES is exactly
+// ['backlog','ready'] and promote/demote accept disjoint sets, EVERY task line in
+// the feed shipped one button whose route answers 409 — a backlog row offered
+// Prune, a ready row offered Prioritise. The card's own header promises the
+// opposite ("the client renders what the server will actually accept").
+
+test('a backlog row is not offered Prune, and a ready row is not offered Prioritise', async () => {
+  expect({ rows: [rotRow({ status: 'backlog' }), rotRow({ id: '6', status: 'ready' })] });
+  const got = await rot.rottingFor({ builderId: 77, rotDays: 30 });
+  const backlog = got.rows[0].verbs.map((v) => v.verb);
+  const ready = got.rows[1].verbs.map((v) => v.verb);
+  assert.ok(!backlog.includes('prune'), "a backlog task is already at the bottom — /demote answers 409 cannot_demote");
+  assert.ok(backlog.includes('prioritise'), 'a backlog task is exactly what /promote is for');
+  assert.ok(!ready.includes('prioritise'), "a ready task is already claimable — /promote answers 409 cannot_promote");
+  assert.ok(ready.includes('prune'), 'ready is the only status /demote accepts');
+  // kill and water are unconditional across the rottable set, so no row loses them.
+  for (const offered of [backlog, ready]) {
+    assert.ok(offered.includes('kill') && offered.includes('water'),
+      'kill and water apply to every rottable row — narrowing must not drop them');
+  }
+});
+
+test('no verb is offered for a status its route would refuse, across the whole rottable set', () => {
+  // The end-to-end claim of this feature, checked against the route guards rather
+  // than against a second hardcoded list. Every status that can reach the feed,
+  // every verb attached to it, must name a route that accepts that status.
+  for (const status of rot.TASK_ROTTABLE_STATUSES) {
+    const offered = rot.verbsFor('task', status).map((v) => v.verb);
+    assert.ok(offered.length > 0, `status '${status}' was offered no verbs at all`);
+    for (const verb of offered) {
+      const accepts = rot.TASK_VERB_ACCEPTS[verb];
+      assert.ok(!accepts || accepts.includes(status),
+        `verb '${verb}' is offered on a '${status}' row but its route accepts only [${accepts}] — that button 409s`);
+    }
+  }
+});
+
+test('the accepted-status map is the one the ROUTES actually enforce', () => {
+  // The unavoidable-copy pairing guard, in the same spirit as the rot-clock check
+  // against migration core_231: rot.js must mirror routes/tasks.js, so read the
+  // guards back out of the route source and fail if they have drifted apart.
+  const TASKS_SRC = readFileSync(join(ROOT, 'modules/lifecycle/routes/tasks.js'), 'utf8');
+
+  const promoteGuard = /if \(!\[([^\]]*)\]\.includes\(task\.status\)\)\s*\{\s*return res\.fail\('cannot_promote'/.exec(TASKS_SRC);
+  assert.ok(promoteGuard, "could not find /promote's status guard in routes/tasks.js — if it was reshaped, re-derive TASK_VERB_ACCEPTS.prioritise from the new shape");
+  const promoteAccepts = promoteGuard[1].split(',').map((x) => x.trim().replace(/^'|'$/g, '')).filter(Boolean);
+  assert.deepEqual(
+    [...rot.TASK_VERB_ACCEPTS.prioritise].sort(), promoteAccepts.sort(),
+    'TASK_VERB_ACCEPTS.prioritise no longer matches what POST /tasks/:id/promote accepts — the rot card would offer (or withhold) a Prioritise button wrongly'
+  );
+
+  const demoteGuard = /if \(task\.status !== '([^']+)'\)\s*\{\s*return res\.fail\('cannot_demote'/.exec(TASKS_SRC);
+  assert.ok(demoteGuard, "could not find /demote's status guard in routes/tasks.js — if it was reshaped, re-derive TASK_VERB_ACCEPTS.prune from the new shape");
+  assert.deepEqual(
+    [...rot.TASK_VERB_ACCEPTS.prune], [demoteGuard[1]],
+    'TASK_VERB_ACCEPTS.prune no longer matches what POST /tasks/:id/demote accepts'
+  );
+});
+
+test('every key in the accepted-status map is a real task verb', () => {
+  // A typo'd key would silently make its verb UNCONDITIONAL (absent = no filter),
+  // which is the exact bug this map exists to fix, reintroduced quietly.
+  const known = new Set(rot.TASK_VERBS.map((v) => v.verb));
+  for (const verb of Object.keys(rot.TASK_VERB_ACCEPTS)) {
+    assert.ok(known.has(verb), `'${verb}' is not a declared task verb — a stale key filters nothing`);
+  }
+});
+
+test('a goal row keeps both its verbs — neither goal route is status-conditional here', () => {
+  assert.deepEqual(rot.verbsFor('goal', 'open').map((v) => v.verb), ['kill', 'water']);
+});
+
 // ---- 5. the timer resolver: precedence + the reporting fail posture ---------
 
 test('no row anywhere = the documented default, and it says so', async () => {